diff --git a/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/INSTALLER b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/LICENSE.txt b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..e497a322f2091d022983b9c5c043082ab61d1a8c --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/LICENSE.txt @@ -0,0 +1,13 @@ + Copyright aio-libs contributors. + + 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/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/METADATA b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..4e74e2da9aada7779b0df57fca1cc4ade9cf90b8 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/METADATA @@ -0,0 +1,250 @@ +Metadata-Version: 2.2 +Name: aiohttp +Version: 3.11.12 +Summary: Async http client/server framework (asyncio) +Home-page: https://github.com/aio-libs/aiohttp +Maintainer: aiohttp team +Maintainer-email: team@aiohttp.org +License: Apache-2.0 +Project-URL: Chat: Matrix, https://matrix.to/#/#aio-libs:matrix.org +Project-URL: Chat: Matrix Space, https://matrix.to/#/#aio-libs-space:matrix.org +Project-URL: CI: GitHub Actions, https://github.com/aio-libs/aiohttp/actions?query=workflow%3ACI +Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/aiohttp +Project-URL: Docs: Changelog, https://docs.aiohttp.org/en/stable/changes.html +Project-URL: Docs: RTD, https://docs.aiohttp.org +Project-URL: GitHub: issues, https://github.com/aio-libs/aiohttp/issues +Project-URL: GitHub: repo, https://github.com/aio-libs/aiohttp +Classifier: Development Status :: 5 - Production/Stable +Classifier: Framework :: AsyncIO +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Operating System :: POSIX +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Operating System :: Microsoft :: Windows +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Topic :: Internet :: WWW/HTTP +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE.txt +Requires-Dist: aiohappyeyeballs>=2.3.0 +Requires-Dist: aiosignal>=1.1.2 +Requires-Dist: async-timeout<6.0,>=4.0; python_version < "3.11" +Requires-Dist: attrs>=17.3.0 +Requires-Dist: frozenlist>=1.1.1 +Requires-Dist: multidict<7.0,>=4.5 +Requires-Dist: propcache>=0.2.0 +Requires-Dist: yarl<2.0,>=1.17.0 +Provides-Extra: speedups +Requires-Dist: aiodns>=3.2.0; (sys_platform == "linux" or sys_platform == "darwin") and extra == "speedups" +Requires-Dist: Brotli; platform_python_implementation == "CPython" and extra == "speedups" +Requires-Dist: brotlicffi; platform_python_implementation != "CPython" and extra == "speedups" + +================================== +Async http client/server framework +================================== + +.. image:: https://raw.githubusercontent.com/aio-libs/aiohttp/master/docs/aiohttp-plain.svg + :height: 64px + :width: 64px + :alt: aiohttp logo + +| + +.. image:: https://github.com/aio-libs/aiohttp/workflows/CI/badge.svg + :target: https://github.com/aio-libs/aiohttp/actions?query=workflow%3ACI + :alt: GitHub Actions status for master branch + +.. image:: https://codecov.io/gh/aio-libs/aiohttp/branch/master/graph/badge.svg + :target: https://codecov.io/gh/aio-libs/aiohttp + :alt: codecov.io status for master branch + +.. image:: https://img.shields.io/endpoint?url=https://codspeed.io/badge.json + :target: https://codspeed.io/aio-libs/aiohttp + :alt: Codspeed.io status for aiohttp + +.. image:: https://badge.fury.io/py/aiohttp.svg + :target: https://pypi.org/project/aiohttp + :alt: Latest PyPI package version + +.. image:: https://readthedocs.org/projects/aiohttp/badge/?version=latest + :target: https://docs.aiohttp.org/ + :alt: Latest Read The Docs + +.. image:: https://img.shields.io/matrix/aio-libs:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat + :target: https://matrix.to/#/%23aio-libs:matrix.org + :alt: Matrix Room — #aio-libs:matrix.org + +.. image:: https://img.shields.io/matrix/aio-libs-space:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs-space%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat + :target: https://matrix.to/#/%23aio-libs-space:matrix.org + :alt: Matrix Space — #aio-libs-space:matrix.org + + +Key Features +============ + +- Supports both client and server side of HTTP protocol. +- Supports both client and server Web-Sockets out-of-the-box and avoids + Callback Hell. +- Provides Web-server with middleware and pluggable routing. + + +Getting started +=============== + +Client +------ + +To get something from the web: + +.. code-block:: python + + import aiohttp + import asyncio + + async def main(): + + async with aiohttp.ClientSession() as session: + async with session.get('http://python.org') as response: + + print("Status:", response.status) + print("Content-type:", response.headers['content-type']) + + html = await response.text() + print("Body:", html[:15], "...") + + asyncio.run(main()) + +This prints: + +.. code-block:: + + Status: 200 + Content-type: text/html; charset=utf-8 + Body: ... + +Coming from `requests `_ ? Read `why we need so many lines `_. + +Server +------ + +An example using a simple server: + +.. code-block:: python + + # examples/server_simple.py + from aiohttp import web + + async def handle(request): + name = request.match_info.get('name', "Anonymous") + text = "Hello, " + name + return web.Response(text=text) + + async def wshandle(request): + ws = web.WebSocketResponse() + await ws.prepare(request) + + async for msg in ws: + if msg.type == web.WSMsgType.text: + await ws.send_str("Hello, {}".format(msg.data)) + elif msg.type == web.WSMsgType.binary: + await ws.send_bytes(msg.data) + elif msg.type == web.WSMsgType.close: + break + + return ws + + + app = web.Application() + app.add_routes([web.get('/', handle), + web.get('/echo', wshandle), + web.get('/{name}', handle)]) + + if __name__ == '__main__': + web.run_app(app) + + +Documentation +============= + +https://aiohttp.readthedocs.io/ + + +Demos +===== + +https://github.com/aio-libs/aiohttp-demos + + +External links +============== + +* `Third party libraries + `_ +* `Built with aiohttp + `_ +* `Powered by aiohttp + `_ + +Feel free to make a Pull Request for adding your link to these pages! + + +Communication channels +====================== + +*aio-libs Discussions*: https://github.com/aio-libs/aiohttp/discussions + +*Matrix*: `#aio-libs:matrix.org `_ + +We support `Stack Overflow +`_. +Please add *aiohttp* tag to your question there. + +Requirements +============ + +- attrs_ +- multidict_ +- yarl_ +- frozenlist_ + +Optionally you may install the aiodns_ library (highly recommended for sake of speed). + +.. _aiodns: https://pypi.python.org/pypi/aiodns +.. _attrs: https://github.com/python-attrs/attrs +.. _multidict: https://pypi.python.org/pypi/multidict +.. _frozenlist: https://pypi.org/project/frozenlist/ +.. _yarl: https://pypi.python.org/pypi/yarl +.. _async-timeout: https://pypi.python.org/pypi/async_timeout + +License +======= + +``aiohttp`` is offered under the Apache 2 license. + + +Keepsafe +======== + +The aiohttp community would like to thank Keepsafe +(https://www.getkeepsafe.com) for its support in the early days of +the project. + + +Source code +=========== + +The latest developer version is available in a GitHub repository: +https://github.com/aio-libs/aiohttp + +Benchmarks +========== + +If you are interested in efficiency, the AsyncIO community maintains a +list of benchmarks on the official wiki: +https://github.com/python/asyncio/wiki/Benchmarks diff --git a/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/RECORD b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..6c686164ec545cf84b662a78f07a1a95e0107b73 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/RECORD @@ -0,0 +1,131 @@ +aiohttp-3.11.12.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +aiohttp-3.11.12.dist-info/LICENSE.txt,sha256=n4DQ2311WpQdtFchcsJw7L2PCCuiFd3QlZhZQu2Uqes,588 +aiohttp-3.11.12.dist-info/METADATA,sha256=d7xgT5HQPw4R1cWYIK6lQbOoCkFYV5505hAhDZWALcA,7712 +aiohttp-3.11.12.dist-info/RECORD,, +aiohttp-3.11.12.dist-info/WHEEL,sha256=bWgrYGwmr1oqID2askDfuFruhD_BtRXYD33vDqPTClc,151 +aiohttp-3.11.12.dist-info/top_level.txt,sha256=iv-JIaacmTl-hSho3QmphcKnbRRYx1st47yjz_178Ro,8 +aiohttp/.hash/_cparser.pxd.hash,sha256=hYa9Vje-oMs2eh_7MfCPOh2QW_1x1yCjcZuc7AmwLd0,121 +aiohttp/.hash/_find_header.pxd.hash,sha256=_mbpD6vM-CVCKq3ulUvsOAz5Wdo88wrDzfpOsMQaMNA,125 +aiohttp/.hash/_http_parser.pyx.hash,sha256=GBgZjCNbtZApPhf9-gHpS5Z2WMIzM-vgp5VSZIEvZfk,125 +aiohttp/.hash/_http_writer.pyx.hash,sha256=-UgSF82qclpxjP0og_gcFEsstXRKF9e3Ou4wziAyDvI,125 +aiohttp/.hash/hdrs.py.hash,sha256=v6IaKbsxjsdQxBzhb5AjP0x_9G3rUe84D7avf7AI4cs,116 +aiohttp/__init__.py,sha256=NFDgrak_EkgNNzRQ9Ka63rIzkN_IYocFcIERyltx5ys,7840 +aiohttp/__pycache__/__init__.cpython-311.pyc,, +aiohttp/__pycache__/abc.cpython-311.pyc,, +aiohttp/__pycache__/base_protocol.cpython-311.pyc,, +aiohttp/__pycache__/client.cpython-311.pyc,, +aiohttp/__pycache__/client_exceptions.cpython-311.pyc,, +aiohttp/__pycache__/client_proto.cpython-311.pyc,, +aiohttp/__pycache__/client_reqrep.cpython-311.pyc,, +aiohttp/__pycache__/client_ws.cpython-311.pyc,, +aiohttp/__pycache__/compression_utils.cpython-311.pyc,, +aiohttp/__pycache__/connector.cpython-311.pyc,, +aiohttp/__pycache__/cookiejar.cpython-311.pyc,, +aiohttp/__pycache__/formdata.cpython-311.pyc,, +aiohttp/__pycache__/hdrs.cpython-311.pyc,, +aiohttp/__pycache__/helpers.cpython-311.pyc,, +aiohttp/__pycache__/http.cpython-311.pyc,, +aiohttp/__pycache__/http_exceptions.cpython-311.pyc,, +aiohttp/__pycache__/http_parser.cpython-311.pyc,, +aiohttp/__pycache__/http_websocket.cpython-311.pyc,, +aiohttp/__pycache__/http_writer.cpython-311.pyc,, +aiohttp/__pycache__/log.cpython-311.pyc,, +aiohttp/__pycache__/multipart.cpython-311.pyc,, +aiohttp/__pycache__/payload.cpython-311.pyc,, +aiohttp/__pycache__/payload_streamer.cpython-311.pyc,, +aiohttp/__pycache__/pytest_plugin.cpython-311.pyc,, +aiohttp/__pycache__/resolver.cpython-311.pyc,, +aiohttp/__pycache__/streams.cpython-311.pyc,, +aiohttp/__pycache__/tcp_helpers.cpython-311.pyc,, +aiohttp/__pycache__/test_utils.cpython-311.pyc,, +aiohttp/__pycache__/tracing.cpython-311.pyc,, +aiohttp/__pycache__/typedefs.cpython-311.pyc,, +aiohttp/__pycache__/web.cpython-311.pyc,, +aiohttp/__pycache__/web_app.cpython-311.pyc,, +aiohttp/__pycache__/web_exceptions.cpython-311.pyc,, +aiohttp/__pycache__/web_fileresponse.cpython-311.pyc,, +aiohttp/__pycache__/web_log.cpython-311.pyc,, +aiohttp/__pycache__/web_middlewares.cpython-311.pyc,, +aiohttp/__pycache__/web_protocol.cpython-311.pyc,, +aiohttp/__pycache__/web_request.cpython-311.pyc,, +aiohttp/__pycache__/web_response.cpython-311.pyc,, +aiohttp/__pycache__/web_routedef.cpython-311.pyc,, +aiohttp/__pycache__/web_runner.cpython-311.pyc,, +aiohttp/__pycache__/web_server.cpython-311.pyc,, +aiohttp/__pycache__/web_urldispatcher.cpython-311.pyc,, +aiohttp/__pycache__/web_ws.cpython-311.pyc,, +aiohttp/__pycache__/worker.cpython-311.pyc,, +aiohttp/_cparser.pxd,sha256=8jGIg-VJ9p3llwCakUYDsPGxA4HiZe9dmK9Jmtlz-5g,4318 +aiohttp/_find_header.pxd,sha256=0GfwFCPN2zxEKTO1_MA5sYq2UfzsG8kcV3aTqvwlz3g,68 +aiohttp/_headers.pxi,sha256=n701k28dVPjwRnx5j6LpJhLTfj7dqu2vJt7f0O60Oyg,2007 +aiohttp/_http_parser.cpython-311-x86_64-linux-gnu.so,sha256=rulksFv5PZ7AOPoQuR2P1THFflfukMumxkEfRfdFk0Y,2826344 +aiohttp/_http_parser.pyx,sha256=wQdADj5LizwC_7nFGr8nIlk6GpoaQeQ0359H0HMKGuM,28241 +aiohttp/_http_writer.cpython-311-x86_64-linux-gnu.so,sha256=zMYCtCYo-xjYJpSCcVx6UdBpGSHm_pMgnpM7JUmsWXA,463752 +aiohttp/_http_writer.pyx,sha256=fiCck_EVgRiTX7VtAoV2AldjuesJMFPev4TWd9Fx8jo,4597 +aiohttp/_websocket/.hash/mask.pxd.hash,sha256=Y0zBddk_ck3pi9-BFzMcpkcvCKvwvZ4GTtZFb9u1nxQ,128 +aiohttp/_websocket/.hash/mask.pyx.hash,sha256=90owpXYM8_kIma4KUcOxhWSk-Uv4NVMBoCYeFM1B3d0,128 +aiohttp/_websocket/.hash/reader_c.pxd.hash,sha256=EoZjkF_tAFEbGvV0oRY2GZOSuAfWFWFjMhXgq6mQExo,132 +aiohttp/_websocket/__init__.py,sha256=Mar3R9_vBN_Ea4lsW7iTAVXD7OKswKPGqF5xgSyt77k,44 +aiohttp/_websocket/__pycache__/__init__.cpython-311.pyc,, +aiohttp/_websocket/__pycache__/helpers.cpython-311.pyc,, +aiohttp/_websocket/__pycache__/models.cpython-311.pyc,, +aiohttp/_websocket/__pycache__/reader.cpython-311.pyc,, +aiohttp/_websocket/__pycache__/reader_c.cpython-311.pyc,, +aiohttp/_websocket/__pycache__/reader_py.cpython-311.pyc,, +aiohttp/_websocket/__pycache__/writer.cpython-311.pyc,, +aiohttp/_websocket/helpers.py,sha256=P-XLv8IUaihKzDenVUqfKU5DJbWE5HvG8uhvUZK8Ic4,5038 +aiohttp/_websocket/mask.cpython-311-x86_64-linux-gnu.so,sha256=hq3aHe5ZVl5ENFRtaXjZcSrbS-ITBwqGgEneGVphY1w,245952 +aiohttp/_websocket/mask.pxd,sha256=sBmZ1Amym9kW4Ge8lj1fLZ7mPPya4LzLdpkQExQXv5M,112 +aiohttp/_websocket/mask.pyx,sha256=BHjOtV0O0w7xp9p0LNADRJvGmgfPn9sGeJvSs0fL__4,1397 +aiohttp/_websocket/models.py,sha256=XAzjs_8JYszWXIgZ6R3ZRrF-tX9Q_6LiD49WRYojopM,2121 +aiohttp/_websocket/reader.py,sha256=eC4qS0c5sOeQ2ebAHLaBpIaTVFaSKX79pY2xvh3Pqyw,1030 +aiohttp/_websocket/reader_c.cpython-311-x86_64-linux-gnu.so,sha256=bnETOmm4gSxKkarM68sAEhBjSd_bQt0GgDD2W7V8cUQ,1906008 +aiohttp/_websocket/reader_c.pxd,sha256=9rMWCpAC1jng7_gtqLjRlqQv9q7UkOn63tIQfq2k8Gc,2444 +aiohttp/_websocket/reader_c.py,sha256=anZsBKZWlL8SO8gArsZMDstH37qBuZOvJA7jtj0Z95M,17975 +aiohttp/_websocket/reader_py.py,sha256=anZsBKZWlL8SO8gArsZMDstH37qBuZOvJA7jtj0Z95M,17975 +aiohttp/_websocket/writer.py,sha256=T3P36iMrzVPPC2XeScserHMD5vd9an6yizWzqDUkRZ0,7077 +aiohttp/abc.py,sha256=JLMOxrKLGTDaPRLfraY1pl-xka53YiHhAH9yaF9QRXQ,6512 +aiohttp/base_protocol.py,sha256=Tp8cxUPQvv9kUPk3w6lAzk6d2MAzV3scwI_3Go3C47c,3025 +aiohttp/client.py,sha256=isdfGlM4O5ILr4F4gBABlybxo4MQ1tNaMm7zjMcrfrM,54309 +aiohttp/client_exceptions.py,sha256=uyKbxI2peZhKl7lELBMx3UeusNkfpemPWpGFq0r6JeM,11367 +aiohttp/client_proto.py,sha256=dV7u9floGWG-_xtD2fLUYqiANG6VsJtq0HMlTjf1g-g,10015 +aiohttp/client_reqrep.py,sha256=VAgh0NxP2HvYWx6nX1Pr8FINc1m-W8-5q2zKeZV68n8,43925 +aiohttp/client_ws.py,sha256=_n4hVk71H5rK8TFOIYT0bPTIHOmMCQ3FDFSrU7ctpfI,15031 +aiohttp/compression_utils.py,sha256=0J3EAOR-0HehlYIudJXRu_Kr6hrYCY0IfuJ1px9MhQs,5681 +aiohttp/connector.py,sha256=yW8vyZz4cmXbScbBkCneMF0giSl0WZPJ2NnNw-TegbQ,60225 +aiohttp/cookiejar.py,sha256=PYR1K1mkLa24Hm6c9UEJnAitccNzz97CbsJyQ2ULAlU,17615 +aiohttp/formdata.py,sha256=CUJnCWDNHFcXSYZ_TupaT6rHkY-Q7ghssvWzaYBPIo0,6552 +aiohttp/hdrs.py,sha256=2rj5MyA-6yRdYPhW5UKkW4iNWhEAlGIOSBH5D4FmKNE,5111 +aiohttp/helpers.py,sha256=KqPQECeiJ_EhA93k7-5ZoVdZH0sk_4n0tCoM_E-iMnE,29091 +aiohttp/http.py,sha256=8o8j8xH70OWjnfTWA9V44NR785QPxEPrUtzMXiAVpwc,1842 +aiohttp/http_exceptions.py,sha256=RYmBycJvvPerKkgXXm8v145I1N-fbsgSpcsbNIC-gdE,2961 +aiohttp/http_parser.py,sha256=UqerYPJzA1MqLmeG1jURhTNO1YhwUASK3QVcNEz0me8,36851 +aiohttp/http_websocket.py,sha256=8VXFKw6KQUEmPg48GtRMB37v0gTK7A0inoxXuDxMZEc,842 +aiohttp/http_writer.py,sha256=pRIyfOmL3cZmdWDWBBJ2cZEwEJzLWzlPPAJInaPLThI,7595 +aiohttp/log.py,sha256=BbNKx9e3VMIm0xYjZI0IcBBoS7wjdeIeSaiJE7-qK2g,325 +aiohttp/multipart.py,sha256=SABIvo3vhXzG4bLDZ0C4V3yG_86vAb-3Zb9Li7BVmI8,36944 +aiohttp/payload.py,sha256=rCA9JJI_RMCik_7qNIaC1Bh21aXhABGYK2tsYeaHRQ4,15793 +aiohttp/payload_streamer.py,sha256=ZzEYyfzcjGWkVkK3XR2pBthSCSIykYvY3Wr5cGQ2eTc,2211 +aiohttp/py.typed,sha256=sow9soTwP9T_gEAQSVh7Gb8855h04Nwmhs2We-JRgZM,7 +aiohttp/pytest_plugin.py,sha256=AfJ6VIWzsp5KgpXRREsX3yqGUZrJyfb7zzcMqzWxz7I,12768 +aiohttp/resolver.py,sha256=sJ8-LYCtl_g9f6gn_5X2NFQ9FQ72Q2Mr4_rLxo9NVeI,6375 +aiohttp/streams.py,sha256=U-qTkuAqIfpJChuKEy-vYn8nQ_Z1MVcW0WO2DHiJz_o,22329 +aiohttp/tcp_helpers.py,sha256=BSadqVWaBpMFDRWnhaaR941N9MiDZ7bdTrxgCb0CW-M,961 +aiohttp/test_utils.py,sha256=r7kBasmZtC3tQY5OmyMaIl1B9P8Bnnq1oM3npVcAPKs,22811 +aiohttp/tracing.py,sha256=66XQwtdR5DHv8p953eeNL0l8o6iHDaNwH9bBaybHXD4,15137 +aiohttp/typedefs.py,sha256=wUlqwe9Mw9W8jT3HsYJcYk00qP3EMPz3nTkYXmeNN48,1657 +aiohttp/web.py,sha256=As5nqGQy4QXWMXSaOsh0JudSVVJVIt_nr3n0b8CaMb0,18422 +aiohttp/web_app.py,sha256=Zre0QHM9JAp4d7jrj5NRxlPnfTrKLNuA42Rdsh8Q2TI,19554 +aiohttp/web_exceptions.py,sha256=7nIuiwhZ39vJJ9KrWqArA5QcWbUdqkz2CLwEpJapeN8,10360 +aiohttp/web_fileresponse.py,sha256=FRsS0p9r1KU5y8ceG0QXBYnrL6xggjbxcXSmI6qIR4k,16504 +aiohttp/web_log.py,sha256=rX5D7xLOX2B6BMdiZ-chme_KfJfW5IXEoFwLfkfkajs,7865 +aiohttp/web_middlewares.py,sha256=sFI0AgeNjdyAjuz92QtMIpngmJSOxrqe2Jfbs4BNUu0,4165 +aiohttp/web_protocol.py,sha256=PMCLcrUlC_-2U9ZxnMyWFiaekNvbswmXiIdmhRcMLHM,25630 +aiohttp/web_request.py,sha256=j_SSX9s-d3ZeNyqUTpFIaPUaNdSqHwb7yfc0ufL8xFA,29750 +aiohttp/web_response.py,sha256=65aliDETi7rZ8P76ksuHQI0ZTu1cKpclCSailNu105M,28696 +aiohttp/web_routedef.py,sha256=VT1GAx6BrawoDh5RwBwBu5wSABSqgWwAe74AUCyZAEo,6110 +aiohttp/web_runner.py,sha256=v1G1nKiOOQgFnTSR4IMc6I9ReEFDMaHtMLvO_roDM-A,11786 +aiohttp/web_server.py,sha256=-9WDKUAiR9ll-rSdwXSqG6YjaoW79d1R4y0BGSqgUMA,2888 +aiohttp/web_urldispatcher.py,sha256=TIMxFmhLjERseG0xcZv2Ef9Xuo_GTBRqBqeMkCgL0K8,43825 +aiohttp/web_ws.py,sha256=EOQX3LYqlrkNQHlFTaNpZkQpOYRCZfR-m1bHT4Iseq8,22488 +aiohttp/worker.py,sha256=0lvxRNMjGM47ddlQWtci53ri9YN42Su1Vdd_Z7zMMH0,8040 diff --git a/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/WHEEL b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..df22dde0af3b0676d738413aed55b371bef5b4df --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.8.0) +Root-Is-Purelib: false +Tag: cp311-cp311-manylinux_2_17_x86_64 +Tag: cp311-cp311-manylinux2014_x86_64 + diff --git a/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/top_level.txt b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..ee4ba4f3d739e094878215c84eb41ba85c80e4a8 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/top_level.txt @@ -0,0 +1 @@ +aiohttp diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__about__.py b/.venv/lib/python3.11/site-packages/aiohttp_cors/__about__.py new file mode 100644 index 0000000000000000000000000000000000000000..51c484189c1cc14c276883eb01dacfbafbb1cebc --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp_cors/__about__.py @@ -0,0 +1,28 @@ +# Copyright 2015 Vladimir Rutsky +# +# 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. + +""" +Library meta information. + +This module must be stand-alone executable. +""" + +__title__ = "aiohttp-cors" +__version__ = "0.7.0" +__author__ = "Vladimir Rutsky and aio-libs team" +__email__ = "vladimir@rutsky.org" +__summary__ = "CORS support for aiohttp" +__uri__ = "https://github.com/aio-libs/aiohttp-cors" +__license__ = "Apache License, Version 2.0" +__copyright__ = "2015-2018 {}".format(__author__) diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__init__.py b/.venv/lib/python3.11/site-packages/aiohttp_cors/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbcc5ef6d1cfb39e350281c1a3b4b4789afcde8b --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp_cors/__init__.py @@ -0,0 +1,67 @@ +# Copyright 2015 Vladimir Rutsky +# +# 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. + +"""CORS support for aiohttp. +""" + +from typing import Mapping, Union, Any + +from aiohttp import web + +from .__about__ import ( + __title__, __version__, __author__, __email__, __summary__, __uri__, + __license__, __copyright__, +) +from .resource_options import ResourceOptions +from .cors_config import CorsConfig +from .mixin import CorsViewMixin, custom_cors + +__all__ = ( + "__title__", "__version__", "__author__", "__email__", "__summary__", + "__uri__", "__license__", "__copyright__", + "setup", "CorsConfig", "ResourceOptions", "CorsViewMixin", "custom_cors" +) + + +APP_CONFIG_KEY = "aiohttp_cors" + + +def setup(app: web.Application, *, + defaults: Mapping[str, Union[ResourceOptions, + Mapping[str, Any]]]=None) -> CorsConfig: + """Setup CORS processing for the application. + + To enable CORS for a resource you need to explicitly add route for + that resource using `CorsConfig.add()` method:: + + app = aiohttp.web.Application() + cors = aiohttp_cors.setup(app) + cors.add( + app.router.add_route("GET", "/resource", handler), + { + "*": aiohttp_cors.ResourceOptions( + allow_credentials=True, + expose_headers="*", + allow_headers="*"), + }) + + :param app: + The application for which CORS will be configured. + :param defaults: + Default settings for origins. + ) + """ + cors = CorsConfig(app, defaults=defaults) + app[APP_CONFIG_KEY] = cors + return cors diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/__about__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/__about__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1cc33298436386a2b764c6e004c77999065ea3a8 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/__about__.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..28076c25bf5d18b39f6164c584a637d2b2b0c6ad Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/__init__.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/abc.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/abc.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bcd700392a61b903a7ef63a1c290f300a1ec215c Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/abc.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/cors_config.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/cors_config.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..663a2cb0f40fedd9d52f156ef0ca1ca169fef94f Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/cors_config.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/mixin.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/mixin.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..816b0ca23e28dcb849aa3b5968bd6ca9fbda6781 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/mixin.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/preflight_handler.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/preflight_handler.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..01b6e6e2e6a7bc2dd9955250795e9d7fd627c075 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/preflight_handler.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/resource_options.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/resource_options.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3e1a78626a0b2fe370f2ac050671806fed19e5b Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/resource_options.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/urldispatcher_router_adapter.cpython-311.pyc b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/urldispatcher_router_adapter.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec3e876d9d7db78f118669e9fe6f4e45ad8e3088 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/aiohttp_cors/__pycache__/urldispatcher_router_adapter.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/abc.py b/.venv/lib/python3.11/site-packages/aiohttp_cors/abc.py new file mode 100644 index 0000000000000000000000000000000000000000..5204a836759d93c46f3d8d77bb8981b5d555abef --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp_cors/abc.py @@ -0,0 +1,100 @@ +# Copyright 2015 Vladimir Rutsky +# +# 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. + +"""Abstract base classes. +""" + +from abc import ABCMeta, abstractmethod + +from aiohttp import web + + +__all__ = ("AbstractRouterAdapter",) + + +class AbstractRouterAdapter(metaclass=ABCMeta): + """Router adapter for handling CORS configuration interface. + + `AbstractRouter` doesn't specify how HTTP requests are delivered + to handlers, and aiohttp_cors doesn't rely on specific implementation + details. + + In general Router can be seen as a substance that allows to setup handlers + for specific HTTP methods and requests paths, lets call these Router's + items routing entities. + Generic Router is configured with set of routing entities and their + handlers. + + This adapter assumes that its reasonable to configure CORS for same + routing entities as used in `AbstractRouter`. + Routing entities will be added to CorsConfig to enable CORS for them. + + For example, for aiohttp < 0.21.0 routing entity would be + `aiohttp.web.Route` — tuple of (HTTP method, URI path). + And CORS can be configured for each `aiohttp.web.Route`. + + In aiohttp >= 0.21.0 there are two routing entities: Resource and Route. + You can configure CORS for Resource (which will be interpreted as default + for all Routes on Resoures), and configure CORS for specific Route. + """ + + @abstractmethod + def add_preflight_handler(self, + routing_entity, + handler, + webview: bool=False): + """Add OPTIONS handler for all routes defined by `routing_entity`. + + Does nothing if CORS handler already handles routing entity. + Should fail if there are conflicting user-defined OPTIONS handlers. + """ + + @abstractmethod + def is_preflight_request(self, request: web.Request) -> bool: + """Is `request` is a CORS preflight request.""" + + @abstractmethod + def is_cors_enabled_on_request(self, request: web.Request) -> bool: + """Is `request` is a request for CORS-enabled resource.""" + + @abstractmethod + def set_config_for_routing_entity(self, + routing_entity, + config): + """Record configuration for routing entity. + + If router implements hierarchical routing entities, stored config + can be used in hierarchical manner too. + + Should raise if there is conflicting configuration for the routing + entity. + """ + + @abstractmethod + async def get_preflight_request_config( + self, + preflight_request: web.Request, + origin: str, + requested_method: str): + """Get stored CORS configuration for specified HTTP method and origin + that corresponds to preflight request. + + Should raise KeyError if CORS is not configured or not enabled + for specified HTTP method. + """ + + @abstractmethod + def get_non_preflight_request_config(self, request: web.Request): + """Get stored CORS configuration for routing entity that handles + specified request.""" diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/cors_config.py b/.venv/lib/python3.11/site-packages/aiohttp_cors/cors_config.py new file mode 100644 index 0000000000000000000000000000000000000000..2e1aeeaf510ad6e1e2bfb49aef5467707b3185b0 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp_cors/cors_config.py @@ -0,0 +1,263 @@ +# Copyright 2015 Vladimir Rutsky +# +# 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. + +"""CORS configuration container class definition. +""" + +import collections +import warnings +from typing import Mapping, Union, Any + +from aiohttp import hdrs, web + +from .urldispatcher_router_adapter import ResourcesUrlDispatcherRouterAdapter +from .abc import AbstractRouterAdapter +from .resource_options import ResourceOptions +from .preflight_handler import _PreflightHandler + +__all__ = ( + "CorsConfig", +) + +# Positive response to Access-Control-Allow-Credentials +_TRUE = "true" +# CORS simple response headers: +# +_SIMPLE_RESPONSE_HEADERS = frozenset([ + hdrs.CACHE_CONTROL, + hdrs.CONTENT_LANGUAGE, + hdrs.CONTENT_TYPE, + hdrs.EXPIRES, + hdrs.LAST_MODIFIED, + hdrs.PRAGMA +]) + + +def _parse_config_options( + config: Mapping[str, Union[ResourceOptions, Mapping[str, Any]]]=None): + """Parse CORS configuration (default or per-route) + + :param config: + Mapping from Origin to Resource configuration (allowed headers etc) + defined either as mapping or `ResourceOptions` instance. + + Raises `ValueError` if configuration is not correct. + """ + + if config is None: + return {} + + if not isinstance(config, collections.abc.Mapping): + raise ValueError( + "Config must be mapping, got '{}'".format(config)) + + parsed = {} + + options_keys = { + "allow_credentials", "expose_headers", "allow_headers", "max_age" + } + + for origin, options in config.items(): + # TODO: check that all origins are properly formatted. + # This is not a security issue, since origin is compared as strings. + if not isinstance(origin, str): + raise ValueError( + "Origin must be string, got '{}'".format(origin)) + + if isinstance(options, ResourceOptions): + resource_options = options + + else: + if not isinstance(options, collections.abc.Mapping): + raise ValueError( + "Origin options must be either " + "aiohttp_cors.ResourceOptions instance or mapping, " + "got '{}'".format(options)) + + unexpected_args = frozenset(options.keys()) - options_keys + if unexpected_args: + raise ValueError( + "Unexpected keywords in resource options: {}".format( + # pylint: disable=bad-builtin + ",".join(map(str, unexpected_args)))) + + resource_options = ResourceOptions(**options) + + parsed[origin] = resource_options + + return parsed + + +_ConfigType = Mapping[str, Union[ResourceOptions, Mapping[str, Any]]] + + +class _CorsConfigImpl(_PreflightHandler): + + def __init__(self, + app: web.Application, + router_adapter: AbstractRouterAdapter): + self._app = app + + self._router_adapter = router_adapter + + # Register hook for all responses. This hook handles CORS-related + # headers on non-preflight requests. + self._app.on_response_prepare.append(self._on_response_prepare) + + def add(self, + routing_entity, + config: _ConfigType=None): + """Enable CORS for specific route or resource. + + If route is passed CORS is enabled for route's resource. + + :param routing_entity: + Route or Resource for which CORS should be enabled. + :param config: + CORS options for the route. + :return: `routing_entity`. + """ + + parsed_config = _parse_config_options(config) + + self._router_adapter.add_preflight_handler( + routing_entity, self._preflight_handler) + self._router_adapter.set_config_for_routing_entity( + routing_entity, parsed_config) + + return routing_entity + + async def _on_response_prepare(self, + request: web.Request, + response: web.StreamResponse): + """Non-preflight CORS request response processor. + + If request is done on CORS-enabled route, process request parameters + and set appropriate CORS response headers. + """ + if (not self._router_adapter.is_cors_enabled_on_request(request) or + self._router_adapter.is_preflight_request(request)): + # Either not CORS enabled route, or preflight request which is + # handled in its own handler. + return + + # Processing response of non-preflight CORS-enabled request. + + config = self._router_adapter.get_non_preflight_request_config(request) + + # Handle according to part 6.1 of the CORS specification. + + origin = request.headers.get(hdrs.ORIGIN) + if origin is None: + # Terminate CORS according to CORS 6.1.1. + return + + options = config.get(origin, config.get("*")) + if options is None: + # Terminate CORS according to CORS 6.1.2. + return + + assert hdrs.ACCESS_CONTROL_ALLOW_ORIGIN not in response.headers + assert hdrs.ACCESS_CONTROL_ALLOW_CREDENTIALS not in response.headers + assert hdrs.ACCESS_CONTROL_EXPOSE_HEADERS not in response.headers + + # Process according to CORS 6.1.4. + # Set exposed headers (server headers exposed to client) before + # setting any other headers. + if options.expose_headers == "*": + # Expose all headers that are set in response. + exposed_headers = \ + frozenset(response.headers.keys()) - _SIMPLE_RESPONSE_HEADERS + response.headers[hdrs.ACCESS_CONTROL_EXPOSE_HEADERS] = \ + ",".join(exposed_headers) + + elif options.expose_headers: + # Expose predefined list of headers. + response.headers[hdrs.ACCESS_CONTROL_EXPOSE_HEADERS] = \ + ",".join(options.expose_headers) + + # Process according to CORS 6.1.3. + # Set allowed origin. + response.headers[hdrs.ACCESS_CONTROL_ALLOW_ORIGIN] = origin + if options.allow_credentials: + # Set allowed credentials. + response.headers[hdrs.ACCESS_CONTROL_ALLOW_CREDENTIALS] = _TRUE + + async def _get_config(self, request, origin, request_method): + config = \ + await self._router_adapter.get_preflight_request_config( + request, origin, request_method) + return config + + +class CorsConfig: + """CORS configuration instance. + + The instance holds default CORS parameters and per-route options specified + in `add()` method. + + Each `aiohttp.web.Application` can have exactly one instance of this class. + """ + + def __init__(self, app: web.Application, *, + defaults: _ConfigType=None, + router_adapter: AbstractRouterAdapter=None): + """Construct CORS configuration. + + :param app: + Application for which CORS configuration is built. + :param defaults: + Default CORS settings for origins. + :param router_adapter: + Router adapter. Required if application uses non-default router. + """ + + self.defaults = _parse_config_options(defaults) + + self._cors_impl = None + + self._resources_router_adapter = None + self._resources_cors_impl = None + + self._old_routes_cors_impl = None + + if router_adapter is None: + router_adapter = \ + ResourcesUrlDispatcherRouterAdapter(app.router, self.defaults) + + self._cors_impl = _CorsConfigImpl(app, router_adapter) + + def add(self, + routing_entity, + config: _ConfigType = None, + webview: bool=False): + """Enable CORS for specific route or resource. + + If route is passed CORS is enabled for route's resource. + + :param routing_entity: + Route or Resource for which CORS should be enabled. + :param config: + CORS options for the route. + :return: `routing_entity`. + """ + + if webview: + warnings.warn('webview argument is deprecated, ' + 'views are handled authomatically without ' + 'extra settings', + DeprecationWarning, + stacklevel=2) + + return self._cors_impl.add(routing_entity, config) diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/mixin.py b/.venv/lib/python3.11/site-packages/aiohttp_cors/mixin.py new file mode 100644 index 0000000000000000000000000000000000000000..f5b45064dd3f06a0305afef72e81eafa71b34e3e --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp_cors/mixin.py @@ -0,0 +1,47 @@ +import collections + +from .preflight_handler import _PreflightHandler + + +def custom_cors(config): + def wrapper(function): + name = "{}_cors_config".format(function.__name__) + setattr(function, name, config) + return function + return wrapper + + +class CorsViewMixin(_PreflightHandler): + cors_config = None + + @classmethod + def get_request_config(cls, request, request_method): + try: + from . import APP_CONFIG_KEY + cors = request.app[APP_CONFIG_KEY] + except KeyError: + raise ValueError("aiohttp-cors is not configured.") + + method = getattr(cls, request_method.lower(), None) + + if not method: + raise KeyError() + + config_property_key = "{}_cors_config".format(request_method.lower()) + + custom_config = getattr(method, config_property_key, None) + if not custom_config: + custom_config = {} + + class_config = cls.cors_config + if not class_config: + class_config = {} + + return collections.ChainMap(custom_config, class_config, cors.defaults) + + async def _get_config(self, request, origin, request_method): + return self.get_request_config(request, request_method) + + async def options(self): + response = await self._preflight_handler(self.request) + return response diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/preflight_handler.py b/.venv/lib/python3.11/site-packages/aiohttp_cors/preflight_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..35e15e122a5d3269bf63bd973d3d03f3aa98e1f8 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp_cors/preflight_handler.py @@ -0,0 +1,130 @@ +from aiohttp import hdrs, web + +# Positive response to Access-Control-Allow-Credentials +_TRUE = "true" + + +class _PreflightHandler: + + @staticmethod + def _parse_request_method(request: web.Request): + """Parse Access-Control-Request-Method header of the preflight request + """ + method = request.headers.get(hdrs.ACCESS_CONTROL_REQUEST_METHOD) + if method is None: + raise web.HTTPForbidden( + text="CORS preflight request failed: " + "'Access-Control-Request-Method' header is not specified") + + # FIXME: validate method string (ABNF: method = token), if parsing + # fails, raise HTTPForbidden. + + return method + + @staticmethod + def _parse_request_headers(request: web.Request): + """Parse Access-Control-Request-Headers header or the preflight request + + Returns set of headers in upper case. + """ + headers = request.headers.get(hdrs.ACCESS_CONTROL_REQUEST_HEADERS) + if headers is None: + return frozenset() + + # FIXME: validate each header string, if parsing fails, raise + # HTTPForbidden. + # FIXME: check, that headers split and stripped correctly (according + # to ABNF). + headers = (h.strip(" \t").upper() for h in headers.split(",")) + # pylint: disable=bad-builtin + return frozenset(filter(None, headers)) + + async def _get_config(self, request, origin, request_method): + raise NotImplementedError() + + async def _preflight_handler(self, request: web.Request): + """CORS preflight request handler""" + + # Handle according to part 6.2 of the CORS specification. + + origin = request.headers.get(hdrs.ORIGIN) + if origin is None: + # Terminate CORS according to CORS 6.2.1. + raise web.HTTPForbidden( + text="CORS preflight request failed: " + "origin header is not specified in the request") + + # CORS 6.2.3. Doing it out of order is not an error. + request_method = self._parse_request_method(request) + + # CORS 6.2.5. Doing it out of order is not an error. + + try: + config = \ + await self._get_config(request, origin, request_method) + except KeyError: + raise web.HTTPForbidden( + text="CORS preflight request failed: " + "request method {!r} is not allowed " + "for {!r} origin".format(request_method, origin)) + + if not config: + # No allowed origins for the route. + # Terminate CORS according to CORS 6.2.1. + raise web.HTTPForbidden( + text="CORS preflight request failed: " + "no origins are allowed") + + options = config.get(origin, config.get("*")) + if options is None: + # No configuration for the origin - deny. + # Terminate CORS according to CORS 6.2.2. + raise web.HTTPForbidden( + text="CORS preflight request failed: " + "origin '{}' is not allowed".format(origin)) + + # CORS 6.2.4 + request_headers = self._parse_request_headers(request) + + # CORS 6.2.6 + if options.allow_headers == "*": + pass + else: + disallowed_headers = request_headers - options.allow_headers + if disallowed_headers: + raise web.HTTPForbidden( + text="CORS preflight request failed: " + "headers are not allowed: {}".format( + ", ".join(disallowed_headers))) + + # Ok, CORS actual request with specified in the preflight request + # parameters is allowed. + # Set appropriate headers and return 200 response. + + response = web.Response() + + # CORS 6.2.7 + response.headers[hdrs.ACCESS_CONTROL_ALLOW_ORIGIN] = origin + if options.allow_credentials: + # Set allowed credentials. + response.headers[hdrs.ACCESS_CONTROL_ALLOW_CREDENTIALS] = _TRUE + + # CORS 6.2.8 + if options.max_age is not None: + response.headers[hdrs.ACCESS_CONTROL_MAX_AGE] = \ + str(options.max_age) + + # CORS 6.2.9 + # TODO: more optimal for client preflight request cache would be to + # respond with ALL allowed methods. + response.headers[hdrs.ACCESS_CONTROL_ALLOW_METHODS] = request_method + + # CORS 6.2.10 + if request_headers: + # Note: case of the headers in the request is changed, but this + # shouldn't be a problem, since the headers should be compared in + # the case-insensitive way. + response.headers[hdrs.ACCESS_CONTROL_ALLOW_HEADERS] = \ + ",".join(request_headers) + + return response diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/resource_options.py b/.venv/lib/python3.11/site-packages/aiohttp_cors/resource_options.py new file mode 100644 index 0000000000000000000000000000000000000000..863323acc59c0352a9baff34dbb76e3287aefc75 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp_cors/resource_options.py @@ -0,0 +1,153 @@ +# Copyright 2015 Vladimir Rutsky +# +# 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. + +"""Resource CORS options class definition. +""" + +import numbers +import collections +import collections.abc + +__all__ = ("ResourceOptions",) + + +def _is_proper_sequence(seq): + """Returns is seq is sequence and not string.""" + return (isinstance(seq, collections.abc.Sequence) and + not isinstance(seq, str)) + + +class ResourceOptions(collections.namedtuple( + "Base", + ("allow_credentials", "expose_headers", "allow_headers", "max_age", + "allow_methods"))): + """Resource CORS options.""" + + __slots__ = () + + def __init__(self, *, allow_credentials=False, expose_headers=(), + allow_headers=(), max_age=None, allow_methods=None): + """Construct resource CORS options. + + Options will be normalized. + + :param allow_credentials: + Is passing client credentials to the resource from other origin + is allowed. + See for + the definition. + :type allow_credentials: bool + Is passing client credentials to the resource from other origin + is allowed. + + :param expose_headers: + Server headers that are allowed to be exposed to the client. + Simple response headers are excluded from this set, see + . + :type expose_headers: sequence of strings or ``*`` string. + + :param allow_headers: + Client headers that are allowed to be passed to the resource. + See . + :type allow_headers: sequence of strings or ``*`` string. + + :param max_age: + How long the results of a preflight request can be cached in a + preflight result cache (in seconds). + See . + + :param allow_methods: + List of allowed methods or ``*``string. Can be used in resource or + global defaults, but not in specific route. + + It's not required to specify all allowed methods for specific + resource, routes that have explicit CORS configuration will be + treated as if their methods are allowed. + """ + super().__init__() + + def __new__(cls, *, allow_credentials=False, expose_headers=(), + allow_headers=(), max_age=None, allow_methods=None): + """Normalize source parameters and store them in namedtuple.""" + + if not isinstance(allow_credentials, bool): + raise ValueError( + "'allow_credentials' must be boolean, " + "got '{!r}'".format(allow_credentials)) + _allow_credentials = allow_credentials + + # `expose_headers` is either "*", or sequence of strings. + if expose_headers == "*": + _expose_headers = expose_headers + elif not _is_proper_sequence(expose_headers): + raise ValueError( + "'expose_headers' must be either '*', or sequence of strings, " + "got '{!r}'".format(expose_headers)) + elif expose_headers: + # "Access-Control-Expose-Headers" ":" #field-name + # TODO: Check that headers are valid. + # TODO: Remove headers that in the _SIMPLE_RESPONSE_HEADERS set + # according to + # . + _expose_headers = frozenset(expose_headers) + else: + # No headers exposed. + _expose_headers = frozenset() + + # `allow_headers` is either "*", or set of headers in upper case. + if allow_headers == "*": + _allow_headers = allow_headers + elif not _is_proper_sequence(allow_headers): + raise ValueError( + "'allow_headers' must be either '*', or sequence of strings, " + "got '{!r}'".format(allow_headers)) + else: + # TODO: Check that headers are valid. + _allow_headers = frozenset(h.upper() for h in allow_headers) + + if max_age is None: + _max_age = None + else: + if not isinstance(max_age, numbers.Integral) or max_age < 0: + raise ValueError( + "'max_age' must be non-negative integer, " + "got '{!r}'".format(max_age)) + _max_age = max_age + + if allow_methods is None or allow_methods == "*": + _allow_methods = allow_methods + elif not _is_proper_sequence(allow_methods): + raise ValueError( + "'allow_methods' must be either '*', or sequence of strings, " + "got '{!r}'".format(allow_methods)) + else: + # TODO: Check that methods are valid. + _allow_methods = frozenset(m.upper() for m in allow_methods) + + return super().__new__( + cls, + allow_credentials=_allow_credentials, + expose_headers=_expose_headers, + allow_headers=_allow_headers, + max_age=_max_age, + allow_methods=_allow_methods) + + def is_method_allowed(self, method): + if self.allow_methods is None: + return False + + if self.allow_methods == '*': + return True + + return method.upper() in self.allow_methods diff --git a/.venv/lib/python3.11/site-packages/aiohttp_cors/urldispatcher_router_adapter.py b/.venv/lib/python3.11/site-packages/aiohttp_cors/urldispatcher_router_adapter.py new file mode 100644 index 0000000000000000000000000000000000000000..1a65e99878e1b9748c9a8cbc6055de85852c7aac --- /dev/null +++ b/.venv/lib/python3.11/site-packages/aiohttp_cors/urldispatcher_router_adapter.py @@ -0,0 +1,324 @@ +# Copyright 2015 Vladimir Rutsky +# +# 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. + +"""AbstractRouterAdapter for aiohttp.web.UrlDispatcher. +""" +import collections + +from typing import Union + +from aiohttp import web +from aiohttp import hdrs + +from .abc import AbstractRouterAdapter +from .mixin import CorsViewMixin + + +# There several usage patterns of routes which should be handled +# differently. +# +# 1. Using new Resources: +# +# resource = app.router.add_resource(path) +# cors.add(resource, resource_defaults=...) +# cors.add(resource.add_route(method1, handler1), config=...) +# cors.add(resource.add_route(method2, handler2), config=...) +# cors.add(resource.add_route(method3, handler3), config=...) +# +# Here all related Routes (i.e. routes with the same path) are in +# a single Resource. +# +# 2. Using `router.add_static()`: +# +# route1 = app.router.add_static( +# "/images", "/usr/share/app/images/") +# cors.add(route1, config=...) +# +# Here old-style `web.StaticRoute` is created and wrapped with +# `web.ResourceAdapter`. +# +# 3. Using old `router.add_route()`: +# +# cors.add(app.router.add_route(method1, path, hand1), config=...) +# cors.add(app.router.add_route(method2, path, hand2), config=...) +# cors.add(app.router.add_route(method3, path, hand3), config=...) +# +# This creates three Resources with single Route in each. +# +# 4. Using deprecated `register_route` with manually created +# `web.Route`: +# +# route1 = RouteSubclass(...) +# app.router.register_route(route1) +# cors.add(route1, config=...) +# +# Here old-style route is wrapped with `web.ResourceAdapter`. +# +# Preflight requests is roughly an OPTIONS request with query +# "is specific HTTP method is allowed". +# In order to properly handle preflight request we need to know which +# routes have enabled CORS on the request path and CORS configuration +# for requested HTTP method. +# +# In case of new usage pattern it's simple: we need to take a look at +# self._resource_config[resource][method] for the processing resource. +# +# In case of old usage pattern we need to iterate over routes with +# enabled CORS and check is requested path and HTTP method is accepted +# by a route. + + +class _ResourceConfig: + def __init__(self, default_config): + # Resource default config. + self.default_config = default_config + + # HTTP method to route configuration. + self.method_config = {} + + +def _is_web_view(entity, strict=True): + webview = False + if isinstance(entity, web.AbstractRoute): + handler = entity.handler + if isinstance(handler, type) and issubclass(handler, web.View): + webview = True + if not issubclass(handler, CorsViewMixin): + if strict: + raise ValueError("web view should be derived from " + "aiohttp_cors.WebViewMixig for working " + "with the library") + else: + return False + return webview + + +class ResourcesUrlDispatcherRouterAdapter(AbstractRouterAdapter): + """Adapter for `UrlDispatcher` for Resources-based routing only. + + Should be used with routes added in the following way: + + resource = app.router.add_resource(path) + cors.add(resource, resource_defaults=...) + cors.add(resource.add_route(method1, handler1), config=...) + cors.add(resource.add_route(method2, handler2), config=...) + cors.add(resource.add_route(method3, handler3), config=...) + """ + + def __init__(self, + router: web.UrlDispatcher, + defaults): + """ + :param defaults: + Default CORS configuration. + """ + self._router = router + + # Default configuration for all routes. + self._default_config = defaults + + # Mapping from Resource to _ResourceConfig. + self._resource_config = {} + + self._resources_with_preflight_handlers = set() + self._preflight_routes = set() + + def add_preflight_handler( + self, + routing_entity: Union[web.Resource, web.StaticResource, + web.ResourceRoute], + handler): + """Add OPTIONS handler for all routes defined by `routing_entity`. + + Does nothing if CORS handler already handles routing entity. + Should fail if there are conflicting user-defined OPTIONS handlers. + """ + + if isinstance(routing_entity, web.Resource): + resource = routing_entity + + # Add preflight handler for Resource, if not yet added. + + if resource in self._resources_with_preflight_handlers: + # Preflight handler already added for this resource. + return + for route_obj in resource: + if route_obj.method == hdrs.METH_OPTIONS: + if route_obj.handler is handler: + return # already added + else: + raise ValueError( + "{!r} already has OPTIONS handler {!r}" + .format(resource, route_obj.handler)) + elif route_obj.method == hdrs.METH_ANY: + if _is_web_view(route_obj): + self._preflight_routes.add(route_obj) + self._resources_with_preflight_handlers.add(resource) + return + else: + raise ValueError("{!r} already has a '*' handler " + "for all methods".format(resource)) + + preflight_route = resource.add_route(hdrs.METH_OPTIONS, handler) + self._preflight_routes.add(preflight_route) + self._resources_with_preflight_handlers.add(resource) + + elif isinstance(routing_entity, web.StaticResource): + resource = routing_entity + + # Add preflight handler for Resource, if not yet added. + + if resource in self._resources_with_preflight_handlers: + # Preflight handler already added for this resource. + return + + resource.set_options_route(handler) + preflight_route = resource._routes[hdrs.METH_OPTIONS] + self._preflight_routes.add(preflight_route) + self._resources_with_preflight_handlers.add(resource) + + elif isinstance(routing_entity, web.ResourceRoute): + route = routing_entity + + if not self.is_cors_for_resource(route.resource): + self.add_preflight_handler(route.resource, handler) + + else: + raise ValueError( + "Resource or ResourceRoute expected, got {!r}".format( + routing_entity)) + + def is_cors_for_resource(self, resource: web.Resource) -> bool: + """Is CORS is configured for the resource""" + return resource in self._resources_with_preflight_handlers + + def _request_route(self, request: web.Request) -> web.ResourceRoute: + match_info = request.match_info + assert isinstance(match_info, web.UrlMappingMatchInfo) + return match_info.route + + def _request_resource(self, request: web.Request) -> web.Resource: + return self._request_route(request).resource + + def is_preflight_request(self, request: web.Request) -> bool: + """Is `request` is a CORS preflight request.""" + route = self._request_route(request) + if _is_web_view(route, strict=False): + return request.method == 'OPTIONS' + return route in self._preflight_routes + + def is_cors_enabled_on_request(self, request: web.Request) -> bool: + """Is `request` is a request for CORS-enabled resource.""" + + return self._request_resource(request) in self._resource_config + + def set_config_for_routing_entity( + self, + routing_entity: Union[web.Resource, web.StaticResource, + web.ResourceRoute], + config): + """Record configuration for resource or it's route.""" + + if isinstance(routing_entity, (web.Resource, web.StaticResource)): + resource = routing_entity + + # Add resource configuration or fail if it's already added. + if resource in self._resource_config: + raise ValueError( + "CORS is already configured for {!r} resource.".format( + resource)) + + self._resource_config[resource] = _ResourceConfig( + default_config=config) + + elif isinstance(routing_entity, web.ResourceRoute): + route = routing_entity + + # Add resource's route configuration or fail if it's already added. + if route.resource not in self._resource_config: + self.set_config_for_routing_entity(route.resource, config) + + if route.resource not in self._resource_config: + raise ValueError( + "Can't setup CORS for {!r} request, " + "CORS must be enabled for route's resource first.".format( + route)) + + resource_config = self._resource_config[route.resource] + + if route.method in resource_config.method_config: + raise ValueError( + "Can't setup CORS for {!r} route: CORS already " + "configured on resource {!r} for {} method".format( + route, route.resource, route.method)) + + resource_config.method_config[route.method] = config + + else: + raise ValueError( + "Resource or ResourceRoute expected, got {!r}".format( + routing_entity)) + + async def get_preflight_request_config( + self, + preflight_request: web.Request, + origin: str, + requested_method: str): + assert self.is_preflight_request(preflight_request) + + resource = self._request_resource(preflight_request) + resource_config = self._resource_config[resource] + defaulted_config = collections.ChainMap( + resource_config.default_config, + self._default_config) + + options = defaulted_config.get(origin, defaulted_config.get("*")) + if options is not None and options.is_method_allowed(requested_method): + # Requested method enabled for CORS in defaults, override it with + # explicit route configuration (if any). + route_config = resource_config.method_config.get( + requested_method, {}) + + else: + # Requested method is not enabled in defaults. + # Enable CORS for it only if explicit configuration exists. + route_config = resource_config.method_config[requested_method] + + defaulted_config = collections.ChainMap(route_config, defaulted_config) + + return defaulted_config + + def get_non_preflight_request_config(self, request: web.Request): + """Get stored CORS configuration for routing entity that handles + specified request.""" + + assert self.is_cors_enabled_on_request(request) + + resource = self._request_resource(request) + resource_config = self._resource_config[resource] + # Take Route config (if any) with defaults from Resource CORS + # configuration and global defaults. + route = request.match_info.route + if _is_web_view(route, strict=False): + method_config = request.match_info.handler.get_request_config( + request, request.method) + else: + method_config = resource_config.method_config.get(request.method, + {}) + defaulted_config = collections.ChainMap( + method_config, + resource_config.default_config, + self._default_config) + + return defaulted_config diff --git a/.venv/lib/python3.11/site-packages/frozenlist/__init__.py b/.venv/lib/python3.11/site-packages/frozenlist/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4022db505cf433332c121564683ac235a3ce0447 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/frozenlist/__init__.py @@ -0,0 +1,98 @@ +import os +import sys +import types +from collections.abc import MutableSequence +from functools import total_ordering +from typing import Any, Type + +__version__ = "1.5.0" + +__all__ = ("FrozenList", "PyFrozenList") # type: Tuple[str, ...] + + +NO_EXTENSIONS = bool(os.environ.get("FROZENLIST_NO_EXTENSIONS")) # type: bool + + +@total_ordering +class FrozenList(MutableSequence): + __slots__ = ("_frozen", "_items") + + if sys.version_info >= (3, 9): + __class_getitem__ = classmethod(types.GenericAlias) + else: + + @classmethod + def __class_getitem__( + cls: Type["FrozenList"], + cls_item: Any, + ) -> Type["FrozenList"]: + return cls + + def __init__(self, items=None): + self._frozen = False + if items is not None: + items = list(items) + else: + items = [] + self._items = items + + @property + def frozen(self): + return self._frozen + + def freeze(self): + self._frozen = True + + def __getitem__(self, index): + return self._items[index] + + def __setitem__(self, index, value): + if self._frozen: + raise RuntimeError("Cannot modify frozen list.") + self._items[index] = value + + def __delitem__(self, index): + if self._frozen: + raise RuntimeError("Cannot modify frozen list.") + del self._items[index] + + def __len__(self): + return self._items.__len__() + + def __iter__(self): + return self._items.__iter__() + + def __reversed__(self): + return self._items.__reversed__() + + def __eq__(self, other): + return list(self) == other + + def __le__(self, other): + return list(self) <= other + + def insert(self, pos, item): + if self._frozen: + raise RuntimeError("Cannot modify frozen list.") + self._items.insert(pos, item) + + def __repr__(self): + return f"" + + def __hash__(self): + if self._frozen: + return hash(tuple(self)) + else: + raise RuntimeError("Cannot hash unfrozen list.") + + +PyFrozenList = FrozenList + + +if not NO_EXTENSIONS: + try: + from ._frozenlist import FrozenList as CFrozenList # type: ignore + except ImportError: # pragma: no cover + pass + else: + FrozenList = CFrozenList # type: ignore diff --git a/.venv/lib/python3.11/site-packages/frozenlist/__init__.pyi b/.venv/lib/python3.11/site-packages/frozenlist/__init__.pyi new file mode 100644 index 0000000000000000000000000000000000000000..ae803ef6aad72f57e7379db5a2044a95f214df7b --- /dev/null +++ b/.venv/lib/python3.11/site-packages/frozenlist/__init__.pyi @@ -0,0 +1,47 @@ +from typing import ( + Generic, + Iterable, + Iterator, + List, + MutableSequence, + Optional, + TypeVar, + Union, + overload, +) + +_T = TypeVar("_T") +_Arg = Union[List[_T], Iterable[_T]] + +class FrozenList(MutableSequence[_T], Generic[_T]): + def __init__(self, items: Optional[_Arg[_T]] = None) -> None: ... + @property + def frozen(self) -> bool: ... + def freeze(self) -> None: ... + @overload + def __getitem__(self, i: int) -> _T: ... + @overload + def __getitem__(self, s: slice) -> FrozenList[_T]: ... + @overload + def __setitem__(self, i: int, o: _T) -> None: ... + @overload + def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... + @overload + def __delitem__(self, i: int) -> None: ... + @overload + def __delitem__(self, i: slice) -> None: ... + def __len__(self) -> int: ... + def __iter__(self) -> Iterator[_T]: ... + def __reversed__(self) -> Iterator[_T]: ... + def __eq__(self, other: object) -> bool: ... + def __le__(self, other: FrozenList[_T]) -> bool: ... + def __ne__(self, other: object) -> bool: ... + def __lt__(self, other: FrozenList[_T]) -> bool: ... + def __ge__(self, other: FrozenList[_T]) -> bool: ... + def __gt__(self, other: FrozenList[_T]) -> bool: ... + def insert(self, pos: int, item: _T) -> None: ... + def __repr__(self) -> str: ... + def __hash__(self) -> int: ... + +# types for C accelerators are the same +CFrozenList = PyFrozenList = FrozenList diff --git a/.venv/lib/python3.11/site-packages/frozenlist/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/frozenlist/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d582bcef12f67eceaf2f4106590f8eb8ed16d93c Binary files /dev/null and b/.venv/lib/python3.11/site-packages/frozenlist/__pycache__/__init__.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/frozenlist/_frozenlist.pyx b/.venv/lib/python3.11/site-packages/frozenlist/_frozenlist.pyx new file mode 100644 index 0000000000000000000000000000000000000000..45d11de13264d426c35f754dfbffbf049af84abf --- /dev/null +++ b/.venv/lib/python3.11/site-packages/frozenlist/_frozenlist.pyx @@ -0,0 +1,123 @@ +import sys +import types +from collections.abc import MutableSequence + + +cdef class FrozenList: + + if sys.version_info >= (3, 9): + __class_getitem__ = classmethod(types.GenericAlias) + else: + @classmethod + def __class_getitem__(cls, cls_item): + return cls + + cdef readonly bint frozen + cdef list _items + + def __init__(self, items=None): + self.frozen = False + if items is not None: + items = list(items) + else: + items = [] + self._items = items + + cdef object _check_frozen(self): + if self.frozen: + raise RuntimeError("Cannot modify frozen list.") + + cdef inline object _fast_len(self): + return len(self._items) + + def freeze(self): + self.frozen = True + + def __getitem__(self, index): + return self._items[index] + + def __setitem__(self, index, value): + self._check_frozen() + self._items[index] = value + + def __delitem__(self, index): + self._check_frozen() + del self._items[index] + + def __len__(self): + return self._fast_len() + + def __iter__(self): + return self._items.__iter__() + + def __reversed__(self): + return self._items.__reversed__() + + def __richcmp__(self, other, op): + if op == 0: # < + return list(self) < other + if op == 1: # <= + return list(self) <= other + if op == 2: # == + return list(self) == other + if op == 3: # != + return list(self) != other + if op == 4: # > + return list(self) > other + if op == 5: # => + return list(self) >= other + + def insert(self, pos, item): + self._check_frozen() + self._items.insert(pos, item) + + def __contains__(self, item): + return item in self._items + + def __iadd__(self, items): + self._check_frozen() + self._items += list(items) + return self + + def index(self, item): + return self._items.index(item) + + def remove(self, item): + self._check_frozen() + self._items.remove(item) + + def clear(self): + self._check_frozen() + self._items.clear() + + def extend(self, items): + self._check_frozen() + self._items += list(items) + + def reverse(self): + self._check_frozen() + self._items.reverse() + + def pop(self, index=-1): + self._check_frozen() + return self._items.pop(index) + + def append(self, item): + self._check_frozen() + return self._items.append(item) + + def count(self, item): + return self._items.count(item) + + def __repr__(self): + return ''.format(self.frozen, + self._items) + + def __hash__(self): + if self.frozen: + return hash(tuple(self._items)) + else: + raise RuntimeError("Cannot hash unfrozen list.") + + +MutableSequence.register(FrozenList) diff --git a/.venv/lib/python3.11/site-packages/frozenlist/py.typed b/.venv/lib/python3.11/site-packages/frozenlist/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..f5642f79f21d872f010979dcf6f0c4a415acc19d --- /dev/null +++ b/.venv/lib/python3.11/site-packages/frozenlist/py.typed @@ -0,0 +1 @@ +Marker diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__init__.py b/.venv/lib/python3.11/site-packages/googleapiclient/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9218dd854063df739f78247c299643f2c6b29f0 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/__init__.py @@ -0,0 +1,27 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +# Set default logging handler to avoid "No handler found" warnings. +import logging + +try: # Python 2.7+ + from logging import NullHandler +except ImportError: + + class NullHandler(logging.Handler): + def emit(self, record): + pass + + +logging.getLogger(__name__).addHandler(NullHandler()) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e9519eaf3e05bf5bb5f12168d5b38142aaaa9ad Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/__init__.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/_auth.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/_auth.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7db4739e8aea137e34b44e9e2c93560dd115e2fe Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/_auth.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/_helpers.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/_helpers.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b074a8729bcdb5b3e7b255f648ab1850b0297c53 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/_helpers.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/channel.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/channel.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dea96532d9b42a04e9a1f6c5d4df928eca2f9746 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/channel.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/discovery.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/discovery.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9fc24c58c55a6d4200de37353f10c805b48153e1 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/discovery.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/errors.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/errors.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a9b4aa78890f10fd857db08ef32a18375f51497 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/errors.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/http.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/http.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47afbd685ded95afefb39c3ead6c95fada60cd8e Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/http.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/mimeparse.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/mimeparse.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..680efb97f98dfbd7302eb527518ab60bbc8d4595 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/mimeparse.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/model.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/model.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5104d19bd93df1c8805ea5a6b26798e4e2bdc4be Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/model.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/sample_tools.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/sample_tools.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9716c5c0a4c3ede7fd24263a21d1e97f267e01c Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/sample_tools.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/schema.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/schema.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c2335b061098b6a7f02cbe9d3d2052a36a1bc337 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/schema.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/version.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/version.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2b3d2836af1d954624f948fb0aea765565fbafa Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/__pycache__/version.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/_auth.py b/.venv/lib/python3.11/site-packages/googleapiclient/_auth.py new file mode 100644 index 0000000000000000000000000000000000000000..065b2ecd307df1d69a7e6afe1b94086b8b33c838 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/_auth.py @@ -0,0 +1,167 @@ +# Copyright 2016 Google Inc. All Rights Reserved. +# +# 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. + +"""Helpers for authentication using oauth2client or google-auth.""" + +import httplib2 + +try: + import google.auth + import google.auth.credentials + + HAS_GOOGLE_AUTH = True +except ImportError: # pragma: NO COVER + HAS_GOOGLE_AUTH = False + +try: + import google_auth_httplib2 +except ImportError: # pragma: NO COVER + google_auth_httplib2 = None + +try: + import oauth2client + import oauth2client.client + + HAS_OAUTH2CLIENT = True +except ImportError: # pragma: NO COVER + HAS_OAUTH2CLIENT = False + + +def credentials_from_file(filename, scopes=None, quota_project_id=None): + """Returns credentials loaded from a file.""" + if HAS_GOOGLE_AUTH: + credentials, _ = google.auth.load_credentials_from_file( + filename, scopes=scopes, quota_project_id=quota_project_id + ) + return credentials + else: + raise EnvironmentError( + "client_options.credentials_file is only supported in google-auth." + ) + + +def default_credentials(scopes=None, quota_project_id=None): + """Returns Application Default Credentials.""" + if HAS_GOOGLE_AUTH: + credentials, _ = google.auth.default( + scopes=scopes, quota_project_id=quota_project_id + ) + return credentials + elif HAS_OAUTH2CLIENT: + if scopes is not None or quota_project_id is not None: + raise EnvironmentError( + "client_options.scopes and client_options.quota_project_id are not supported in oauth2client." + "Please install google-auth." + ) + return oauth2client.client.GoogleCredentials.get_application_default() + else: + raise EnvironmentError( + "No authentication library is available. Please install either " + "google-auth or oauth2client." + ) + + +def with_scopes(credentials, scopes): + """Scopes the credentials if necessary. + + Args: + credentials (Union[ + google.auth.credentials.Credentials, + oauth2client.client.Credentials]): The credentials to scope. + scopes (Sequence[str]): The list of scopes. + + Returns: + Union[google.auth.credentials.Credentials, + oauth2client.client.Credentials]: The scoped credentials. + """ + if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials): + return google.auth.credentials.with_scopes_if_required(credentials, scopes) + else: + try: + if credentials.create_scoped_required(): + return credentials.create_scoped(scopes) + else: + return credentials + except AttributeError: + return credentials + + +def authorized_http(credentials): + """Returns an http client that is authorized with the given credentials. + + Args: + credentials (Union[ + google.auth.credentials.Credentials, + oauth2client.client.Credentials]): The credentials to use. + + Returns: + Union[httplib2.Http, google_auth_httplib2.AuthorizedHttp]: An + authorized http client. + """ + from googleapiclient.http import build_http + + if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials): + if google_auth_httplib2 is None: + raise ValueError( + "Credentials from google.auth specified, but " + "google-api-python-client is unable to use these credentials " + "unless google-auth-httplib2 is installed. Please install " + "google-auth-httplib2." + ) + return google_auth_httplib2.AuthorizedHttp(credentials, http=build_http()) + else: + return credentials.authorize(build_http()) + + +def refresh_credentials(credentials): + # Refresh must use a new http instance, as the one associated with the + # credentials could be a AuthorizedHttp or an oauth2client-decorated + # Http instance which would cause a weird recursive loop of refreshing + # and likely tear a hole in spacetime. + refresh_http = httplib2.Http() + if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials): + request = google_auth_httplib2.Request(refresh_http) + return credentials.refresh(request) + else: + return credentials.refresh(refresh_http) + + +def apply_credentials(credentials, headers): + # oauth2client and google-auth have the same interface for this. + if not is_valid(credentials): + refresh_credentials(credentials) + return credentials.apply(headers) + + +def is_valid(credentials): + if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials): + return credentials.valid + else: + return ( + credentials.access_token is not None + and not credentials.access_token_expired + ) + + +def get_credentials_from_http(http): + if http is None: + return None + elif hasattr(http.request, "credentials"): + return http.request.credentials + elif hasattr(http, "credentials") and not isinstance( + http.credentials, httplib2.Credentials + ): + return http.credentials + else: + return None diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/_helpers.py b/.venv/lib/python3.11/site-packages/googleapiclient/_helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..17b8a171514eb144ba67b75de58f526b36680ea1 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/_helpers.py @@ -0,0 +1,207 @@ +# Copyright 2015 Google Inc. All rights reserved. +# +# 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. + +"""Helper functions for commonly used utilities.""" + +import functools +import inspect +import logging +import urllib + +logger = logging.getLogger(__name__) + +POSITIONAL_WARNING = "WARNING" +POSITIONAL_EXCEPTION = "EXCEPTION" +POSITIONAL_IGNORE = "IGNORE" +POSITIONAL_SET = frozenset( + [POSITIONAL_WARNING, POSITIONAL_EXCEPTION, POSITIONAL_IGNORE] +) + +positional_parameters_enforcement = POSITIONAL_WARNING + +_SYM_LINK_MESSAGE = "File: {0}: Is a symbolic link." +_IS_DIR_MESSAGE = "{0}: Is a directory" +_MISSING_FILE_MESSAGE = "Cannot access {0}: No such file or directory" + + +def positional(max_positional_args): + """A decorator to declare that only the first N arguments may be positional. + + This decorator makes it easy to support Python 3 style keyword-only + parameters. For example, in Python 3 it is possible to write:: + + def fn(pos1, *, kwonly1=None, kwonly2=None): + ... + + All named parameters after ``*`` must be a keyword:: + + fn(10, 'kw1', 'kw2') # Raises exception. + fn(10, kwonly1='kw1') # Ok. + + Example + ^^^^^^^ + + To define a function like above, do:: + + @positional(1) + def fn(pos1, kwonly1=None, kwonly2=None): + ... + + If no default value is provided to a keyword argument, it becomes a + required keyword argument:: + + @positional(0) + def fn(required_kw): + ... + + This must be called with the keyword parameter:: + + fn() # Raises exception. + fn(10) # Raises exception. + fn(required_kw=10) # Ok. + + When defining instance or class methods always remember to account for + ``self`` and ``cls``:: + + class MyClass(object): + + @positional(2) + def my_method(self, pos1, kwonly1=None): + ... + + @classmethod + @positional(2) + def my_method(cls, pos1, kwonly1=None): + ... + + The positional decorator behavior is controlled by + ``_helpers.positional_parameters_enforcement``, which may be set to + ``POSITIONAL_EXCEPTION``, ``POSITIONAL_WARNING`` or + ``POSITIONAL_IGNORE`` to raise an exception, log a warning, or do + nothing, respectively, if a declaration is violated. + + Args: + max_positional_arguments: Maximum number of positional arguments. All + parameters after this index must be + keyword only. + + Returns: + A decorator that prevents using arguments after max_positional_args + from being used as positional parameters. + + Raises: + TypeError: if a keyword-only argument is provided as a positional + parameter, but only if + _helpers.positional_parameters_enforcement is set to + POSITIONAL_EXCEPTION. + """ + + def positional_decorator(wrapped): + @functools.wraps(wrapped) + def positional_wrapper(*args, **kwargs): + if len(args) > max_positional_args: + plural_s = "" + if max_positional_args != 1: + plural_s = "s" + message = ( + "{function}() takes at most {args_max} positional " + "argument{plural} ({args_given} given)".format( + function=wrapped.__name__, + args_max=max_positional_args, + args_given=len(args), + plural=plural_s, + ) + ) + if positional_parameters_enforcement == POSITIONAL_EXCEPTION: + raise TypeError(message) + elif positional_parameters_enforcement == POSITIONAL_WARNING: + logger.warning(message) + return wrapped(*args, **kwargs) + + return positional_wrapper + + if isinstance(max_positional_args, int): + return positional_decorator + else: + args, _, _, defaults, _, _, _ = inspect.getfullargspec(max_positional_args) + return positional(len(args) - len(defaults))(max_positional_args) + + +def parse_unique_urlencoded(content): + """Parses unique key-value parameters from urlencoded content. + + Args: + content: string, URL-encoded key-value pairs. + + Returns: + dict, The key-value pairs from ``content``. + + Raises: + ValueError: if one of the keys is repeated. + """ + urlencoded_params = urllib.parse.parse_qs(content) + params = {} + for key, value in urlencoded_params.items(): + if len(value) != 1: + msg = "URL-encoded content contains a repeated value:" "%s -> %s" % ( + key, + ", ".join(value), + ) + raise ValueError(msg) + params[key] = value[0] + return params + + +def update_query_params(uri, params): + """Updates a URI with new query parameters. + + If a given key from ``params`` is repeated in the ``uri``, then + the URI will be considered invalid and an error will occur. + + If the URI is valid, then each value from ``params`` will + replace the corresponding value in the query parameters (if + it exists). + + Args: + uri: string, A valid URI, with potential existing query parameters. + params: dict, A dictionary of query parameters. + + Returns: + The same URI but with the new query parameters added. + """ + parts = urllib.parse.urlparse(uri) + query_params = parse_unique_urlencoded(parts.query) + query_params.update(params) + new_query = urllib.parse.urlencode(query_params) + new_parts = parts._replace(query=new_query) + return urllib.parse.urlunparse(new_parts) + + +def _add_query_parameter(url, name, value): + """Adds a query parameter to a url. + + Replaces the current value if it already exists in the URL. + + Args: + url: string, url to add the query parameter to. + name: string, query parameter name. + value: string, query parameter value. + + Returns: + Updated query parameter. Does not update the url if value is None. + """ + if value is None: + return url + else: + return update_query_params(url, {name: value}) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/channel.py b/.venv/lib/python3.11/site-packages/googleapiclient/channel.py new file mode 100644 index 0000000000000000000000000000000000000000..37bda1ea7e52630d2a775961816ea19d6174a62b --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/channel.py @@ -0,0 +1,315 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""Channel notifications support. + +Classes and functions to support channel subscriptions and notifications +on those channels. + +Notes: + - This code is based on experimental APIs and is subject to change. + - Notification does not do deduplication of notification ids, that's up to + the receiver. + - Storing the Channel between calls is up to the caller. + + +Example setting up a channel: + + # Create a new channel that gets notifications via webhook. + channel = new_webhook_channel("https://example.com/my_web_hook") + + # Store the channel, keyed by 'channel.id'. Store it before calling the + # watch method because notifications may start arriving before the watch + # method returns. + ... + + resp = service.objects().watchAll( + bucket="some_bucket_id", body=channel.body()).execute() + channel.update(resp) + + # Store the channel, keyed by 'channel.id'. Store it after being updated + # since the resource_id value will now be correct, and that's needed to + # stop a subscription. + ... + + +An example Webhook implementation using webapp2. Note that webapp2 puts +headers in a case insensitive dictionary, as headers aren't guaranteed to +always be upper case. + + id = self.request.headers[X_GOOG_CHANNEL_ID] + + # Retrieve the channel by id. + channel = ... + + # Parse notification from the headers, including validating the id. + n = notification_from_headers(channel, self.request.headers) + + # Do app specific stuff with the notification here. + if n.resource_state == 'sync': + # Code to handle sync state. + elif n.resource_state == 'exists': + # Code to handle the exists state. + elif n.resource_state == 'not_exists': + # Code to handle the not exists state. + + +Example of unsubscribing. + + service.channels().stop(channel.body()).execute() +""" +from __future__ import absolute_import + +import datetime +import uuid + +from googleapiclient import _helpers as util +from googleapiclient import errors + +# The unix time epoch starts at midnight 1970. +EPOCH = datetime.datetime(1970, 1, 1) + +# Map the names of the parameters in the JSON channel description to +# the parameter names we use in the Channel class. +CHANNEL_PARAMS = { + "address": "address", + "id": "id", + "expiration": "expiration", + "params": "params", + "resourceId": "resource_id", + "resourceUri": "resource_uri", + "type": "type", + "token": "token", +} + +X_GOOG_CHANNEL_ID = "X-GOOG-CHANNEL-ID" +X_GOOG_MESSAGE_NUMBER = "X-GOOG-MESSAGE-NUMBER" +X_GOOG_RESOURCE_STATE = "X-GOOG-RESOURCE-STATE" +X_GOOG_RESOURCE_URI = "X-GOOG-RESOURCE-URI" +X_GOOG_RESOURCE_ID = "X-GOOG-RESOURCE-ID" + + +def _upper_header_keys(headers): + new_headers = {} + for k, v in headers.items(): + new_headers[k.upper()] = v + return new_headers + + +class Notification(object): + """A Notification from a Channel. + + Notifications are not usually constructed directly, but are returned + from functions like notification_from_headers(). + + Attributes: + message_number: int, The unique id number of this notification. + state: str, The state of the resource being monitored. + uri: str, The address of the resource being monitored. + resource_id: str, The unique identifier of the version of the resource at + this event. + """ + + @util.positional(5) + def __init__(self, message_number, state, resource_uri, resource_id): + """Notification constructor. + + Args: + message_number: int, The unique id number of this notification. + state: str, The state of the resource being monitored. Can be one + of "exists", "not_exists", or "sync". + resource_uri: str, The address of the resource being monitored. + resource_id: str, The identifier of the watched resource. + """ + self.message_number = message_number + self.state = state + self.resource_uri = resource_uri + self.resource_id = resource_id + + +class Channel(object): + """A Channel for notifications. + + Usually not constructed directly, instead it is returned from helper + functions like new_webhook_channel(). + + Attributes: + type: str, The type of delivery mechanism used by this channel. For + example, 'web_hook'. + id: str, A UUID for the channel. + token: str, An arbitrary string associated with the channel that + is delivered to the target address with each event delivered + over this channel. + address: str, The address of the receiving entity where events are + delivered. Specific to the channel type. + expiration: int, The time, in milliseconds from the epoch, when this + channel will expire. + params: dict, A dictionary of string to string, with additional parameters + controlling delivery channel behavior. + resource_id: str, An opaque id that identifies the resource that is + being watched. Stable across different API versions. + resource_uri: str, The canonicalized ID of the watched resource. + """ + + @util.positional(5) + def __init__( + self, + type, + id, + token, + address, + expiration=None, + params=None, + resource_id="", + resource_uri="", + ): + """Create a new Channel. + + In user code, this Channel constructor will not typically be called + manually since there are functions for creating channels for each specific + type with a more customized set of arguments to pass. + + Args: + type: str, The type of delivery mechanism used by this channel. For + example, 'web_hook'. + id: str, A UUID for the channel. + token: str, An arbitrary string associated with the channel that + is delivered to the target address with each event delivered + over this channel. + address: str, The address of the receiving entity where events are + delivered. Specific to the channel type. + expiration: int, The time, in milliseconds from the epoch, when this + channel will expire. + params: dict, A dictionary of string to string, with additional parameters + controlling delivery channel behavior. + resource_id: str, An opaque id that identifies the resource that is + being watched. Stable across different API versions. + resource_uri: str, The canonicalized ID of the watched resource. + """ + self.type = type + self.id = id + self.token = token + self.address = address + self.expiration = expiration + self.params = params + self.resource_id = resource_id + self.resource_uri = resource_uri + + def body(self): + """Build a body from the Channel. + + Constructs a dictionary that's appropriate for passing into watch() + methods as the value of body argument. + + Returns: + A dictionary representation of the channel. + """ + result = { + "id": self.id, + "token": self.token, + "type": self.type, + "address": self.address, + } + if self.params: + result["params"] = self.params + if self.resource_id: + result["resourceId"] = self.resource_id + if self.resource_uri: + result["resourceUri"] = self.resource_uri + if self.expiration: + result["expiration"] = self.expiration + + return result + + def update(self, resp): + """Update a channel with information from the response of watch(). + + When a request is sent to watch() a resource, the response returned + from the watch() request is a dictionary with updated channel information, + such as the resource_id, which is needed when stopping a subscription. + + Args: + resp: dict, The response from a watch() method. + """ + for json_name, param_name in CHANNEL_PARAMS.items(): + value = resp.get(json_name) + if value is not None: + setattr(self, param_name, value) + + +def notification_from_headers(channel, headers): + """Parse a notification from the webhook request headers, validate + the notification, and return a Notification object. + + Args: + channel: Channel, The channel that the notification is associated with. + headers: dict, A dictionary like object that contains the request headers + from the webhook HTTP request. + + Returns: + A Notification object. + + Raises: + errors.InvalidNotificationError if the notification is invalid. + ValueError if the X-GOOG-MESSAGE-NUMBER can't be converted to an int. + """ + headers = _upper_header_keys(headers) + channel_id = headers[X_GOOG_CHANNEL_ID] + if channel.id != channel_id: + raise errors.InvalidNotificationError( + "Channel id mismatch: %s != %s" % (channel.id, channel_id) + ) + else: + message_number = int(headers[X_GOOG_MESSAGE_NUMBER]) + state = headers[X_GOOG_RESOURCE_STATE] + resource_uri = headers[X_GOOG_RESOURCE_URI] + resource_id = headers[X_GOOG_RESOURCE_ID] + return Notification(message_number, state, resource_uri, resource_id) + + +@util.positional(2) +def new_webhook_channel(url, token=None, expiration=None, params=None): + """Create a new webhook Channel. + + Args: + url: str, URL to post notifications to. + token: str, An arbitrary string associated with the channel that + is delivered to the target address with each notification delivered + over this channel. + expiration: datetime.datetime, A time in the future when the channel + should expire. Can also be None if the subscription should use the + default expiration. Note that different services may have different + limits on how long a subscription lasts. Check the response from the + watch() method to see the value the service has set for an expiration + time. + params: dict, Extra parameters to pass on channel creation. Currently + not used for webhook channels. + """ + expiration_ms = 0 + if expiration: + delta = expiration - EPOCH + expiration_ms = ( + delta.microseconds / 1000 + (delta.seconds + delta.days * 24 * 3600) * 1000 + ) + if expiration_ms < 0: + expiration_ms = 0 + + return Channel( + "web_hook", + str(uuid.uuid4()), + token, + url, + expiration=expiration_ms, + params=params, + ) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery.py b/.venv/lib/python3.11/site-packages/googleapiclient/discovery.py new file mode 100644 index 0000000000000000000000000000000000000000..f7bbd77763c1218e42622ce6fb4f84ce6206e98f --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery.py @@ -0,0 +1,1662 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""Client for discovery based APIs. + +A client library for Google's discovery based APIs. +""" +from __future__ import absolute_import + +__author__ = "jcgregorio@google.com (Joe Gregorio)" +__all__ = ["build", "build_from_document", "fix_method_name", "key2param"] + +from collections import OrderedDict +import collections.abc + +# Standard library imports +import copy +from email.generator import BytesGenerator +from email.mime.multipart import MIMEMultipart +from email.mime.nonmultipart import MIMENonMultipart +import http.client as http_client +import io +import json +import keyword +import logging +import mimetypes +import os +import re +import urllib + +import google.api_core.client_options +from google.auth.exceptions import MutualTLSChannelError +from google.auth.transport import mtls +from google.oauth2 import service_account + +# Third-party imports +import httplib2 +import uritemplate + +try: + import google_auth_httplib2 +except ImportError: # pragma: NO COVER + google_auth_httplib2 = None + +try: + from google.api_core import universe + + HAS_UNIVERSE = True +except ImportError: + HAS_UNIVERSE = False + +# Local imports +from googleapiclient import _auth, mimeparse +from googleapiclient._helpers import _add_query_parameter, positional +from googleapiclient.errors import ( + HttpError, + InvalidJsonError, + MediaUploadSizeError, + UnacceptableMimeTypeError, + UnknownApiNameOrVersion, + UnknownFileType, +) +from googleapiclient.http import ( + BatchHttpRequest, + HttpMock, + HttpMockSequence, + HttpRequest, + MediaFileUpload, + MediaUpload, + build_http, +) +from googleapiclient.model import JsonModel, MediaModel, RawModel +from googleapiclient.schema import Schemas + +# The client library requires a version of httplib2 that supports RETRIES. +httplib2.RETRIES = 1 + +logger = logging.getLogger(__name__) + +URITEMPLATE = re.compile("{[^}]*}") +VARNAME = re.compile("[a-zA-Z0-9_-]+") +DISCOVERY_URI = ( + "https://www.googleapis.com/discovery/v1/apis/" "{api}/{apiVersion}/rest" +) +V1_DISCOVERY_URI = DISCOVERY_URI +V2_DISCOVERY_URI = ( + "https://{api}.googleapis.com/$discovery/rest?" "version={apiVersion}" +) +DEFAULT_METHOD_DOC = "A description of how to use this function" +HTTP_PAYLOAD_METHODS = frozenset(["PUT", "POST", "PATCH"]) + +_MEDIA_SIZE_BIT_SHIFTS = {"KB": 10, "MB": 20, "GB": 30, "TB": 40} +BODY_PARAMETER_DEFAULT_VALUE = {"description": "The request body.", "type": "object"} +MEDIA_BODY_PARAMETER_DEFAULT_VALUE = { + "description": ( + "The filename of the media request body, or an instance " + "of a MediaUpload object." + ), + "type": "string", + "required": False, +} +MEDIA_MIME_TYPE_PARAMETER_DEFAULT_VALUE = { + "description": ( + "The MIME type of the media request body, or an instance " + "of a MediaUpload object." + ), + "type": "string", + "required": False, +} +_PAGE_TOKEN_NAMES = ("pageToken", "nextPageToken") + +# Parameters controlling mTLS behavior. See https://google.aip.dev/auth/4114. +GOOGLE_API_USE_CLIENT_CERTIFICATE = "GOOGLE_API_USE_CLIENT_CERTIFICATE" +GOOGLE_API_USE_MTLS_ENDPOINT = "GOOGLE_API_USE_MTLS_ENDPOINT" +GOOGLE_CLOUD_UNIVERSE_DOMAIN = "GOOGLE_CLOUD_UNIVERSE_DOMAIN" +DEFAULT_UNIVERSE = "googleapis.com" +# Parameters accepted by the stack, but not visible via discovery. +# TODO(dhermes): Remove 'userip' in 'v2'. +STACK_QUERY_PARAMETERS = frozenset(["trace", "pp", "userip", "strict"]) +STACK_QUERY_PARAMETER_DEFAULT_VALUE = {"type": "string", "location": "query"} + + +class APICoreVersionError(ValueError): + def __init__(self): + message = ( + "google-api-core >= 2.18.0 is required to use the universe domain feature." + ) + super().__init__(message) + + +# Library-specific reserved words beyond Python keywords. +RESERVED_WORDS = frozenset(["body"]) + +# patch _write_lines to avoid munging '\r' into '\n' +# ( https://bugs.python.org/issue18886 https://bugs.python.org/issue19003 ) +class _BytesGenerator(BytesGenerator): + _write_lines = BytesGenerator.write + + +def fix_method_name(name): + """Fix method names to avoid '$' characters and reserved word conflicts. + + Args: + name: string, method name. + + Returns: + The name with '_' appended if the name is a reserved word and '$' and '-' + replaced with '_'. + """ + name = name.replace("$", "_").replace("-", "_") + if keyword.iskeyword(name) or name in RESERVED_WORDS: + return name + "_" + else: + return name + + +def key2param(key): + """Converts key names into parameter names. + + For example, converting "max-results" -> "max_results" + + Args: + key: string, the method key name. + + Returns: + A safe method name based on the key name. + """ + result = [] + key = list(key) + if not key[0].isalpha(): + result.append("x") + for c in key: + if c.isalnum(): + result.append(c) + else: + result.append("_") + + return "".join(result) + + +@positional(2) +def build( + serviceName, + version, + http=None, + discoveryServiceUrl=None, + developerKey=None, + model=None, + requestBuilder=HttpRequest, + credentials=None, + cache_discovery=True, + cache=None, + client_options=None, + adc_cert_path=None, + adc_key_path=None, + num_retries=1, + static_discovery=None, + always_use_jwt_access=False, +): + """Construct a Resource for interacting with an API. + + Construct a Resource object for interacting with an API. The serviceName and + version are the names from the Discovery service. + + Args: + serviceName: string, name of the service. + version: string, the version of the service. + http: httplib2.Http, An instance of httplib2.Http or something that acts + like it that HTTP requests will be made through. + discoveryServiceUrl: string, a URI Template that points to the location of + the discovery service. It should have two parameters {api} and + {apiVersion} that when filled in produce an absolute URI to the discovery + document for that service. + developerKey: string, key obtained from + https://code.google.com/apis/console. + model: googleapiclient.Model, converts to and from the wire format. + requestBuilder: googleapiclient.http.HttpRequest, encapsulator for an HTTP + request. + credentials: oauth2client.Credentials or + google.auth.credentials.Credentials, credentials to be used for + authentication. + cache_discovery: Boolean, whether or not to cache the discovery doc. + cache: googleapiclient.discovery_cache.base.CacheBase, an optional + cache object for the discovery documents. + client_options: Mapping object or google.api_core.client_options, client + options to set user options on the client. + (1) The API endpoint should be set through client_options. If API endpoint + is not set, `GOOGLE_API_USE_MTLS_ENDPOINT` environment variable can be used + to control which endpoint to use. + (2) client_cert_source is not supported, client cert should be provided using + client_encrypted_cert_source instead. In order to use the provided client + cert, `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be + set to `true`. + More details on the environment variables are here: + https://google.aip.dev/auth/4114 + adc_cert_path: str, client certificate file path to save the application + default client certificate for mTLS. This field is required if you want to + use the default client certificate. `GOOGLE_API_USE_CLIENT_CERTIFICATE` + environment variable must be set to `true` in order to use this field, + otherwise this field doesn't nothing. + More details on the environment variables are here: + https://google.aip.dev/auth/4114 + adc_key_path: str, client encrypted private key file path to save the + application default client encrypted private key for mTLS. This field is + required if you want to use the default client certificate. + `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be set to + `true` in order to use this field, otherwise this field doesn't nothing. + More details on the environment variables are here: + https://google.aip.dev/auth/4114 + num_retries: Integer, number of times to retry discovery with + randomized exponential backoff in case of intermittent/connection issues. + static_discovery: Boolean, whether or not to use the static discovery docs + included in the library. The default value for `static_discovery` depends + on the value of `discoveryServiceUrl`. `static_discovery` will default to + `True` when `discoveryServiceUrl` is also not provided, otherwise it will + default to `False`. + always_use_jwt_access: Boolean, whether always use self signed JWT for service + account credentials. This only applies to + google.oauth2.service_account.Credentials. + + Returns: + A Resource object with methods for interacting with the service. + + Raises: + google.auth.exceptions.MutualTLSChannelError: if there are any problems + setting up mutual TLS channel. + """ + params = {"api": serviceName, "apiVersion": version} + + # The default value for `static_discovery` depends on the value of + # `discoveryServiceUrl`. `static_discovery` will default to `True` when + # `discoveryServiceUrl` is also not provided, otherwise it will default to + # `False`. This is added for backwards compatability with + # google-api-python-client 1.x which does not support the `static_discovery` + # parameter. + if static_discovery is None: + if discoveryServiceUrl is None: + static_discovery = True + else: + static_discovery = False + + if http is None: + discovery_http = build_http() + else: + discovery_http = http + + service = None + + for discovery_url in _discovery_service_uri_options(discoveryServiceUrl, version): + requested_url = uritemplate.expand(discovery_url, params) + + try: + content = _retrieve_discovery_doc( + requested_url, + discovery_http, + cache_discovery, + serviceName, + version, + cache, + developerKey, + num_retries=num_retries, + static_discovery=static_discovery, + ) + service = build_from_document( + content, + base=discovery_url, + http=http, + developerKey=developerKey, + model=model, + requestBuilder=requestBuilder, + credentials=credentials, + client_options=client_options, + adc_cert_path=adc_cert_path, + adc_key_path=adc_key_path, + always_use_jwt_access=always_use_jwt_access, + ) + break # exit if a service was created + except HttpError as e: + if e.resp.status == http_client.NOT_FOUND: + continue + else: + raise e + + # If discovery_http was created by this function, we are done with it + # and can safely close it + if http is None: + discovery_http.close() + + if service is None: + raise UnknownApiNameOrVersion("name: %s version: %s" % (serviceName, version)) + else: + return service + + +def _discovery_service_uri_options(discoveryServiceUrl, version): + """ + Returns Discovery URIs to be used for attempting to build the API Resource. + + Args: + discoveryServiceUrl: + string, the Original Discovery Service URL preferred by the customer. + version: + string, API Version requested + + Returns: + A list of URIs to be tried for the Service Discovery, in order. + """ + + if discoveryServiceUrl is not None: + return [discoveryServiceUrl] + if version is None: + # V1 Discovery won't work if the requested version is None + logger.warning( + "Discovery V1 does not support empty versions. Defaulting to V2..." + ) + return [V2_DISCOVERY_URI] + else: + return [DISCOVERY_URI, V2_DISCOVERY_URI] + + +def _retrieve_discovery_doc( + url, + http, + cache_discovery, + serviceName, + version, + cache=None, + developerKey=None, + num_retries=1, + static_discovery=True, +): + """Retrieves the discovery_doc from cache or the internet. + + Args: + url: string, the URL of the discovery document. + http: httplib2.Http, An instance of httplib2.Http or something that acts + like it through which HTTP requests will be made. + cache_discovery: Boolean, whether or not to cache the discovery doc. + serviceName: string, name of the service. + version: string, the version of the service. + cache: googleapiclient.discovery_cache.base.Cache, an optional cache + object for the discovery documents. + developerKey: string, Key for controlling API usage, generated + from the API Console. + num_retries: Integer, number of times to retry discovery with + randomized exponential backoff in case of intermittent/connection issues. + static_discovery: Boolean, whether or not to use the static discovery docs + included in the library. + + Returns: + A unicode string representation of the discovery document. + """ + from . import discovery_cache + + if cache_discovery: + if cache is None: + cache = discovery_cache.autodetect() + if cache: + content = cache.get(url) + if content: + return content + + # When `static_discovery=True`, use static discovery artifacts included + # with the library + if static_discovery: + content = discovery_cache.get_static_doc(serviceName, version) + if content: + return content + else: + raise UnknownApiNameOrVersion( + "name: %s version: %s" % (serviceName, version) + ) + + actual_url = url + # REMOTE_ADDR is defined by the CGI spec [RFC3875] as the environment + # variable that contains the network address of the client sending the + # request. If it exists then add that to the request for the discovery + # document to avoid exceeding the quota on discovery requests. + if "REMOTE_ADDR" in os.environ: + actual_url = _add_query_parameter(url, "userIp", os.environ["REMOTE_ADDR"]) + if developerKey: + actual_url = _add_query_parameter(url, "key", developerKey) + logger.debug("URL being requested: GET %s", actual_url) + + # Execute this request with retries build into HttpRequest + # Note that it will already raise an error if we don't get a 2xx response + req = HttpRequest(http, HttpRequest.null_postproc, actual_url) + resp, content = req.execute(num_retries=num_retries) + + try: + content = content.decode("utf-8") + except AttributeError: + pass + + try: + service = json.loads(content) + except ValueError as e: + logger.error("Failed to parse as JSON: " + content) + raise InvalidJsonError() + if cache_discovery and cache: + cache.set(url, content) + return content + + +def _check_api_core_compatible_with_credentials_universe(credentials): + if not HAS_UNIVERSE: + credentials_universe = getattr(credentials, "universe_domain", None) + if credentials_universe and credentials_universe != DEFAULT_UNIVERSE: + raise APICoreVersionError + + +@positional(1) +def build_from_document( + service, + base=None, + future=None, + http=None, + developerKey=None, + model=None, + requestBuilder=HttpRequest, + credentials=None, + client_options=None, + adc_cert_path=None, + adc_key_path=None, + always_use_jwt_access=False, +): + """Create a Resource for interacting with an API. + + Same as `build()`, but constructs the Resource object from a discovery + document that is it given, as opposed to retrieving one over HTTP. + + Args: + service: string or object, the JSON discovery document describing the API. + The value passed in may either be the JSON string or the deserialized + JSON. + base: string, base URI for all HTTP requests, usually the discovery URI. + This parameter is no longer used as rootUrl and servicePath are included + within the discovery document. (deprecated) + future: string, discovery document with future capabilities (deprecated). + http: httplib2.Http, An instance of httplib2.Http or something that acts + like it that HTTP requests will be made through. + developerKey: string, Key for controlling API usage, generated + from the API Console. + model: Model class instance that serializes and de-serializes requests and + responses. + requestBuilder: Takes an http request and packages it up to be executed. + credentials: oauth2client.Credentials or + google.auth.credentials.Credentials, credentials to be used for + authentication. + client_options: Mapping object or google.api_core.client_options, client + options to set user options on the client. + (1) The API endpoint should be set through client_options. If API endpoint + is not set, `GOOGLE_API_USE_MTLS_ENDPOINT` environment variable can be used + to control which endpoint to use. + (2) client_cert_source is not supported, client cert should be provided using + client_encrypted_cert_source instead. In order to use the provided client + cert, `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be + set to `true`. + More details on the environment variables are here: + https://google.aip.dev/auth/4114 + adc_cert_path: str, client certificate file path to save the application + default client certificate for mTLS. This field is required if you want to + use the default client certificate. `GOOGLE_API_USE_CLIENT_CERTIFICATE` + environment variable must be set to `true` in order to use this field, + otherwise this field doesn't nothing. + More details on the environment variables are here: + https://google.aip.dev/auth/4114 + adc_key_path: str, client encrypted private key file path to save the + application default client encrypted private key for mTLS. This field is + required if you want to use the default client certificate. + `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be set to + `true` in order to use this field, otherwise this field doesn't nothing. + More details on the environment variables are here: + https://google.aip.dev/auth/4114 + always_use_jwt_access: Boolean, whether always use self signed JWT for service + account credentials. This only applies to + google.oauth2.service_account.Credentials. + + Returns: + A Resource object with methods for interacting with the service. + + Raises: + google.auth.exceptions.MutualTLSChannelError: if there are any problems + setting up mutual TLS channel. + """ + + if client_options is None: + client_options = google.api_core.client_options.ClientOptions() + if isinstance(client_options, collections.abc.Mapping): + client_options = google.api_core.client_options.from_dict(client_options) + + if http is not None: + # if http is passed, the user cannot provide credentials + banned_options = [ + (credentials, "credentials"), + (client_options.credentials_file, "client_options.credentials_file"), + ] + for option, name in banned_options: + if option is not None: + raise ValueError( + "Arguments http and {} are mutually exclusive".format(name) + ) + + if isinstance(service, str): + service = json.loads(service) + elif isinstance(service, bytes): + service = json.loads(service.decode("utf-8")) + + if "rootUrl" not in service and isinstance(http, (HttpMock, HttpMockSequence)): + logger.error( + "You are using HttpMock or HttpMockSequence without" + + "having the service discovery doc in cache. Try calling " + + "build() without mocking once first to populate the " + + "cache." + ) + raise InvalidJsonError() + + # If an API Endpoint is provided on client options, use that as the base URL + base = urllib.parse.urljoin(service["rootUrl"], service["servicePath"]) + universe_domain = None + if HAS_UNIVERSE: + universe_domain_env = os.getenv(GOOGLE_CLOUD_UNIVERSE_DOMAIN, None) + universe_domain = universe.determine_domain( + client_options.universe_domain, universe_domain_env + ) + base = base.replace(universe.DEFAULT_UNIVERSE, universe_domain) + else: + client_universe = getattr(client_options, "universe_domain", None) + if client_universe: + raise APICoreVersionError + + audience_for_self_signed_jwt = base + if client_options.api_endpoint: + base = client_options.api_endpoint + + schema = Schemas(service) + + # If the http client is not specified, then we must construct an http client + # to make requests. If the service has scopes, then we also need to setup + # authentication. + if http is None: + # Does the service require scopes? + scopes = list( + service.get("auth", {}).get("oauth2", {}).get("scopes", {}).keys() + ) + + # If so, then the we need to setup authentication if no developerKey is + # specified. + if scopes and not developerKey: + # Make sure the user didn't pass multiple credentials + if client_options.credentials_file and credentials: + raise google.api_core.exceptions.DuplicateCredentialArgs( + "client_options.credentials_file and credentials are mutually exclusive." + ) + # Check for credentials file via client options + if client_options.credentials_file: + credentials = _auth.credentials_from_file( + client_options.credentials_file, + scopes=client_options.scopes, + quota_project_id=client_options.quota_project_id, + ) + # If the user didn't pass in credentials, attempt to acquire application + # default credentials. + if credentials is None: + credentials = _auth.default_credentials( + scopes=client_options.scopes, + quota_project_id=client_options.quota_project_id, + ) + + # Check google-api-core >= 2.18.0 if credentials' universe != "googleapis.com". + _check_api_core_compatible_with_credentials_universe(credentials) + + # The credentials need to be scoped. + # If the user provided scopes via client_options don't override them + if not client_options.scopes: + credentials = _auth.with_scopes(credentials, scopes) + + # For google-auth service account credentials, enable self signed JWT if + # always_use_jwt_access is true. + if ( + credentials + and isinstance(credentials, service_account.Credentials) + and always_use_jwt_access + and hasattr(service_account.Credentials, "with_always_use_jwt_access") + ): + credentials = credentials.with_always_use_jwt_access(always_use_jwt_access) + credentials._create_self_signed_jwt(audience_for_self_signed_jwt) + + # If credentials are provided, create an authorized http instance; + # otherwise, skip authentication. + if credentials: + http = _auth.authorized_http(credentials) + + # If the service doesn't require scopes then there is no need for + # authentication. + else: + http = build_http() + + # Obtain client cert and create mTLS http channel if cert exists. + client_cert_to_use = None + use_client_cert = os.getenv(GOOGLE_API_USE_CLIENT_CERTIFICATE, "false") + if not use_client_cert in ("true", "false"): + raise MutualTLSChannelError( + "Unsupported GOOGLE_API_USE_CLIENT_CERTIFICATE value. Accepted values: true, false" + ) + if client_options and client_options.client_cert_source: + raise MutualTLSChannelError( + "ClientOptions.client_cert_source is not supported, please use ClientOptions.client_encrypted_cert_source." + ) + if use_client_cert == "true": + if ( + client_options + and hasattr(client_options, "client_encrypted_cert_source") + and client_options.client_encrypted_cert_source + ): + client_cert_to_use = client_options.client_encrypted_cert_source + elif ( + adc_cert_path and adc_key_path and mtls.has_default_client_cert_source() + ): + client_cert_to_use = mtls.default_client_encrypted_cert_source( + adc_cert_path, adc_key_path + ) + if client_cert_to_use: + cert_path, key_path, passphrase = client_cert_to_use() + + # The http object we built could be google_auth_httplib2.AuthorizedHttp + # or httplib2.Http. In the first case we need to extract the wrapped + # httplib2.Http object from google_auth_httplib2.AuthorizedHttp. + http_channel = ( + http.http + if google_auth_httplib2 + and isinstance(http, google_auth_httplib2.AuthorizedHttp) + else http + ) + http_channel.add_certificate(key_path, cert_path, "", passphrase) + + # If user doesn't provide api endpoint via client options, decide which + # api endpoint to use. + if "mtlsRootUrl" in service and ( + not client_options or not client_options.api_endpoint + ): + mtls_endpoint = urllib.parse.urljoin( + service["mtlsRootUrl"], service["servicePath"] + ) + use_mtls_endpoint = os.getenv(GOOGLE_API_USE_MTLS_ENDPOINT, "auto") + + if not use_mtls_endpoint in ("never", "auto", "always"): + raise MutualTLSChannelError( + "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted values: never, auto, always" + ) + + # Switch to mTLS endpoint, if environment variable is "always", or + # environment varibable is "auto" and client cert exists. + if use_mtls_endpoint == "always" or ( + use_mtls_endpoint == "auto" and client_cert_to_use + ): + if HAS_UNIVERSE and universe_domain != universe.DEFAULT_UNIVERSE: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {universe.DEFAULT_UNIVERSE}." + ) + base = mtls_endpoint + else: + # Check google-api-core >= 2.18.0 if credentials' universe != "googleapis.com". + http_credentials = getattr(http, "credentials", None) + _check_api_core_compatible_with_credentials_universe(http_credentials) + + if model is None: + features = service.get("features", []) + model = JsonModel("dataWrapper" in features) + + return Resource( + http=http, + baseUrl=base, + model=model, + developerKey=developerKey, + requestBuilder=requestBuilder, + resourceDesc=service, + rootDesc=service, + schema=schema, + universe_domain=universe_domain, + ) + + +def _cast(value, schema_type): + """Convert value to a string based on JSON Schema type. + + See http://tools.ietf.org/html/draft-zyp-json-schema-03 for more details on + JSON Schema. + + Args: + value: any, the value to convert + schema_type: string, the type that value should be interpreted as + + Returns: + A string representation of 'value' based on the schema_type. + """ + if schema_type == "string": + if type(value) == type("") or type(value) == type(""): + return value + else: + return str(value) + elif schema_type == "integer": + return str(int(value)) + elif schema_type == "number": + return str(float(value)) + elif schema_type == "boolean": + return str(bool(value)).lower() + else: + if type(value) == type("") or type(value) == type(""): + return value + else: + return str(value) + + +def _media_size_to_long(maxSize): + """Convert a string media size, such as 10GB or 3TB into an integer. + + Args: + maxSize: string, size as a string, such as 2MB or 7GB. + + Returns: + The size as an integer value. + """ + if len(maxSize) < 2: + return 0 + units = maxSize[-2:].upper() + bit_shift = _MEDIA_SIZE_BIT_SHIFTS.get(units) + if bit_shift is not None: + return int(maxSize[:-2]) << bit_shift + else: + return int(maxSize) + + +def _media_path_url_from_info(root_desc, path_url): + """Creates an absolute media path URL. + + Constructed using the API root URI and service path from the discovery + document and the relative path for the API method. + + Args: + root_desc: Dictionary; the entire original deserialized discovery document. + path_url: String; the relative URL for the API method. Relative to the API + root, which is specified in the discovery document. + + Returns: + String; the absolute URI for media upload for the API method. + """ + return "%(root)supload/%(service_path)s%(path)s" % { + "root": root_desc["rootUrl"], + "service_path": root_desc["servicePath"], + "path": path_url, + } + + +def _fix_up_parameters(method_desc, root_desc, http_method, schema): + """Updates parameters of an API method with values specific to this library. + + Specifically, adds whatever global parameters are specified by the API to the + parameters for the individual method. Also adds parameters which don't + appear in the discovery document, but are available to all discovery based + APIs (these are listed in STACK_QUERY_PARAMETERS). + + SIDE EFFECTS: This updates the parameters dictionary object in the method + description. + + Args: + method_desc: Dictionary with metadata describing an API method. Value comes + from the dictionary of methods stored in the 'methods' key in the + deserialized discovery document. + root_desc: Dictionary; the entire original deserialized discovery document. + http_method: String; the HTTP method used to call the API method described + in method_desc. + schema: Object, mapping of schema names to schema descriptions. + + Returns: + The updated Dictionary stored in the 'parameters' key of the method + description dictionary. + """ + parameters = method_desc.setdefault("parameters", {}) + + # Add in the parameters common to all methods. + for name, description in root_desc.get("parameters", {}).items(): + parameters[name] = description + + # Add in undocumented query parameters. + for name in STACK_QUERY_PARAMETERS: + parameters[name] = STACK_QUERY_PARAMETER_DEFAULT_VALUE.copy() + + # Add 'body' (our own reserved word) to parameters if the method supports + # a request payload. + if http_method in HTTP_PAYLOAD_METHODS and "request" in method_desc: + body = BODY_PARAMETER_DEFAULT_VALUE.copy() + body.update(method_desc["request"]) + parameters["body"] = body + + return parameters + + +def _fix_up_media_upload(method_desc, root_desc, path_url, parameters): + """Adds 'media_body' and 'media_mime_type' parameters if supported by method. + + SIDE EFFECTS: If there is a 'mediaUpload' in the method description, adds + 'media_upload' key to parameters. + + Args: + method_desc: Dictionary with metadata describing an API method. Value comes + from the dictionary of methods stored in the 'methods' key in the + deserialized discovery document. + root_desc: Dictionary; the entire original deserialized discovery document. + path_url: String; the relative URL for the API method. Relative to the API + root, which is specified in the discovery document. + parameters: A dictionary describing method parameters for method described + in method_desc. + + Returns: + Triple (accept, max_size, media_path_url) where: + - accept is a list of strings representing what content types are + accepted for media upload. Defaults to empty list if not in the + discovery document. + - max_size is a long representing the max size in bytes allowed for a + media upload. Defaults to 0L if not in the discovery document. + - media_path_url is a String; the absolute URI for media upload for the + API method. Constructed using the API root URI and service path from + the discovery document and the relative path for the API method. If + media upload is not supported, this is None. + """ + media_upload = method_desc.get("mediaUpload", {}) + accept = media_upload.get("accept", []) + max_size = _media_size_to_long(media_upload.get("maxSize", "")) + media_path_url = None + + if media_upload: + media_path_url = _media_path_url_from_info(root_desc, path_url) + parameters["media_body"] = MEDIA_BODY_PARAMETER_DEFAULT_VALUE.copy() + parameters["media_mime_type"] = MEDIA_MIME_TYPE_PARAMETER_DEFAULT_VALUE.copy() + + return accept, max_size, media_path_url + + +def _fix_up_method_description(method_desc, root_desc, schema): + """Updates a method description in a discovery document. + + SIDE EFFECTS: Changes the parameters dictionary in the method description with + extra parameters which are used locally. + + Args: + method_desc: Dictionary with metadata describing an API method. Value comes + from the dictionary of methods stored in the 'methods' key in the + deserialized discovery document. + root_desc: Dictionary; the entire original deserialized discovery document. + schema: Object, mapping of schema names to schema descriptions. + + Returns: + Tuple (path_url, http_method, method_id, accept, max_size, media_path_url) + where: + - path_url is a String; the relative URL for the API method. Relative to + the API root, which is specified in the discovery document. + - http_method is a String; the HTTP method used to call the API method + described in the method description. + - method_id is a String; the name of the RPC method associated with the + API method, and is in the method description in the 'id' key. + - accept is a list of strings representing what content types are + accepted for media upload. Defaults to empty list if not in the + discovery document. + - max_size is a long representing the max size in bytes allowed for a + media upload. Defaults to 0L if not in the discovery document. + - media_path_url is a String; the absolute URI for media upload for the + API method. Constructed using the API root URI and service path from + the discovery document and the relative path for the API method. If + media upload is not supported, this is None. + """ + path_url = method_desc["path"] + http_method = method_desc["httpMethod"] + method_id = method_desc["id"] + + parameters = _fix_up_parameters(method_desc, root_desc, http_method, schema) + # Order is important. `_fix_up_media_upload` needs `method_desc` to have a + # 'parameters' key and needs to know if there is a 'body' parameter because it + # also sets a 'media_body' parameter. + accept, max_size, media_path_url = _fix_up_media_upload( + method_desc, root_desc, path_url, parameters + ) + + return path_url, http_method, method_id, accept, max_size, media_path_url + + +def _fix_up_media_path_base_url(media_path_url, base_url): + """ + Update the media upload base url if its netloc doesn't match base url netloc. + + This can happen in case the base url was overridden by + client_options.api_endpoint. + + Args: + media_path_url: String; the absolute URI for media upload. + base_url: string, base URL for the API. All requests are relative to this URI. + + Returns: + String; the absolute URI for media upload. + """ + parsed_media_url = urllib.parse.urlparse(media_path_url) + parsed_base_url = urllib.parse.urlparse(base_url) + if parsed_media_url.netloc == parsed_base_url.netloc: + return media_path_url + return urllib.parse.urlunparse( + parsed_media_url._replace(netloc=parsed_base_url.netloc) + ) + + +def _urljoin(base, url): + """Custom urljoin replacement supporting : before / in url.""" + # In general, it's unsafe to simply join base and url. However, for + # the case of discovery documents, we know: + # * base will never contain params, query, or fragment + # * url will never contain a scheme or net_loc. + # In general, this means we can safely join on /; we just need to + # ensure we end up with precisely one / joining base and url. The + # exception here is the case of media uploads, where url will be an + # absolute url. + if url.startswith("http://") or url.startswith("https://"): + return urllib.parse.urljoin(base, url) + new_base = base if base.endswith("/") else base + "/" + new_url = url[1:] if url.startswith("/") else url + return new_base + new_url + + +# TODO(dhermes): Convert this class to ResourceMethod and make it callable +class ResourceMethodParameters(object): + """Represents the parameters associated with a method. + + Attributes: + argmap: Map from method parameter name (string) to query parameter name + (string). + required_params: List of required parameters (represented by parameter + name as string). + repeated_params: List of repeated parameters (represented by parameter + name as string). + pattern_params: Map from method parameter name (string) to regular + expression (as a string). If the pattern is set for a parameter, the + value for that parameter must match the regular expression. + query_params: List of parameters (represented by parameter name as string) + that will be used in the query string. + path_params: Set of parameters (represented by parameter name as string) + that will be used in the base URL path. + param_types: Map from method parameter name (string) to parameter type. Type + can be any valid JSON schema type; valid values are 'any', 'array', + 'boolean', 'integer', 'number', 'object', or 'string'. Reference: + http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1 + enum_params: Map from method parameter name (string) to list of strings, + where each list of strings is the list of acceptable enum values. + """ + + def __init__(self, method_desc): + """Constructor for ResourceMethodParameters. + + Sets default values and defers to set_parameters to populate. + + Args: + method_desc: Dictionary with metadata describing an API method. Value + comes from the dictionary of methods stored in the 'methods' key in + the deserialized discovery document. + """ + self.argmap = {} + self.required_params = [] + self.repeated_params = [] + self.pattern_params = {} + self.query_params = [] + # TODO(dhermes): Change path_params to a list if the extra URITEMPLATE + # parsing is gotten rid of. + self.path_params = set() + self.param_types = {} + self.enum_params = {} + + self.set_parameters(method_desc) + + def set_parameters(self, method_desc): + """Populates maps and lists based on method description. + + Iterates through each parameter for the method and parses the values from + the parameter dictionary. + + Args: + method_desc: Dictionary with metadata describing an API method. Value + comes from the dictionary of methods stored in the 'methods' key in + the deserialized discovery document. + """ + parameters = method_desc.get("parameters", {}) + sorted_parameters = OrderedDict(sorted(parameters.items())) + for arg, desc in sorted_parameters.items(): + param = key2param(arg) + self.argmap[param] = arg + + if desc.get("pattern"): + self.pattern_params[param] = desc["pattern"] + if desc.get("enum"): + self.enum_params[param] = desc["enum"] + if desc.get("required"): + self.required_params.append(param) + if desc.get("repeated"): + self.repeated_params.append(param) + if desc.get("location") == "query": + self.query_params.append(param) + if desc.get("location") == "path": + self.path_params.add(param) + self.param_types[param] = desc.get("type", "string") + + # TODO(dhermes): Determine if this is still necessary. Discovery based APIs + # should have all path parameters already marked with + # 'location: path'. + for match in URITEMPLATE.finditer(method_desc["path"]): + for namematch in VARNAME.finditer(match.group(0)): + name = key2param(namematch.group(0)) + self.path_params.add(name) + if name in self.query_params: + self.query_params.remove(name) + + +def createMethod(methodName, methodDesc, rootDesc, schema): + """Creates a method for attaching to a Resource. + + Args: + methodName: string, name of the method to use. + methodDesc: object, fragment of deserialized discovery document that + describes the method. + rootDesc: object, the entire deserialized discovery document. + schema: object, mapping of schema names to schema descriptions. + """ + methodName = fix_method_name(methodName) + ( + pathUrl, + httpMethod, + methodId, + accept, + maxSize, + mediaPathUrl, + ) = _fix_up_method_description(methodDesc, rootDesc, schema) + + parameters = ResourceMethodParameters(methodDesc) + + def method(self, **kwargs): + # Don't bother with doc string, it will be over-written by createMethod. + + # Validate credentials for the configured universe. + self._validate_credentials() + + for name in kwargs: + if name not in parameters.argmap: + raise TypeError("Got an unexpected keyword argument {}".format(name)) + + # Remove args that have a value of None. + keys = list(kwargs.keys()) + for name in keys: + if kwargs[name] is None: + del kwargs[name] + + for name in parameters.required_params: + if name not in kwargs: + # temporary workaround for non-paging methods incorrectly requiring + # page token parameter (cf. drive.changes.watch vs. drive.changes.list) + if name not in _PAGE_TOKEN_NAMES or _findPageTokenName( + _methodProperties(methodDesc, schema, "response") + ): + raise TypeError('Missing required parameter "%s"' % name) + + for name, regex in parameters.pattern_params.items(): + if name in kwargs: + if isinstance(kwargs[name], str): + pvalues = [kwargs[name]] + else: + pvalues = kwargs[name] + for pvalue in pvalues: + if re.match(regex, pvalue) is None: + raise TypeError( + 'Parameter "%s" value "%s" does not match the pattern "%s"' + % (name, pvalue, regex) + ) + + for name, enums in parameters.enum_params.items(): + if name in kwargs: + # We need to handle the case of a repeated enum + # name differently, since we want to handle both + # arg='value' and arg=['value1', 'value2'] + if name in parameters.repeated_params and not isinstance( + kwargs[name], str + ): + values = kwargs[name] + else: + values = [kwargs[name]] + for value in values: + if value not in enums: + raise TypeError( + 'Parameter "%s" value "%s" is not an allowed value in "%s"' + % (name, value, str(enums)) + ) + + actual_query_params = {} + actual_path_params = {} + for key, value in kwargs.items(): + to_type = parameters.param_types.get(key, "string") + # For repeated parameters we cast each member of the list. + if key in parameters.repeated_params and type(value) == type([]): + cast_value = [_cast(x, to_type) for x in value] + else: + cast_value = _cast(value, to_type) + if key in parameters.query_params: + actual_query_params[parameters.argmap[key]] = cast_value + if key in parameters.path_params: + actual_path_params[parameters.argmap[key]] = cast_value + body_value = kwargs.get("body", None) + media_filename = kwargs.get("media_body", None) + media_mime_type = kwargs.get("media_mime_type", None) + + if self._developerKey: + actual_query_params["key"] = self._developerKey + + model = self._model + if methodName.endswith("_media"): + model = MediaModel() + elif "response" not in methodDesc: + model = RawModel() + + api_version = methodDesc.get("apiVersion", None) + + headers = {} + headers, params, query, body = model.request( + headers, actual_path_params, actual_query_params, body_value, api_version + ) + + expanded_url = uritemplate.expand(pathUrl, params) + url = _urljoin(self._baseUrl, expanded_url + query) + + resumable = None + multipart_boundary = "" + + if media_filename: + # Ensure we end up with a valid MediaUpload object. + if isinstance(media_filename, str): + if media_mime_type is None: + logger.warning( + "media_mime_type argument not specified: trying to auto-detect for %s", + media_filename, + ) + media_mime_type, _ = mimetypes.guess_type(media_filename) + if media_mime_type is None: + raise UnknownFileType(media_filename) + if not mimeparse.best_match([media_mime_type], ",".join(accept)): + raise UnacceptableMimeTypeError(media_mime_type) + media_upload = MediaFileUpload(media_filename, mimetype=media_mime_type) + elif isinstance(media_filename, MediaUpload): + media_upload = media_filename + else: + raise TypeError("media_filename must be str or MediaUpload.") + + # Check the maxSize + if media_upload.size() is not None and media_upload.size() > maxSize > 0: + raise MediaUploadSizeError("Media larger than: %s" % maxSize) + + # Use the media path uri for media uploads + expanded_url = uritemplate.expand(mediaPathUrl, params) + url = _urljoin(self._baseUrl, expanded_url + query) + url = _fix_up_media_path_base_url(url, self._baseUrl) + if media_upload.resumable(): + url = _add_query_parameter(url, "uploadType", "resumable") + + if media_upload.resumable(): + # This is all we need to do for resumable, if the body exists it gets + # sent in the first request, otherwise an empty body is sent. + resumable = media_upload + else: + # A non-resumable upload + if body is None: + # This is a simple media upload + headers["content-type"] = media_upload.mimetype() + body = media_upload.getbytes(0, media_upload.size()) + url = _add_query_parameter(url, "uploadType", "media") + else: + # This is a multipart/related upload. + msgRoot = MIMEMultipart("related") + # msgRoot should not write out it's own headers + setattr(msgRoot, "_write_headers", lambda self: None) + + # attach the body as one part + msg = MIMENonMultipart(*headers["content-type"].split("/")) + msg.set_payload(body) + msgRoot.attach(msg) + + # attach the media as the second part + msg = MIMENonMultipart(*media_upload.mimetype().split("/")) + msg["Content-Transfer-Encoding"] = "binary" + + payload = media_upload.getbytes(0, media_upload.size()) + msg.set_payload(payload) + msgRoot.attach(msg) + # encode the body: note that we can't use `as_string`, because + # it plays games with `From ` lines. + fp = io.BytesIO() + g = _BytesGenerator(fp, mangle_from_=False) + g.flatten(msgRoot, unixfrom=False) + body = fp.getvalue() + + multipart_boundary = msgRoot.get_boundary() + headers["content-type"] = ( + "multipart/related; " 'boundary="%s"' + ) % multipart_boundary + url = _add_query_parameter(url, "uploadType", "multipart") + + logger.debug("URL being requested: %s %s" % (httpMethod, url)) + return self._requestBuilder( + self._http, + model.response, + url, + method=httpMethod, + body=body, + headers=headers, + methodId=methodId, + resumable=resumable, + ) + + docs = [methodDesc.get("description", DEFAULT_METHOD_DOC), "\n\n"] + if len(parameters.argmap) > 0: + docs.append("Args:\n") + + # Skip undocumented params and params common to all methods. + skip_parameters = list(rootDesc.get("parameters", {}).keys()) + skip_parameters.extend(STACK_QUERY_PARAMETERS) + + all_args = list(parameters.argmap.keys()) + args_ordered = [key2param(s) for s in methodDesc.get("parameterOrder", [])] + + # Move body to the front of the line. + if "body" in all_args: + args_ordered.append("body") + + for name in sorted(all_args): + if name not in args_ordered: + args_ordered.append(name) + + for arg in args_ordered: + if arg in skip_parameters: + continue + + repeated = "" + if arg in parameters.repeated_params: + repeated = " (repeated)" + required = "" + if arg in parameters.required_params: + required = " (required)" + paramdesc = methodDesc["parameters"][parameters.argmap[arg]] + paramdoc = paramdesc.get("description", "A parameter") + if "$ref" in paramdesc: + docs.append( + (" %s: object, %s%s%s\n The object takes the form of:\n\n%s\n\n") + % ( + arg, + paramdoc, + required, + repeated, + schema.prettyPrintByName(paramdesc["$ref"]), + ) + ) + else: + paramtype = paramdesc.get("type", "string") + docs.append( + " %s: %s, %s%s%s\n" % (arg, paramtype, paramdoc, required, repeated) + ) + enum = paramdesc.get("enum", []) + enumDesc = paramdesc.get("enumDescriptions", []) + if enum and enumDesc: + docs.append(" Allowed values\n") + for (name, desc) in zip(enum, enumDesc): + docs.append(" %s - %s\n" % (name, desc)) + if "response" in methodDesc: + if methodName.endswith("_media"): + docs.append("\nReturns:\n The media object as a string.\n\n ") + else: + docs.append("\nReturns:\n An object of the form:\n\n ") + docs.append(schema.prettyPrintSchema(methodDesc["response"])) + + setattr(method, "__doc__", "".join(docs)) + return (methodName, method) + + +def createNextMethod( + methodName, + pageTokenName="pageToken", + nextPageTokenName="nextPageToken", + isPageTokenParameter=True, +): + """Creates any _next methods for attaching to a Resource. + + The _next methods allow for easy iteration through list() responses. + + Args: + methodName: string, name of the method to use. + pageTokenName: string, name of request page token field. + nextPageTokenName: string, name of response page token field. + isPageTokenParameter: Boolean, True if request page token is a query + parameter, False if request page token is a field of the request body. + """ + methodName = fix_method_name(methodName) + + def methodNext(self, previous_request, previous_response): + """Retrieves the next page of results. + + Args: + previous_request: The request for the previous page. (required) + previous_response: The response from the request for the previous page. (required) + + Returns: + A request object that you can call 'execute()' on to request the next + page. Returns None if there are no more items in the collection. + """ + # Retrieve nextPageToken from previous_response + # Use as pageToken in previous_request to create new request. + + nextPageToken = previous_response.get(nextPageTokenName, None) + if not nextPageToken: + return None + + request = copy.copy(previous_request) + + if isPageTokenParameter: + # Replace pageToken value in URI + request.uri = _add_query_parameter( + request.uri, pageTokenName, nextPageToken + ) + logger.debug("Next page request URL: %s %s" % (methodName, request.uri)) + else: + # Replace pageToken value in request body + model = self._model + body = model.deserialize(request.body) + body[pageTokenName] = nextPageToken + request.body = model.serialize(body) + request.body_size = len(request.body) + if "content-length" in request.headers: + del request.headers["content-length"] + logger.debug("Next page request body: %s %s" % (methodName, body)) + + return request + + return (methodName, methodNext) + + +class Resource(object): + """A class for interacting with a resource.""" + + def __init__( + self, + http, + baseUrl, + model, + requestBuilder, + developerKey, + resourceDesc, + rootDesc, + schema, + universe_domain=universe.DEFAULT_UNIVERSE if HAS_UNIVERSE else "", + ): + """Build a Resource from the API description. + + Args: + http: httplib2.Http, Object to make http requests with. + baseUrl: string, base URL for the API. All requests are relative to this + URI. + model: googleapiclient.Model, converts to and from the wire format. + requestBuilder: class or callable that instantiates an + googleapiclient.HttpRequest object. + developerKey: string, key obtained from + https://code.google.com/apis/console + resourceDesc: object, section of deserialized discovery document that + describes a resource. Note that the top level discovery document + is considered a resource. + rootDesc: object, the entire deserialized discovery document. + schema: object, mapping of schema names to schema descriptions. + universe_domain: string, the universe for the API. The default universe + is "googleapis.com". + """ + self._dynamic_attrs = [] + + self._http = http + self._baseUrl = baseUrl + self._model = model + self._developerKey = developerKey + self._requestBuilder = requestBuilder + self._resourceDesc = resourceDesc + self._rootDesc = rootDesc + self._schema = schema + self._universe_domain = universe_domain + self._credentials_validated = False + + self._set_service_methods() + + def _set_dynamic_attr(self, attr_name, value): + """Sets an instance attribute and tracks it in a list of dynamic attributes. + + Args: + attr_name: string; The name of the attribute to be set + value: The value being set on the object and tracked in the dynamic cache. + """ + self._dynamic_attrs.append(attr_name) + self.__dict__[attr_name] = value + + def __getstate__(self): + """Trim the state down to something that can be pickled. + + Uses the fact that the instance variable _dynamic_attrs holds attrs that + will be wiped and restored on pickle serialization. + """ + state_dict = copy.copy(self.__dict__) + for dynamic_attr in self._dynamic_attrs: + del state_dict[dynamic_attr] + del state_dict["_dynamic_attrs"] + return state_dict + + def __setstate__(self, state): + """Reconstitute the state of the object from being pickled. + + Uses the fact that the instance variable _dynamic_attrs holds attrs that + will be wiped and restored on pickle serialization. + """ + self.__dict__.update(state) + self._dynamic_attrs = [] + self._set_service_methods() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, exc_tb): + self.close() + + def close(self): + """Close httplib2 connections.""" + # httplib2 leaves sockets open by default. + # Cleanup using the `close` method. + # https://github.com/httplib2/httplib2/issues/148 + self._http.close() + + def _set_service_methods(self): + self._add_basic_methods(self._resourceDesc, self._rootDesc, self._schema) + self._add_nested_resources(self._resourceDesc, self._rootDesc, self._schema) + self._add_next_methods(self._resourceDesc, self._schema) + + def _add_basic_methods(self, resourceDesc, rootDesc, schema): + # If this is the root Resource, add a new_batch_http_request() method. + if resourceDesc == rootDesc: + batch_uri = "%s%s" % ( + rootDesc["rootUrl"], + rootDesc.get("batchPath", "batch"), + ) + + def new_batch_http_request(callback=None): + """Create a BatchHttpRequest object based on the discovery document. + + Args: + callback: callable, A callback to be called for each response, of the + form callback(id, response, exception). The first parameter is the + request id, and the second is the deserialized response object. The + third is an apiclient.errors.HttpError exception object if an HTTP + error occurred while processing the request, or None if no error + occurred. + + Returns: + A BatchHttpRequest object based on the discovery document. + """ + return BatchHttpRequest(callback=callback, batch_uri=batch_uri) + + self._set_dynamic_attr("new_batch_http_request", new_batch_http_request) + + # Add basic methods to Resource + if "methods" in resourceDesc: + for methodName, methodDesc in resourceDesc["methods"].items(): + fixedMethodName, method = createMethod( + methodName, methodDesc, rootDesc, schema + ) + self._set_dynamic_attr( + fixedMethodName, method.__get__(self, self.__class__) + ) + # Add in _media methods. The functionality of the attached method will + # change when it sees that the method name ends in _media. + if methodDesc.get("supportsMediaDownload", False): + fixedMethodName, method = createMethod( + methodName + "_media", methodDesc, rootDesc, schema + ) + self._set_dynamic_attr( + fixedMethodName, method.__get__(self, self.__class__) + ) + + def _add_nested_resources(self, resourceDesc, rootDesc, schema): + # Add in nested resources + if "resources" in resourceDesc: + + def createResourceMethod(methodName, methodDesc): + """Create a method on the Resource to access a nested Resource. + + Args: + methodName: string, name of the method to use. + methodDesc: object, fragment of deserialized discovery document that + describes the method. + """ + methodName = fix_method_name(methodName) + + def methodResource(self): + return Resource( + http=self._http, + baseUrl=self._baseUrl, + model=self._model, + developerKey=self._developerKey, + requestBuilder=self._requestBuilder, + resourceDesc=methodDesc, + rootDesc=rootDesc, + schema=schema, + universe_domain=self._universe_domain, + ) + + setattr(methodResource, "__doc__", "A collection resource.") + setattr(methodResource, "__is_resource__", True) + + return (methodName, methodResource) + + for methodName, methodDesc in resourceDesc["resources"].items(): + fixedMethodName, method = createResourceMethod(methodName, methodDesc) + self._set_dynamic_attr( + fixedMethodName, method.__get__(self, self.__class__) + ) + + def _add_next_methods(self, resourceDesc, schema): + # Add _next() methods if and only if one of the names 'pageToken' or + # 'nextPageToken' occurs among the fields of both the method's response + # type either the method's request (query parameters) or request body. + if "methods" not in resourceDesc: + return + for methodName, methodDesc in resourceDesc["methods"].items(): + nextPageTokenName = _findPageTokenName( + _methodProperties(methodDesc, schema, "response") + ) + if not nextPageTokenName: + continue + isPageTokenParameter = True + pageTokenName = _findPageTokenName(methodDesc.get("parameters", {})) + if not pageTokenName: + isPageTokenParameter = False + pageTokenName = _findPageTokenName( + _methodProperties(methodDesc, schema, "request") + ) + if not pageTokenName: + continue + fixedMethodName, method = createNextMethod( + methodName + "_next", + pageTokenName, + nextPageTokenName, + isPageTokenParameter, + ) + self._set_dynamic_attr( + fixedMethodName, method.__get__(self, self.__class__) + ) + + def _validate_credentials(self): + """Validates client's and credentials' universe domains are consistent. + + Returns: + bool: True iff the configured universe domain is valid. + + Raises: + UniverseMismatchError: If the configured universe domain is not valid. + """ + credentials = getattr(self._http, "credentials", None) + + self._credentials_validated = ( + ( + self._credentials_validated + or universe.compare_domains(self._universe_domain, credentials) + ) + if HAS_UNIVERSE + else True + ) + return self._credentials_validated + + +def _findPageTokenName(fields): + """Search field names for one like a page token. + + Args: + fields: container of string, names of fields. + + Returns: + First name that is either 'pageToken' or 'nextPageToken' if one exists, + otherwise None. + """ + return next( + (tokenName for tokenName in _PAGE_TOKEN_NAMES if tokenName in fields), None + ) + + +def _methodProperties(methodDesc, schema, name): + """Get properties of a field in a method description. + + Args: + methodDesc: object, fragment of deserialized discovery document that + describes the method. + schema: object, mapping of schema names to schema descriptions. + name: string, name of top-level field in method description. + + Returns: + Object representing fragment of deserialized discovery document + corresponding to 'properties' field of object corresponding to named field + in method description, if it exists, otherwise empty dict. + """ + desc = methodDesc.get(name, {}) + if "$ref" in desc: + desc = schema.get(desc["$ref"], {}) + return desc.get("properties", {}) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__init__.py b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6051191e73760def19afd617851f82861810812a --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__init__.py @@ -0,0 +1,78 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""Caching utility for the discovery document.""" + +from __future__ import absolute_import + +import logging +import os + +LOGGER = logging.getLogger(__name__) + +DISCOVERY_DOC_MAX_AGE = 60 * 60 * 24 # 1 day +DISCOVERY_DOC_DIR = os.path.join( + os.path.dirname(os.path.realpath(__file__)), "documents" +) + + +def autodetect(): + """Detects an appropriate cache module and returns it. + + Returns: + googleapiclient.discovery_cache.base.Cache, a cache object which + is auto detected, or None if no cache object is available. + """ + if "GAE_ENV" in os.environ: + try: + from . import appengine_memcache + + return appengine_memcache.cache + except Exception: + pass + try: + from . import file_cache + + return file_cache.cache + except Exception: + LOGGER.info( + "file_cache is only supported with oauth2client<4.0.0", exc_info=False + ) + return None + + +def get_static_doc(serviceName, version): + """Retrieves the discovery document from the directory defined in + DISCOVERY_DOC_DIR corresponding to the serviceName and version provided. + + Args: + serviceName: string, name of the service. + version: string, the version of the service. + + Returns: + A string containing the contents of the JSON discovery document, + otherwise None if the JSON discovery document was not found. + """ + + content = None + doc_name = "{}.{}.json".format(serviceName, version) + + try: + with open(os.path.join(DISCOVERY_DOC_DIR, doc_name), "r") as f: + content = f.read() + except FileNotFoundError: + # File does not exist. Nothing to do here. + pass + + return content diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d3cb9472a433be202a9a9afed4caac394c5f4f5 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/__init__.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/appengine_memcache.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/appengine_memcache.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..003a29a026fa780d88edefb3cf80559e16b8d9dc Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/appengine_memcache.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/base.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/base.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26a0ca113979fed8d6c94167279ca67222c08971 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/base.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/file_cache.cpython-311.pyc b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/file_cache.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e49947680ba26a4f93667605b439f7825924502 Binary files /dev/null and b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__pycache__/file_cache.cpython-311.pyc differ diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/appengine_memcache.py b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/appengine_memcache.py new file mode 100644 index 0000000000000000000000000000000000000000..73a1decb96e531d9f3f492365ee176639c596c4a --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/appengine_memcache.py @@ -0,0 +1,55 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""App Engine memcache based cache for the discovery document.""" + +import logging + +# This is only an optional dependency because we only import this +# module when google.appengine.api.memcache is available. +from google.appengine.api import memcache + +from . import base +from ..discovery_cache import DISCOVERY_DOC_MAX_AGE + +LOGGER = logging.getLogger(__name__) + +NAMESPACE = "google-api-client" + + +class Cache(base.Cache): + """A cache with app engine memcache API.""" + + def __init__(self, max_age): + """Constructor. + + Args: + max_age: Cache expiration in seconds. + """ + self._max_age = max_age + + def get(self, url): + try: + return memcache.get(url, namespace=NAMESPACE) + except Exception as e: + LOGGER.warning(e, exc_info=True) + + def set(self, url, content): + try: + memcache.set(url, content, time=int(self._max_age), namespace=NAMESPACE) + except Exception as e: + LOGGER.warning(e, exc_info=True) + + +cache = Cache(max_age=DISCOVERY_DOC_MAX_AGE) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/base.py b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/base.py new file mode 100644 index 0000000000000000000000000000000000000000..41f3f3f0af5a027b480a746cdc04fc9056019f74 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/base.py @@ -0,0 +1,46 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""An abstract class for caching the discovery document.""" + +import abc + + +class Cache(object): + """A base abstract cache class.""" + + __metaclass__ = abc.ABCMeta + + @abc.abstractmethod + def get(self, url): + """Gets the content from the memcache with a given key. + + Args: + url: string, the key for the cache. + + Returns: + object, the value in the cache for the given key, or None if the key is + not in the cache. + """ + raise NotImplementedError() + + @abc.abstractmethod + def set(self, url, content): + """Sets the given key and content in the cache. + + Args: + url: string, the key for the cache. + content: string, the discovery document. + """ + raise NotImplementedError() diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/abusiveexperiencereport.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/abusiveexperiencereport.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..6ef6a43f6e0d92f0ae211da494729d1784cb8871 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/abusiveexperiencereport.v1.json @@ -0,0 +1,225 @@ +{ +"basePath": "", +"baseUrl": "https://abusiveexperiencereport.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Abusive Experience Report", +"description": "Views Abusive Experience Report data, and gets a list of sites that have a significant number of abusive experiences.", +"discoveryVersion": "v1", +"documentationLink": "https://developers.google.com/abusive-experience-report/", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "abusiveexperiencereport:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://abusiveexperiencereport.mtls.googleapis.com/", +"name": "abusiveexperiencereport", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"sites": { +"methods": { +"get": { +"description": "Gets a site's Abusive Experience Report summary.", +"flatPath": "v1/sites/{sitesId}", +"httpMethod": "GET", +"id": "abusiveexperiencereport.sites.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the site whose summary to get, e.g. `sites/http%3A%2F%2Fwww.google.com%2F`. Format: `sites/{site}`", +"location": "path", +"pattern": "^sites/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "SiteSummaryResponse" +} +} +} +}, +"violatingSites": { +"methods": { +"list": { +"description": "Lists sites that are failing in the Abusive Experience Report.", +"flatPath": "v1/violatingSites", +"httpMethod": "GET", +"id": "abusiveexperiencereport.violatingSites.list", +"parameterOrder": [], +"parameters": {}, +"path": "v1/violatingSites", +"response": { +"$ref": "ViolatingSitesResponse" +} +} +} +} +}, +"revision": "20240610", +"rootUrl": "https://abusiveexperiencereport.googleapis.com/", +"schemas": { +"SiteSummaryResponse": { +"description": "Response message for GetSiteSummary.", +"id": "SiteSummaryResponse", +"properties": { +"abusiveStatus": { +"description": "The site's Abusive Experience Report status.", +"enum": [ +"UNKNOWN", +"PASSING", +"FAILING" +], +"enumDescriptions": [ +"Not reviewed.", +"Passing.", +"Failing." +], +"type": "string" +}, +"enforcementTime": { +"description": "The time at which [enforcement](https://support.google.com/webtools/answer/7538608) against the site began or will begin. Not set when the filter_status is OFF.", +"format": "google-datetime", +"type": "string" +}, +"filterStatus": { +"description": "The site's [enforcement status](https://support.google.com/webtools/answer/7538608).", +"enum": [ +"UNKNOWN", +"ON", +"OFF", +"PAUSED", +"PENDING" +], +"enumDescriptions": [ +"N/A.", +"Enforcement is on.", +"Enforcement is off.", +"Enforcement is paused.", +"Enforcement is pending." +], +"type": "string" +}, +"lastChangeTime": { +"description": "The time at which the site's status last changed.", +"format": "google-datetime", +"type": "string" +}, +"reportUrl": { +"description": "A link to the full Abusive Experience Report for the site. Not set in ViolatingSitesResponse. Note that you must complete the [Search Console verification process](https://support.google.com/webmasters/answer/9008080) for the site before you can access the full report.", +"type": "string" +}, +"reviewedSite": { +"description": "The name of the reviewed site, e.g. `google.com`.", +"type": "string" +}, +"underReview": { +"description": "Whether the site is currently under review.", +"type": "boolean" +} +}, +"type": "object" +}, +"ViolatingSitesResponse": { +"description": "Response message for ListViolatingSites.", +"id": "ViolatingSitesResponse", +"properties": { +"violatingSites": { +"description": "The list of violating sites.", +"items": { +"$ref": "SiteSummaryResponse" +}, +"type": "array" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Abusive Experience Report API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/accessapproval.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/accessapproval.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..358f2ae0f8b0883ac96a720ec094ec7f5b65681a --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/accessapproval.v1.json @@ -0,0 +1,1361 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +} +} +} +}, +"basePath": "", +"baseUrl": "https://accessapproval.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Access Approval", +"description": "An API for controlling access to data by Google personnel.", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/assured-workloads/access-approval/docs", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "accessapproval:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://accessapproval.mtls.googleapis.com/", +"name": "accessapproval", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"folders": { +"methods": { +"deleteAccessApprovalSettings": { +"description": "Deletes the settings associated with a project, folder, or organization. This will have the effect of disabling Access Approval for the project, folder, or organization, but only if all ancestors also have Access Approval disabled. If Access Approval is enabled at a higher level of the hierarchy, then Access Approval will still be enabled at this level as the settings are inherited.", +"flatPath": "v1/folders/{foldersId}/accessApprovalSettings", +"httpMethod": "DELETE", +"id": "accessapproval.folders.deleteAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the AccessApprovalSettings to delete.", +"location": "path", +"pattern": "^folders/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getAccessApprovalSettings": { +"description": "Gets the settings associated with a project, folder, or organization.", +"flatPath": "v1/folders/{foldersId}/accessApprovalSettings", +"httpMethod": "GET", +"id": "accessapproval.folders.getAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the AccessApprovalSettings to retrieve. Format: \"{projects|folders|organizations}/{id}/accessApprovalSettings\"", +"location": "path", +"pattern": "^folders/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AccessApprovalSettings" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getServiceAccount": { +"description": "Retrieves the service account that is used by Access Approval to access KMS keys for signing approved approval requests.", +"flatPath": "v1/folders/{foldersId}/serviceAccount", +"httpMethod": "GET", +"id": "accessapproval.folders.getServiceAccount", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the AccessApprovalServiceAccount to retrieve.", +"location": "path", +"pattern": "^folders/[^/]+/serviceAccount$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AccessApprovalServiceAccount" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"updateAccessApprovalSettings": { +"description": "Updates the settings associated with a project, folder, or organization. Settings to update are determined by the value of field_mask.", +"flatPath": "v1/folders/{foldersId}/accessApprovalSettings", +"httpMethod": "PATCH", +"id": "accessapproval.folders.updateAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The resource name of the settings. Format is one of: * \"projects/{project}/accessApprovalSettings\" * \"folders/{folder}/accessApprovalSettings\" * \"organizations/{organization}/accessApprovalSettings\"", +"location": "path", +"pattern": "^folders/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "The update mask applies to the settings. Only the top level fields of AccessApprovalSettings (notification_emails & enrolled_services) are supported. For each field, if it is included, the currently stored value will be entirely overwritten with the value of the field passed in this request. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask If this field is left unset, only the notification_emails field will be updated.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "AccessApprovalSettings" +}, +"response": { +"$ref": "AccessApprovalSettings" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"approvalRequests": { +"methods": { +"approve": { +"description": "Approves a request and returns the updated ApprovalRequest. Returns NOT_FOUND if the request does not exist. Returns FAILED_PRECONDITION if the request exists but is not in a pending state.", +"flatPath": "v1/folders/{foldersId}/approvalRequests/{approvalRequestsId}:approve", +"httpMethod": "POST", +"id": "accessapproval.folders.approvalRequests.approve", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the approval request to approve.", +"location": "path", +"pattern": "^folders/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:approve", +"request": { +"$ref": "ApproveApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"dismiss": { +"description": "Dismisses a request. Returns the updated ApprovalRequest. NOTE: This does not deny access to the resource if another request has been made and approved. It is equivalent in effect to ignoring the request altogether. Returns NOT_FOUND if the request does not exist. Returns FAILED_PRECONDITION if the request exists but is not in a pending state.", +"flatPath": "v1/folders/{foldersId}/approvalRequests/{approvalRequestsId}:dismiss", +"httpMethod": "POST", +"id": "accessapproval.folders.approvalRequests.dismiss", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the ApprovalRequest to dismiss.", +"location": "path", +"pattern": "^folders/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:dismiss", +"request": { +"$ref": "DismissApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets an approval request. Returns NOT_FOUND if the request does not exist.", +"flatPath": "v1/folders/{foldersId}/approvalRequests/{approvalRequestsId}", +"httpMethod": "GET", +"id": "accessapproval.folders.approvalRequests.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the approval request to retrieve. Format: \"{projects|folders|organizations}/{id}/approvalRequests/{approval_request}\"", +"location": "path", +"pattern": "^folders/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"invalidate": { +"description": "Invalidates an existing ApprovalRequest. Returns the updated ApprovalRequest. NOTE: This does not deny access to the resource if another request has been made and approved. It only invalidates a single approval. Returns FAILED_PRECONDITION if the request exists but is not in an approved state.", +"flatPath": "v1/folders/{foldersId}/approvalRequests/{approvalRequestsId}:invalidate", +"httpMethod": "POST", +"id": "accessapproval.folders.approvalRequests.invalidate", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the ApprovalRequest to invalidate.", +"location": "path", +"pattern": "^folders/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:invalidate", +"request": { +"$ref": "InvalidateApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists approval requests associated with a project, folder, or organization. Approval requests can be filtered by state (pending, active, dismissed). The order is reverse chronological.", +"flatPath": "v1/folders/{foldersId}/approvalRequests", +"httpMethod": "GET", +"id": "accessapproval.folders.approvalRequests.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter on the type of approval requests to retrieve. Must be one of the following values: * [not set]: Requests that are pending or have active approvals. * ALL: All requests. * PENDING: Only pending requests. * ACTIVE: Only active (i.e. currently approved) requests. * DISMISSED: Only requests that have been dismissed, or requests that are not approved and past expiration. * EXPIRED: Only requests that have been approved, and the approval has expired. * HISTORY: Active, dismissed and expired requests.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Requested page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying the page of results to return.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "The parent resource. This may be \"projects/{project}\", \"folders/{folder}\", or \"organizations/{organization}\".", +"location": "path", +"pattern": "^folders/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/approvalRequests", +"response": { +"$ref": "ListApprovalRequestsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +}, +"organizations": { +"methods": { +"deleteAccessApprovalSettings": { +"description": "Deletes the settings associated with a project, folder, or organization. This will have the effect of disabling Access Approval for the project, folder, or organization, but only if all ancestors also have Access Approval disabled. If Access Approval is enabled at a higher level of the hierarchy, then Access Approval will still be enabled at this level as the settings are inherited.", +"flatPath": "v1/organizations/{organizationsId}/accessApprovalSettings", +"httpMethod": "DELETE", +"id": "accessapproval.organizations.deleteAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the AccessApprovalSettings to delete.", +"location": "path", +"pattern": "^organizations/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getAccessApprovalSettings": { +"description": "Gets the settings associated with a project, folder, or organization.", +"flatPath": "v1/organizations/{organizationsId}/accessApprovalSettings", +"httpMethod": "GET", +"id": "accessapproval.organizations.getAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the AccessApprovalSettings to retrieve. Format: \"{projects|folders|organizations}/{id}/accessApprovalSettings\"", +"location": "path", +"pattern": "^organizations/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AccessApprovalSettings" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getServiceAccount": { +"description": "Retrieves the service account that is used by Access Approval to access KMS keys for signing approved approval requests.", +"flatPath": "v1/organizations/{organizationsId}/serviceAccount", +"httpMethod": "GET", +"id": "accessapproval.organizations.getServiceAccount", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the AccessApprovalServiceAccount to retrieve.", +"location": "path", +"pattern": "^organizations/[^/]+/serviceAccount$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AccessApprovalServiceAccount" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"updateAccessApprovalSettings": { +"description": "Updates the settings associated with a project, folder, or organization. Settings to update are determined by the value of field_mask.", +"flatPath": "v1/organizations/{organizationsId}/accessApprovalSettings", +"httpMethod": "PATCH", +"id": "accessapproval.organizations.updateAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The resource name of the settings. Format is one of: * \"projects/{project}/accessApprovalSettings\" * \"folders/{folder}/accessApprovalSettings\" * \"organizations/{organization}/accessApprovalSettings\"", +"location": "path", +"pattern": "^organizations/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "The update mask applies to the settings. Only the top level fields of AccessApprovalSettings (notification_emails & enrolled_services) are supported. For each field, if it is included, the currently stored value will be entirely overwritten with the value of the field passed in this request. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask If this field is left unset, only the notification_emails field will be updated.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "AccessApprovalSettings" +}, +"response": { +"$ref": "AccessApprovalSettings" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"approvalRequests": { +"methods": { +"approve": { +"description": "Approves a request and returns the updated ApprovalRequest. Returns NOT_FOUND if the request does not exist. Returns FAILED_PRECONDITION if the request exists but is not in a pending state.", +"flatPath": "v1/organizations/{organizationsId}/approvalRequests/{approvalRequestsId}:approve", +"httpMethod": "POST", +"id": "accessapproval.organizations.approvalRequests.approve", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the approval request to approve.", +"location": "path", +"pattern": "^organizations/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:approve", +"request": { +"$ref": "ApproveApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"dismiss": { +"description": "Dismisses a request. Returns the updated ApprovalRequest. NOTE: This does not deny access to the resource if another request has been made and approved. It is equivalent in effect to ignoring the request altogether. Returns NOT_FOUND if the request does not exist. Returns FAILED_PRECONDITION if the request exists but is not in a pending state.", +"flatPath": "v1/organizations/{organizationsId}/approvalRequests/{approvalRequestsId}:dismiss", +"httpMethod": "POST", +"id": "accessapproval.organizations.approvalRequests.dismiss", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the ApprovalRequest to dismiss.", +"location": "path", +"pattern": "^organizations/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:dismiss", +"request": { +"$ref": "DismissApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets an approval request. Returns NOT_FOUND if the request does not exist.", +"flatPath": "v1/organizations/{organizationsId}/approvalRequests/{approvalRequestsId}", +"httpMethod": "GET", +"id": "accessapproval.organizations.approvalRequests.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the approval request to retrieve. Format: \"{projects|folders|organizations}/{id}/approvalRequests/{approval_request}\"", +"location": "path", +"pattern": "^organizations/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"invalidate": { +"description": "Invalidates an existing ApprovalRequest. Returns the updated ApprovalRequest. NOTE: This does not deny access to the resource if another request has been made and approved. It only invalidates a single approval. Returns FAILED_PRECONDITION if the request exists but is not in an approved state.", +"flatPath": "v1/organizations/{organizationsId}/approvalRequests/{approvalRequestsId}:invalidate", +"httpMethod": "POST", +"id": "accessapproval.organizations.approvalRequests.invalidate", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the ApprovalRequest to invalidate.", +"location": "path", +"pattern": "^organizations/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:invalidate", +"request": { +"$ref": "InvalidateApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists approval requests associated with a project, folder, or organization. Approval requests can be filtered by state (pending, active, dismissed). The order is reverse chronological.", +"flatPath": "v1/organizations/{organizationsId}/approvalRequests", +"httpMethod": "GET", +"id": "accessapproval.organizations.approvalRequests.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter on the type of approval requests to retrieve. Must be one of the following values: * [not set]: Requests that are pending or have active approvals. * ALL: All requests. * PENDING: Only pending requests. * ACTIVE: Only active (i.e. currently approved) requests. * DISMISSED: Only requests that have been dismissed, or requests that are not approved and past expiration. * EXPIRED: Only requests that have been approved, and the approval has expired. * HISTORY: Active, dismissed and expired requests.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Requested page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying the page of results to return.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "The parent resource. This may be \"projects/{project}\", \"folders/{folder}\", or \"organizations/{organization}\".", +"location": "path", +"pattern": "^organizations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/approvalRequests", +"response": { +"$ref": "ListApprovalRequestsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +}, +"projects": { +"methods": { +"deleteAccessApprovalSettings": { +"description": "Deletes the settings associated with a project, folder, or organization. This will have the effect of disabling Access Approval for the project, folder, or organization, but only if all ancestors also have Access Approval disabled. If Access Approval is enabled at a higher level of the hierarchy, then Access Approval will still be enabled at this level as the settings are inherited.", +"flatPath": "v1/projects/{projectsId}/accessApprovalSettings", +"httpMethod": "DELETE", +"id": "accessapproval.projects.deleteAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the AccessApprovalSettings to delete.", +"location": "path", +"pattern": "^projects/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getAccessApprovalSettings": { +"description": "Gets the settings associated with a project, folder, or organization.", +"flatPath": "v1/projects/{projectsId}/accessApprovalSettings", +"httpMethod": "GET", +"id": "accessapproval.projects.getAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the AccessApprovalSettings to retrieve. Format: \"{projects|folders|organizations}/{id}/accessApprovalSettings\"", +"location": "path", +"pattern": "^projects/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AccessApprovalSettings" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getServiceAccount": { +"description": "Retrieves the service account that is used by Access Approval to access KMS keys for signing approved approval requests.", +"flatPath": "v1/projects/{projectsId}/serviceAccount", +"httpMethod": "GET", +"id": "accessapproval.projects.getServiceAccount", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the AccessApprovalServiceAccount to retrieve.", +"location": "path", +"pattern": "^projects/[^/]+/serviceAccount$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AccessApprovalServiceAccount" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"updateAccessApprovalSettings": { +"description": "Updates the settings associated with a project, folder, or organization. Settings to update are determined by the value of field_mask.", +"flatPath": "v1/projects/{projectsId}/accessApprovalSettings", +"httpMethod": "PATCH", +"id": "accessapproval.projects.updateAccessApprovalSettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The resource name of the settings. Format is one of: * \"projects/{project}/accessApprovalSettings\" * \"folders/{folder}/accessApprovalSettings\" * \"organizations/{organization}/accessApprovalSettings\"", +"location": "path", +"pattern": "^projects/[^/]+/accessApprovalSettings$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "The update mask applies to the settings. Only the top level fields of AccessApprovalSettings (notification_emails & enrolled_services) are supported. For each field, if it is included, the currently stored value will be entirely overwritten with the value of the field passed in this request. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask If this field is left unset, only the notification_emails field will be updated.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "AccessApprovalSettings" +}, +"response": { +"$ref": "AccessApprovalSettings" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"approvalRequests": { +"methods": { +"approve": { +"description": "Approves a request and returns the updated ApprovalRequest. Returns NOT_FOUND if the request does not exist. Returns FAILED_PRECONDITION if the request exists but is not in a pending state.", +"flatPath": "v1/projects/{projectsId}/approvalRequests/{approvalRequestsId}:approve", +"httpMethod": "POST", +"id": "accessapproval.projects.approvalRequests.approve", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the approval request to approve.", +"location": "path", +"pattern": "^projects/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:approve", +"request": { +"$ref": "ApproveApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"dismiss": { +"description": "Dismisses a request. Returns the updated ApprovalRequest. NOTE: This does not deny access to the resource if another request has been made and approved. It is equivalent in effect to ignoring the request altogether. Returns NOT_FOUND if the request does not exist. Returns FAILED_PRECONDITION if the request exists but is not in a pending state.", +"flatPath": "v1/projects/{projectsId}/approvalRequests/{approvalRequestsId}:dismiss", +"httpMethod": "POST", +"id": "accessapproval.projects.approvalRequests.dismiss", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the ApprovalRequest to dismiss.", +"location": "path", +"pattern": "^projects/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:dismiss", +"request": { +"$ref": "DismissApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets an approval request. Returns NOT_FOUND if the request does not exist.", +"flatPath": "v1/projects/{projectsId}/approvalRequests/{approvalRequestsId}", +"httpMethod": "GET", +"id": "accessapproval.projects.approvalRequests.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the approval request to retrieve. Format: \"{projects|folders|organizations}/{id}/approvalRequests/{approval_request}\"", +"location": "path", +"pattern": "^projects/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"invalidate": { +"description": "Invalidates an existing ApprovalRequest. Returns the updated ApprovalRequest. NOTE: This does not deny access to the resource if another request has been made and approved. It only invalidates a single approval. Returns FAILED_PRECONDITION if the request exists but is not in an approved state.", +"flatPath": "v1/projects/{projectsId}/approvalRequests/{approvalRequestsId}:invalidate", +"httpMethod": "POST", +"id": "accessapproval.projects.approvalRequests.invalidate", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Name of the ApprovalRequest to invalidate.", +"location": "path", +"pattern": "^projects/[^/]+/approvalRequests/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:invalidate", +"request": { +"$ref": "InvalidateApprovalRequestMessage" +}, +"response": { +"$ref": "ApprovalRequest" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists approval requests associated with a project, folder, or organization. Approval requests can be filtered by state (pending, active, dismissed). The order is reverse chronological.", +"flatPath": "v1/projects/{projectsId}/approvalRequests", +"httpMethod": "GET", +"id": "accessapproval.projects.approvalRequests.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter on the type of approval requests to retrieve. Must be one of the following values: * [not set]: Requests that are pending or have active approvals. * ALL: All requests. * PENDING: Only pending requests. * ACTIVE: Only active (i.e. currently approved) requests. * DISMISSED: Only requests that have been dismissed, or requests that are not approved and past expiration. * EXPIRED: Only requests that have been approved, and the approval has expired. * HISTORY: Active, dismissed and expired requests.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Requested page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying the page of results to return.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "The parent resource. This may be \"projects/{project}\", \"folders/{folder}\", or \"organizations/{organization}\".", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/approvalRequests", +"response": { +"$ref": "ListApprovalRequestsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +}, +"revision": "20240820", +"rootUrl": "https://accessapproval.googleapis.com/", +"schemas": { +"AccessApprovalServiceAccount": { +"description": "Access Approval service account related to a project/folder/organization.", +"id": "AccessApprovalServiceAccount", +"properties": { +"accountEmail": { +"description": "Email address of the service account.", +"type": "string" +}, +"name": { +"description": "The resource name of the Access Approval service account. Format is one of: * \"projects/{project}/serviceAccount\" * \"folders/{folder}/serviceAccount\" * \"organizations/{organization}/serviceAccount\"", +"type": "string" +} +}, +"type": "object" +}, +"AccessApprovalSettings": { +"description": "Settings on a Project/Folder/Organization related to Access Approval.", +"id": "AccessApprovalSettings", +"properties": { +"activeKeyVersion": { +"description": "The asymmetric crypto key version to use for signing approval requests. Empty active_key_version indicates that a Google-managed key should be used for signing. This property will be ignored if set by an ancestor of this resource, and new non-empty values may not be set.", +"type": "string" +}, +"ancestorHasActiveKeyVersion": { +"description": "Output only. This field is read only (not settable via UpdateAccessApprovalSettings method). If the field is true, that indicates that an ancestor of this Project or Folder has set active_key_version (this field will always be unset for the organization since organizations do not have ancestors).", +"readOnly": true, +"type": "boolean" +}, +"enrolledAncestor": { +"description": "Output only. This field is read only (not settable via UpdateAccessApprovalSettings method). If the field is true, that indicates that at least one service is enrolled for Access Approval in one or more ancestors of the Project or Folder (this field will always be unset for the organization since organizations do not have ancestors).", +"readOnly": true, +"type": "boolean" +}, +"enrolledServices": { +"description": "A list of Google Cloud Services for which the given resource has Access Approval enrolled. Access requests for the resource given by name against any of these services contained here will be required to have explicit approval. If name refers to an organization, enrollment can be done for individual services. If name refers to a folder or project, enrollment can only be done on an all or nothing basis. If a cloud_product is repeated in this list, the first entry will be honored and all following entries will be discarded. A maximum of 10 enrolled services will be enforced, to be expanded as the set of supported services is expanded.", +"items": { +"$ref": "EnrolledService" +}, +"type": "array" +}, +"invalidKeyVersion": { +"description": "Output only. This field is read only (not settable via UpdateAccessApprovalSettings method). If the field is true, that indicates that there is some configuration issue with the active_key_version configured at this level in the resource hierarchy (e.g. it doesn't exist or the Access Approval service account doesn't have the correct permissions on it, etc.) This key version is not necessarily the effective key version at this level, as key versions are inherited top-down.", +"readOnly": true, +"type": "boolean" +}, +"name": { +"description": "The resource name of the settings. Format is one of: * \"projects/{project}/accessApprovalSettings\" * \"folders/{folder}/accessApprovalSettings\" * \"organizations/{organization}/accessApprovalSettings\"", +"type": "string" +}, +"notificationEmails": { +"description": "A list of email addresses to which notifications relating to approval requests should be sent. Notifications relating to a resource will be sent to all emails in the settings of ancestor resources of that resource. A maximum of 50 email addresses are allowed.", +"items": { +"type": "string" +}, +"type": "array" +}, +"notificationPubsubTopic": { +"description": "Optional. A pubsub topic to which notifications relating to approval requests should be sent.", +"type": "string" +}, +"preferNoBroadApprovalRequests": { +"description": "This preference is communicated to Google personnel when sending an approval request but can be overridden if necessary.", +"type": "boolean" +}, +"preferredRequestExpirationDays": { +"description": "This preference is shared with Google personnel, but can be overridden if said personnel deems necessary. The approver ultimately can set the expiration at approval time.", +"format": "int32", +"type": "integer" +}, +"requestScopeMaxWidthPreference": { +"description": "Optional. A setting to indicate the maximum width of an Access Approval request.", +"enum": [ +"REQUEST_SCOPE_MAX_WIDTH_PREFERENCE_UNSPECIFIED", +"ORGANIZATION", +"FOLDER", +"PROJECT" +], +"enumDescriptions": [ +"Default value for proto, shouldn't be used.", +"This is the widest scope possible. It means the customer has no scope restriction when it comes to Access Approval requests.", +"Customer allows the scope of Access Approval requests as broad as the Folder level.", +"Customer allows the scope of Access Approval requests as broad as the Project level." +], +"type": "string" +}, +"requireCustomerVisibleJustification": { +"description": "Optional. A setting to require approval request justifications to be customer visible.", +"type": "boolean" +} +}, +"type": "object" +}, +"AccessLocations": { +"description": "Home office and physical location of the principal.", +"id": "AccessLocations", +"properties": { +"principalOfficeCountry": { +"description": "The \"home office\" location of the principal. A two-letter country code (ISO 3166-1 alpha-2), such as \"US\", \"DE\" or \"GB\" or a region code. In some limited situations Google systems may refer refer to a region code instead of a country code. Possible Region Codes: * ASI: Asia * EUR: Europe * OCE: Oceania * AFR: Africa * NAM: North America * SAM: South America * ANT: Antarctica * ANY: Any location", +"type": "string" +}, +"principalPhysicalLocationCountry": { +"description": "Physical location of the principal at the time of the access. A two-letter country code (ISO 3166-1 alpha-2), such as \"US\", \"DE\" or \"GB\" or a region code. In some limited situations Google systems may refer refer to a region code instead of a country code. Possible Region Codes: * ASI: Asia * EUR: Europe * OCE: Oceania * AFR: Africa * NAM: North America * SAM: South America * ANT: Antarctica * ANY: Any location", +"type": "string" +} +}, +"type": "object" +}, +"AccessReason": { +"id": "AccessReason", +"properties": { +"detail": { +"description": "More detail about certain reason types. See comments for each type above.", +"type": "string" +}, +"type": { +"description": "Type of access justification.", +"enum": [ +"TYPE_UNSPECIFIED", +"CUSTOMER_INITIATED_SUPPORT", +"GOOGLE_INITIATED_SERVICE", +"GOOGLE_INITIATED_REVIEW", +"THIRD_PARTY_DATA_REQUEST", +"GOOGLE_RESPONSE_TO_PRODUCTION_ALERT", +"CLOUD_INITIATED_ACCESS" +], +"enumDescriptions": [ +"Default value for proto, shouldn't be used.", +"Customer made a request or raised an issue that required the principal to access customer data. `detail` is of the form (\"#####\" is the issue ID): * \"Feedback Report: #####\" * \"Case Number: #####\" * \"Case ID: #####\" * \"E-PIN Reference: #####\" * \"Google-#####\" * \"T-#####\"", +"The principal accessed customer data in order to diagnose or resolve a suspected issue in services. Often this access is used to confirm that customers are not affected by a suspected service issue or to remediate a reversible system issue.", +"Google initiated service for security, fraud, abuse, or compliance purposes.", +"The principal was compelled to access customer data in order to respond to a legal third party data request or process, including legal processes from customers themselves.", +"The principal accessed customer data in order to diagnose or resolve a suspected issue in services or a known outage.", +"Similar to 'GOOGLE_INITIATED_SERVICE' or 'GOOGLE_INITIATED_REVIEW', but with universe agnostic naming. The principal accessed customer data in order to diagnose or resolve a suspected issue in services or a known outage, or for security, fraud, abuse, or compliance review purposes." +], +"type": "string" +} +}, +"type": "object" +}, +"ApprovalRequest": { +"description": "A request for the customer to approve access to a resource.", +"id": "ApprovalRequest", +"properties": { +"approve": { +"$ref": "ApproveDecision", +"description": "Access was approved." +}, +"dismiss": { +"$ref": "DismissDecision", +"description": "The request was dismissed." +}, +"name": { +"description": "The resource name of the request. Format is \"{projects|folders|organizations}/{id}/approvalRequests/{approval_request}\".", +"type": "string" +}, +"requestTime": { +"description": "The time at which approval was requested.", +"format": "google-datetime", +"type": "string" +}, +"requestedAugmentedInfo": { +"$ref": "AugmentedInfo", +"description": "This field contains the augmented information of the request." +}, +"requestedDuration": { +"description": "The requested access duration.", +"format": "google-duration", +"type": "string" +}, +"requestedExpiration": { +"description": "The original requested expiration for the approval. Calculated by adding the requested_duration to the request_time.", +"format": "google-datetime", +"type": "string" +}, +"requestedLocations": { +"$ref": "AccessLocations", +"description": "The locations for which approval is being requested." +}, +"requestedReason": { +"$ref": "AccessReason", +"description": "The justification for which approval is being requested." +}, +"requestedResourceName": { +"description": "The resource for which approval is being requested. The format of the resource name is defined at https://cloud.google.com/apis/design/resource_names. The resource name here may either be a \"full\" resource name (e.g. \"//library.googleapis.com/shelves/shelf1/books/book2\") or a \"relative\" resource name (e.g. \"shelves/shelf1/books/book2\") as described in the resource name specification.", +"type": "string" +}, +"requestedResourceProperties": { +"$ref": "ResourceProperties", +"description": "Properties related to the resource represented by requested_resource_name." +} +}, +"type": "object" +}, +"ApproveApprovalRequestMessage": { +"description": "Request to approve an ApprovalRequest.", +"id": "ApproveApprovalRequestMessage", +"properties": { +"expireTime": { +"description": "The expiration time of this approval.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"ApproveDecision": { +"description": "A decision that has been made to approve access to a resource.", +"id": "ApproveDecision", +"properties": { +"approveTime": { +"description": "The time at which approval was granted.", +"format": "google-datetime", +"type": "string" +}, +"autoApproved": { +"description": "True when the request has been auto-approved.", +"type": "boolean" +}, +"expireTime": { +"description": "The time at which the approval expires.", +"format": "google-datetime", +"type": "string" +}, +"invalidateTime": { +"description": "If set, denotes the timestamp at which the approval is invalidated.", +"format": "google-datetime", +"type": "string" +}, +"signatureInfo": { +"$ref": "SignatureInfo", +"description": "The signature for the ApprovalRequest and details on how it was signed." +} +}, +"type": "object" +}, +"AugmentedInfo": { +"description": "This field contains the augmented information of the request.", +"id": "AugmentedInfo", +"properties": { +"command": { +"description": "For command-line tools, the full command-line exactly as entered by the actor without adding any additional characters (such as quotation marks).", +"type": "string" +} +}, +"type": "object" +}, +"DismissApprovalRequestMessage": { +"description": "Request to dismiss an approval request.", +"id": "DismissApprovalRequestMessage", +"properties": {}, +"type": "object" +}, +"DismissDecision": { +"description": "A decision that has been made to dismiss an approval request.", +"id": "DismissDecision", +"properties": { +"dismissTime": { +"description": "The time at which the approval request was dismissed.", +"format": "google-datetime", +"type": "string" +}, +"implicit": { +"description": "This field will be true if the ApprovalRequest was implicitly dismissed due to inaction by the access approval approvers (the request is not acted on by the approvers before the exiration time).", +"type": "boolean" +} +}, +"type": "object" +}, +"Empty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "Empty", +"properties": {}, +"type": "object" +}, +"EnrolledService": { +"description": "Represents the enrollment of a cloud resource into a specific service.", +"id": "EnrolledService", +"properties": { +"cloudProduct": { +"description": "The product for which Access Approval will be enrolled. Allowed values are listed below (case-sensitive): * all * GA * App Engine * Artifact Registry * BigQuery * Certificate Authority Service * Cloud Bigtable * Cloud Key Management Service * Compute Engine * Cloud Composer * Cloud Dataflow * Cloud Dataproc * Cloud DLP * Cloud EKM * Cloud Firestore * Cloud HSM * Cloud Identity and Access Management * Cloud Logging * Cloud NAT * Cloud Pub/Sub * Cloud Spanner * Cloud SQL * Cloud Storage * Eventarc * Google Kubernetes Engine * Organization Policy Serivice * Persistent Disk * Resource Manager * Secret Manager * Speaker ID Note: These values are supported as input for legacy purposes, but will not be returned from the API. * all * ga-only * appengine.googleapis.com * artifactregistry.googleapis.com * bigquery.googleapis.com * bigtable.googleapis.com * container.googleapis.com * cloudkms.googleapis.com * cloudresourcemanager.googleapis.com * cloudsql.googleapis.com * compute.googleapis.com * dataflow.googleapis.com * dataproc.googleapis.com * dlp.googleapis.com * iam.googleapis.com * logging.googleapis.com * orgpolicy.googleapis.com * pubsub.googleapis.com * spanner.googleapis.com * secretmanager.googleapis.com * speakerid.googleapis.com * storage.googleapis.com Calls to UpdateAccessApprovalSettings using 'all' or any of the XXX.googleapis.com will be translated to the associated product name ('all', 'App Engine', etc.). Note: 'all' will enroll the resource in all products supported at both 'GA' and 'Preview' levels. More information about levels of support is available at https://cloud.google.com/access-approval/docs/supported-services", +"type": "string" +}, +"enrollmentLevel": { +"description": "The enrollment level of the service.", +"enum": [ +"ENROLLMENT_LEVEL_UNSPECIFIED", +"BLOCK_ALL" +], +"enumDescriptions": [ +"Default value for proto, shouldn't be used.", +"Service is enrolled in Access Approval for all requests" +], +"type": "string" +} +}, +"type": "object" +}, +"InvalidateApprovalRequestMessage": { +"description": "Request to invalidate an existing approval.", +"id": "InvalidateApprovalRequestMessage", +"properties": {}, +"type": "object" +}, +"ListApprovalRequestsResponse": { +"description": "Response to listing of ApprovalRequest objects.", +"id": "ListApprovalRequestsResponse", +"properties": { +"approvalRequests": { +"description": "Approval request details.", +"items": { +"$ref": "ApprovalRequest" +}, +"type": "array" +}, +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more.", +"type": "string" +} +}, +"type": "object" +}, +"ResourceProperties": { +"description": "The properties associated with the resource of the request.", +"id": "ResourceProperties", +"properties": { +"excludesDescendants": { +"description": "Whether an approval will exclude the descendants of the resource being requested.", +"type": "boolean" +} +}, +"type": "object" +}, +"SignatureInfo": { +"description": "Information about the digital signature of the resource.", +"id": "SignatureInfo", +"properties": { +"customerKmsKeyVersion": { +"description": "The resource name of the customer CryptoKeyVersion used for signing.", +"type": "string" +}, +"googleKeyAlgorithm": { +"description": "The hashing algorithm used for signature verification. It will only be present in the case of Google managed keys.", +"enum": [ +"CRYPTO_KEY_VERSION_ALGORITHM_UNSPECIFIED", +"GOOGLE_SYMMETRIC_ENCRYPTION", +"AES_128_GCM", +"AES_256_GCM", +"AES_128_CBC", +"AES_256_CBC", +"AES_128_CTR", +"AES_256_CTR", +"RSA_SIGN_PSS_2048_SHA256", +"RSA_SIGN_PSS_3072_SHA256", +"RSA_SIGN_PSS_4096_SHA256", +"RSA_SIGN_PSS_4096_SHA512", +"RSA_SIGN_PKCS1_2048_SHA256", +"RSA_SIGN_PKCS1_3072_SHA256", +"RSA_SIGN_PKCS1_4096_SHA256", +"RSA_SIGN_PKCS1_4096_SHA512", +"RSA_SIGN_RAW_PKCS1_2048", +"RSA_SIGN_RAW_PKCS1_3072", +"RSA_SIGN_RAW_PKCS1_4096", +"RSA_DECRYPT_OAEP_2048_SHA256", +"RSA_DECRYPT_OAEP_3072_SHA256", +"RSA_DECRYPT_OAEP_4096_SHA256", +"RSA_DECRYPT_OAEP_4096_SHA512", +"RSA_DECRYPT_OAEP_2048_SHA1", +"RSA_DECRYPT_OAEP_3072_SHA1", +"RSA_DECRYPT_OAEP_4096_SHA1", +"EC_SIGN_P256_SHA256", +"EC_SIGN_P384_SHA384", +"EC_SIGN_SECP256K1_SHA256", +"EC_SIGN_ED25519", +"HMAC_SHA256", +"HMAC_SHA1", +"HMAC_SHA384", +"HMAC_SHA512", +"HMAC_SHA224", +"EXTERNAL_SYMMETRIC_ENCRYPTION" +], +"enumDescriptions": [ +"Not specified.", +"Creates symmetric encryption keys.", +"AES-GCM (Galois Counter Mode) using 128-bit keys.", +"AES-GCM (Galois Counter Mode) using 256-bit keys.", +"AES-CBC (Cipher Block Chaining Mode) using 128-bit keys.", +"AES-CBC (Cipher Block Chaining Mode) using 256-bit keys.", +"AES-CTR (Counter Mode) using 128-bit keys.", +"AES-CTR (Counter Mode) using 256-bit keys.", +"RSASSA-PSS 2048 bit key with a SHA256 digest.", +"RSASSA-PSS 3072 bit key with a SHA256 digest.", +"RSASSA-PSS 4096 bit key with a SHA256 digest.", +"RSASSA-PSS 4096 bit key with a SHA512 digest.", +"RSASSA-PKCS1-v1_5 with a 2048 bit key and a SHA256 digest.", +"RSASSA-PKCS1-v1_5 with a 3072 bit key and a SHA256 digest.", +"RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA256 digest.", +"RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA512 digest.", +"RSASSA-PKCS1-v1_5 signing without encoding, with a 2048 bit key.", +"RSASSA-PKCS1-v1_5 signing without encoding, with a 3072 bit key.", +"RSASSA-PKCS1-v1_5 signing without encoding, with a 4096 bit key.", +"RSAES-OAEP 2048 bit key with a SHA256 digest.", +"RSAES-OAEP 3072 bit key with a SHA256 digest.", +"RSAES-OAEP 4096 bit key with a SHA256 digest.", +"RSAES-OAEP 4096 bit key with a SHA512 digest.", +"RSAES-OAEP 2048 bit key with a SHA1 digest.", +"RSAES-OAEP 3072 bit key with a SHA1 digest.", +"RSAES-OAEP 4096 bit key with a SHA1 digest.", +"ECDSA on the NIST P-256 curve with a SHA256 digest. Other hash functions can also be used: https://cloud.google.com/kms/docs/create-validate-signatures#ecdsa_support_for_other_hash_algorithms", +"ECDSA on the NIST P-384 curve with a SHA384 digest. Other hash functions can also be used: https://cloud.google.com/kms/docs/create-validate-signatures#ecdsa_support_for_other_hash_algorithms", +"ECDSA on the non-NIST secp256k1 curve. This curve is only supported for HSM protection level. Other hash functions can also be used: https://cloud.google.com/kms/docs/create-validate-signatures#ecdsa_support_for_other_hash_algorithms", +"EdDSA on the Curve25519 in pure mode (taking data as input).", +"HMAC-SHA256 signing with a 256 bit key.", +"HMAC-SHA1 signing with a 160 bit key.", +"HMAC-SHA384 signing with a 384 bit key.", +"HMAC-SHA512 signing with a 512 bit key.", +"HMAC-SHA224 signing with a 224 bit key.", +"Algorithm representing symmetric encryption by an external key manager." +], +"type": "string" +}, +"googlePublicKeyPem": { +"description": "The public key for the Google default signing, encoded in PEM format. The signature was created using a private key which may be verified using this public key.", +"type": "string" +}, +"serializedApprovalRequest": { +"description": "The ApprovalRequest that is serialized without the SignatureInfo message field. This data is used with the hashing algorithm to generate the digital signature, and it can be used for signature verification.", +"format": "byte", +"type": "string" +}, +"signature": { +"description": "The digital signature.", +"format": "byte", +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Access Approval API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/chromeuxreport.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/chromeuxreport.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..649128e3c7b8a18e3d38879da158c9e718905c11 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/chromeuxreport.v1.json @@ -0,0 +1,550 @@ +{ +"basePath": "", +"baseUrl": "https://chromeuxreport.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Chrome UX Report", +"description": "The Chrome UX Report API lets you view real user experience data for millions of websites. ", +"discoveryVersion": "v1", +"documentationLink": "https://developers.google.com/web/tools/chrome-user-experience-report/api/reference", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "chromeuxreport:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://chromeuxreport.mtls.googleapis.com/", +"name": "chromeuxreport", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"records": { +"methods": { +"queryHistoryRecord": { +"description": "Queries the Chrome User Experience Report for a timeseries `history record` for a given site. Returns a `history record` that contains one or more `metric timeseries` corresponding to performance data about the requested site.", +"flatPath": "v1/records:queryHistoryRecord", +"httpMethod": "POST", +"id": "chromeuxreport.records.queryHistoryRecord", +"parameterOrder": [], +"parameters": {}, +"path": "v1/records:queryHistoryRecord", +"request": { +"$ref": "QueryHistoryRequest" +}, +"response": { +"$ref": "QueryHistoryResponse" +} +}, +"queryRecord": { +"description": "Queries the Chrome User Experience for a single `record` for a given site. Returns a `record` that contains one or more `metrics` corresponding to performance data about the requested site.", +"flatPath": "v1/records:queryRecord", +"httpMethod": "POST", +"id": "chromeuxreport.records.queryRecord", +"parameterOrder": [], +"parameters": {}, +"path": "v1/records:queryRecord", +"request": { +"$ref": "QueryRequest" +}, +"response": { +"$ref": "QueryResponse" +} +} +} +} +}, +"revision": "20240916", +"rootUrl": "https://chromeuxreport.googleapis.com/", +"schemas": { +"Bin": { +"description": "A bin is a discrete portion of data spanning from start to end, or if no end is given, then from start to +inf. A bin's start and end values are given in the value type of the metric it represents. For example, \"first contentful paint\" is measured in milliseconds and exposed as ints, therefore its metric bins will use int32s for its start and end types. However, \"cumulative layout shift\" is measured in unitless decimals and is exposed as a decimal encoded as a string, therefore its metric bins will use strings for its value type.", +"id": "Bin", +"properties": { +"density": { +"description": "The proportion of users that experienced this bin's value for the given metric.", +"type": "any" +}, +"end": { +"description": "End is the end of the data bin. If end is not populated, then the bin has no end and is valid from start to +inf.", +"type": "any" +}, +"start": { +"description": "Start is the beginning of the data bin.", +"type": "any" +} +}, +"type": "object" +}, +"CollectionPeriod": { +"description": "The collection period is a date range which includes the `first` and `last` day.", +"id": "CollectionPeriod", +"properties": { +"firstDate": { +"$ref": "Date", +"description": "The first day in the collection period, inclusive." +}, +"lastDate": { +"$ref": "Date", +"description": "The last day in the collection period, inclusive." +} +}, +"type": "object" +}, +"Date": { +"description": "Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp", +"id": "Date", +"properties": { +"day": { +"description": "Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.", +"format": "int32", +"type": "integer" +}, +"month": { +"description": "Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.", +"format": "int32", +"type": "integer" +}, +"year": { +"description": "Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"FractionTimeseries": { +"description": "For enum metrics, provides fraction timeseries which add up to approximately 1.0 per entry (k-th element into the repeated fractions field for any k <= len) across fraction_timeseries.", +"id": "FractionTimeseries", +"properties": { +"fractions": { +"description": "Values between 0.0 and 1.0 (inclusive) and NaN.", +"items": { +"format": "double", +"type": "number" +}, +"type": "array" +} +}, +"type": "object" +}, +"HistoryKey": { +"description": "Key defines all the dimensions that identify this record as unique.", +"id": "HistoryKey", +"properties": { +"formFactor": { +"description": "The form factor is the device class that all users used to access the site for this record. If the form factor is unspecified, then aggregated data over all form factors will be returned.", +"enum": [ +"ALL_FORM_FACTORS", +"PHONE", +"DESKTOP", +"TABLET" +], +"enumDescriptions": [ +"The default value, representing all device classes.", +"The device class representing a \"mobile\"/\"phone\" sized client.", +"The device class representing a \"desktop\"/\"laptop\" type full size client.", +"The device class representing a \"tablet\" type client." +], +"type": "string" +}, +"origin": { +"description": "Origin specifies the origin that this record is for. Note: When specifying an origin, data for loads under this origin over all pages are aggregated into origin level user experience data.", +"type": "string" +}, +"url": { +"description": "Url specifies a specific url that this record is for. This url should be normalized, following the normalization actions taken in the request to increase the chances of successful lookup. Note: When specifying a \"url\" only data for that specific url will be aggregated.", +"type": "string" +} +}, +"type": "object" +}, +"HistoryRecord": { +"description": "HistoryRecord is a timeseries of Chrome UX Report data. It contains user experience statistics for a single url pattern and a set of dimensions.", +"id": "HistoryRecord", +"properties": { +"collectionPeriods": { +"description": "The collection periods indicate when each of the data points reflected in the time series data in metrics was collected. Note that all the time series share the same collection periods, and it is enforced in the CrUX pipeline that every time series has the same number of data points.", +"items": { +"$ref": "CollectionPeriod" +}, +"type": "array" +}, +"key": { +"$ref": "HistoryKey", +"description": "Key defines all of the unique querying parameters needed to look up a user experience history record." +}, +"metrics": { +"additionalProperties": { +"$ref": "MetricTimeseries" +}, +"description": "Metrics is the map of user experience time series data available for the record defined in the key field. Metrics are keyed on the metric name. Allowed key values: [\"first_contentful_paint\", \"first_input_delay\", \"largest_contentful_paint\", \"cumulative_layout_shift\", \"experimental_time_to_first_byte\", \"experimental_interaction_to_next_paint\"]", +"type": "object" +} +}, +"type": "object" +}, +"Key": { +"description": "Key defines all the dimensions that identify this record as unique.", +"id": "Key", +"properties": { +"effectiveConnectionType": { +"description": "The effective connection type is the general connection class that all users experienced for this record. This field uses the values [\"offline\", \"slow-2G\", \"2G\", \"3G\", \"4G\"] as specified in: https://wicg.github.io/netinfo/#effective-connection-types If the effective connection type is unspecified, then aggregated data over all effective connection types will be returned.", +"type": "string" +}, +"formFactor": { +"description": "The form factor is the device class that all users used to access the site for this record. If the form factor is unspecified, then aggregated data over all form factors will be returned.", +"enum": [ +"ALL_FORM_FACTORS", +"PHONE", +"DESKTOP", +"TABLET" +], +"enumDescriptions": [ +"The default value, representing all device classes.", +"The device class representing a \"mobile\"/\"phone\" sized client.", +"The device class representing a \"desktop\"/\"laptop\" type full size client.", +"The device class representing a \"tablet\" type client." +], +"type": "string" +}, +"origin": { +"description": "Origin specifies the origin that this record is for. Note: When specifying an origin, data for loads under this origin over all pages are aggregated into origin level user experience data.", +"type": "string" +}, +"url": { +"description": "Url specifies a specific url that this record is for. Note: When specifying a \"url\" only data for that specific url will be aggregated.", +"type": "string" +} +}, +"type": "object" +}, +"Metric": { +"description": "A `metric` is a set of user experience data for a single web performance metric, like \"first contentful paint\". It contains a summary histogram of real world Chrome usage as a series of `bins`.", +"id": "Metric", +"properties": { +"fractions": { +"additionalProperties": { +"format": "double", +"type": "number" +}, +"description": "For enum metrics, provides fractions which add up to approximately 1.0.", +"type": "object" +}, +"histogram": { +"description": "The histogram of user experiences for a metric. The histogram will have at least one bin and the densities of all bins will add up to ~1.", +"items": { +"$ref": "Bin" +}, +"type": "array" +}, +"percentiles": { +"$ref": "Percentiles", +"description": "Commonly useful percentiles of the Metric. The value type for the percentiles will be the same as the value types given for the Histogram bins." +} +}, +"type": "object" +}, +"MetricTimeseries": { +"description": "A `metric timeseries` is a set of user experience data for a single web performance metric, like \"first contentful paint\". It contains a summary histogram of real world Chrome usage as a series of `bins`, where each bin has density values for a particular time period.", +"id": "MetricTimeseries", +"properties": { +"fractionTimeseries": { +"additionalProperties": { +"$ref": "FractionTimeseries" +}, +"description": "Mapping from labels to timeseries of fractions attributed to this label.", +"type": "object" +}, +"histogramTimeseries": { +"description": "The histogram of user experiences for a metric. The histogram will have at least one bin and the densities of all bins will add up to ~1, for each timeseries entry.", +"items": { +"$ref": "TimeseriesBin" +}, +"type": "array" +}, +"percentilesTimeseries": { +"$ref": "TimeseriesPercentiles", +"description": "Commonly useful percentiles of the Metric. The value type for the percentiles will be the same as the value types given for the Histogram bins." +} +}, +"type": "object" +}, +"Percentiles": { +"description": "Percentiles contains synthetic values of a metric at a given statistical percentile. These are used for estimating a metric's value as experienced by a percentage of users out of the total number of users.", +"id": "Percentiles", +"properties": { +"p75": { +"description": "75% of users experienced the given metric at or below this value.", +"type": "any" +} +}, +"type": "object" +}, +"QueryHistoryRequest": { +"description": "Request payload sent by a physical web client. This request includes all necessary context to load a particular user experience history record.", +"id": "QueryHistoryRequest", +"properties": { +"formFactor": { +"description": "The form factor is a query dimension that specifies the device class that the record's data should belong to. Note: If no form factor is specified, then a special record with aggregated data over all form factors will be returned.", +"enum": [ +"ALL_FORM_FACTORS", +"PHONE", +"DESKTOP", +"TABLET" +], +"enumDescriptions": [ +"The default value, representing all device classes.", +"The device class representing a \"mobile\"/\"phone\" sized client.", +"The device class representing a \"desktop\"/\"laptop\" type full size client.", +"The device class representing a \"tablet\" type client." +], +"type": "string" +}, +"metrics": { +"description": "The metrics that should be included in the response. If none are specified then any metrics found will be returned. Allowed values: [\"first_contentful_paint\", \"first_input_delay\", \"largest_contentful_paint\", \"cumulative_layout_shift\", \"experimental_time_to_first_byte\", \"experimental_interaction_to_next_paint\"]", +"items": { +"type": "string" +}, +"type": "array" +}, +"origin": { +"description": "The url pattern \"origin\" refers to a url pattern that is the origin of a website. Examples: \"https://example.com\", \"https://cloud.google.com\"", +"type": "string" +}, +"url": { +"description": "The url pattern \"url\" refers to a url pattern that is any arbitrary url. Examples: \"https://example.com/\", \"https://cloud.google.com/why-google-cloud/\"", +"type": "string" +} +}, +"type": "object" +}, +"QueryHistoryResponse": { +"description": "Response payload sent back to a physical web client. This response contains the record found based on the identiers present in a `QueryHistoryRequest`. The returned response will have a history record, and sometimes details on normalization actions taken on the request that were necessary to make the request successful.", +"id": "QueryHistoryResponse", +"properties": { +"record": { +"$ref": "HistoryRecord", +"description": "The record that was found." +}, +"urlNormalizationDetails": { +"$ref": "UrlNormalization", +"description": "These are details about automated normalization actions that were taken in order to make the requested `url_pattern` valid." +} +}, +"type": "object" +}, +"QueryRequest": { +"description": "Request payload sent by a physical web client. This request includes all necessary context to load a particular user experience record.", +"id": "QueryRequest", +"properties": { +"effectiveConnectionType": { +"description": "The effective connection type is a query dimension that specifies the effective network class that the record's data should belong to. This field uses the values [\"offline\", \"slow-2G\", \"2G\", \"3G\", \"4G\"] as specified in: https://wicg.github.io/netinfo/#effective-connection-types Note: If no effective connection type is specified, then a special record with aggregated data over all effective connection types will be returned.", +"type": "string" +}, +"formFactor": { +"description": "The form factor is a query dimension that specifies the device class that the record's data should belong to. Note: If no form factor is specified, then a special record with aggregated data over all form factors will be returned.", +"enum": [ +"ALL_FORM_FACTORS", +"PHONE", +"DESKTOP", +"TABLET" +], +"enumDescriptions": [ +"The default value, representing all device classes.", +"The device class representing a \"mobile\"/\"phone\" sized client.", +"The device class representing a \"desktop\"/\"laptop\" type full size client.", +"The device class representing a \"tablet\" type client." +], +"type": "string" +}, +"metrics": { +"description": "The metrics that should be included in the response. If none are specified then any metrics found will be returned. Allowed values: [\"first_contentful_paint\", \"first_input_delay\", \"largest_contentful_paint\", \"cumulative_layout_shift\", \"experimental_time_to_first_byte\", \"experimental_interaction_to_next_paint\"]", +"items": { +"type": "string" +}, +"type": "array" +}, +"origin": { +"description": "The url pattern \"origin\" refers to a url pattern that is the origin of a website. Examples: \"https://example.com\", \"https://cloud.google.com\"", +"type": "string" +}, +"url": { +"description": "The url pattern \"url\" refers to a url pattern that is any arbitrary url. Examples: \"https://example.com/\", \"https://cloud.google.com/why-google-cloud/\"", +"type": "string" +} +}, +"type": "object" +}, +"QueryResponse": { +"description": "Response payload sent back to a physical web client. This response contains the record found based on the identiers present in a `QueryRequest`. The returned response will have a record, and sometimes details on normalization actions taken on the request that were necessary to make the request successful.", +"id": "QueryResponse", +"properties": { +"record": { +"$ref": "Record", +"description": "The record that was found." +}, +"urlNormalizationDetails": { +"$ref": "UrlNormalization", +"description": "These are details about automated normalization actions that were taken in order to make the requested `url_pattern` valid." +} +}, +"type": "object" +}, +"Record": { +"description": "Record is a single Chrome UX report data record. It contains use experience statistics for a single url pattern and set of dimensions.", +"id": "Record", +"properties": { +"collectionPeriod": { +"$ref": "CollectionPeriod", +"description": "The collection period indicates when the data reflected in this record was collected." +}, +"key": { +"$ref": "Key", +"description": "Key defines all of the unique querying parameters needed to look up a user experience record." +}, +"metrics": { +"additionalProperties": { +"$ref": "Metric" +}, +"description": "Metrics is the map of user experience data available for the record defined in the key field. Metrics are keyed on the metric name. Allowed key values: [\"first_contentful_paint\", \"first_input_delay\", \"largest_contentful_paint\", \"cumulative_layout_shift\", \"experimental_time_to_first_byte\", \"experimental_interaction_to_next_paint\"]", +"type": "object" +} +}, +"type": "object" +}, +"TimeseriesBin": { +"description": "A bin is a discrete portion of data spanning from start to end, or if no end is given, then from start to +inf. A bin's start and end values are given in the value type of the metric it represents. For example, \"first contentful paint\" is measured in milliseconds and exposed as ints, therefore its metric bins will use int32s for its start and end types. However, \"cumulative layout shift\" is measured in unitless decimals and is exposed as a decimal encoded as a string, therefore its metric bins will use strings for its value type.", +"id": "TimeseriesBin", +"properties": { +"densities": { +"description": "The proportion of users that experienced this bin's value for the given metric in a given collection period; the index for each of these entries corresponds to an entry in the CollectionPeriods field in the HistoryRecord message, which describes when the density was observed in the field. Thus, the length of this list of densities is equal to the length of the CollectionPeriods field in the HistoryRecord message.", +"items": { +"format": "double", +"type": "number" +}, +"type": "array" +}, +"end": { +"description": "End is the end of the data bin. If end is not populated, then the bin has no end and is valid from start to +inf.", +"type": "any" +}, +"start": { +"description": "Start is the beginning of the data bin.", +"type": "any" +} +}, +"type": "object" +}, +"TimeseriesPercentiles": { +"description": "Percentiles contains synthetic values of a metric at a given statistical percentile. These are used for estimating a metric's value as experienced by a percentage of users out of the total number of users.", +"id": "TimeseriesPercentiles", +"properties": { +"p75s": { +"description": "75% of users experienced the given metric at or below this value. The length of this list of densities is equal to the length of the CollectionPeriods field in the HistoryRecord message, which describes when the density was observed in the field.", +"items": { +"type": "any" +}, +"type": "array" +} +}, +"type": "object" +}, +"UrlNormalization": { +"description": "Object representing the normalization actions taken to normalize a url to achieve a higher chance of successful lookup. These are simple automated changes that are taken when looking up the provided `url_patten` would be known to fail. Complex actions like following redirects are not handled.", +"id": "UrlNormalization", +"properties": { +"normalizedUrl": { +"description": "The URL after any normalization actions. This is a valid user experience URL that could reasonably be looked up.", +"type": "string" +}, +"originalUrl": { +"description": "The original requested URL prior to any normalization actions.", +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Chrome UX Report API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/managedidentities.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/managedidentities.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..d1531864cf0944f365db91497d992405877ed74d --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/managedidentities.v1.json @@ -0,0 +1,3235 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +} +} +} +}, +"basePath": "", +"baseUrl": "https://managedidentities.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Managed Service for Microsoft Active Directory Consumer API", +"description": "The Managed Service for Microsoft Active Directory API is used for managing a highly available, hardened service running Microsoft Active Directory (AD).", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/managed-microsoft-ad/", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "managedidentities:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://managedidentities.mtls.googleapis.com/", +"name": "managedidentities", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"projects": { +"resources": { +"locations": { +"methods": { +"get": { +"description": "Gets information about a location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Resource name for the location.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Location" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists information about the supported locations for this service.", +"flatPath": "v1/projects/{projectsId}/locations", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "A filter to narrow down results to a preferred subset. The filtering language accepts strings like `\"displayName=tokyo\"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160).", +"location": "query", +"type": "string" +}, +"name": { +"description": "The resource that owns the locations collection, if applicable.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return. If not set, the service selects a default.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}/locations", +"response": { +"$ref": "ListLocationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"global": { +"resources": { +"domains": { +"methods": { +"attachTrust": { +"description": "Adds an AD trust to a domain.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:attachTrust", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.attachTrust", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource domain name, project name and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:attachTrust", +"request": { +"$ref": "AttachTrustRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"checkMigrationPermission": { +"description": "CheckMigrationPermission API gets the current state of DomainMigration", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:checkMigrationPermission", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.checkMigrationPermission", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+domain}:checkMigrationPermission", +"request": { +"$ref": "CheckMigrationPermissionRequest" +}, +"response": { +"$ref": "CheckMigrationPermissionResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"create": { +"description": "Creates a Microsoft AD domain.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"domainName": { +"description": "Required. The fully qualified domain name. e.g. mydomain.myorganization.com, with the following restrictions: * Must contain only lowercase letters, numbers, periods and hyphens. * Must start with a letter. * Must contain between 2-64 characters. * Must end with a number or a letter. * Must not start with period. * First segment length (mydomain for example above) shouldn't exceed 15 chars. * The last segment cannot be fully numeric. * Must be unique within the customer project.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource project name and location using the form: `projects/{project_id}/locations/global`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/domains", +"request": { +"$ref": "Domain" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a domain.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}", +"httpMethod": "DELETE", +"id": "managedidentities.projects.locations.global.domains.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"detachTrust": { +"description": "Removes an AD trust.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:detachTrust", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.detachTrust", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource domain name, project name, and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:detachTrust", +"request": { +"$ref": "DetachTrustRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"disableMigration": { +"description": "Disable Domain Migration", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:disableMigration", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.disableMigration", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+domain}:disableMigration", +"request": { +"$ref": "DisableMigrationRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"domainJoinMachine": { +"description": "DomainJoinMachine API joins a Compute Engine VM to the domain", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:domainJoinMachine", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.domainJoinMachine", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: projects/{project_id}/locations/global/domains/{domain_name}", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+domain}:domainJoinMachine", +"request": { +"$ref": "DomainJoinMachineRequest" +}, +"response": { +"$ref": "DomainJoinMachineResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"enableMigration": { +"description": "Enable Domain Migration", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:enableMigration", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.enableMigration", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+domain}:enableMigration", +"request": { +"$ref": "EnableMigrationRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"extendSchema": { +"description": "Extend Schema for Domain", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:extendSchema", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.extendSchema", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+domain}:extendSchema", +"request": { +"$ref": "ExtendSchemaRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets information about a domain.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Domain" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:getIamPolicy", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getLdapssettings": { +"description": "Gets the domain ldaps settings.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/ldapssettings", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.getLdapssettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}/ldapssettings", +"response": { +"$ref": "LDAPSSettings" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists domains in a project.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. A filter specifying constraints of a list operation. For example, `Domain.fqdn=\"mydomain.myorginization\"`.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Specifies the ordering of results. See [Sorting order](https://cloud.google.com/apis/design/design_patterns#sorting_order) for more information.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of items to return. If not specified, a default value of 1000 will be used. Regardless of the page_size value, the response may include a partial list. Callers should rely on a response's next_page_token to determine if there are additional results to list.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The `next_page_token` value returned from a previous ListDomainsRequest request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource name of the domain location using the form: `projects/{project_id}/locations/global`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/domains", +"response": { +"$ref": "ListDomainsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the metadata and configuration of a domain.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}", +"httpMethod": "PATCH", +"id": "managedidentities.projects.locations.global.domains.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The unique name of the domain using the form: `projects/{project_id}/locations/global/domains/{domain_name}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask of fields to update. At least one path must be supplied in this field. The elements of the repeated paths field may only include fields from Domain: * `labels` * `locations` * `authorized_networks` * `audit_logs_enabled`", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "Domain" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"reconfigureTrust": { +"description": "Updates the DNS conditional forwarder.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:reconfigureTrust", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.reconfigureTrust", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource domain name, project name and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:reconfigureTrust", +"request": { +"$ref": "ReconfigureTrustRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"resetAdminPassword": { +"description": "Resets a domain's administrator password.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:resetAdminPassword", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.resetAdminPassword", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:resetAdminPassword", +"request": { +"$ref": "ResetAdminPasswordRequest" +}, +"response": { +"$ref": "ResetAdminPasswordResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"restore": { +"description": "RestoreDomain restores domain backup mentioned in the RestoreDomainRequest", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:restore", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.restore", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Resource name for the domain to which the backup belongs", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:restore", +"request": { +"$ref": "RestoreDomainRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:setIamPolicy", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:testIamPermissions", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"updateLdapssettings": { +"description": "Patches a single ldaps settings.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/ldapssettings", +"httpMethod": "PATCH", +"id": "managedidentities.projects.locations.global.domains.updateLdapssettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The resource name of the LDAPS settings. Uses the form: `projects/{project}/locations/{location}/domains/{domain}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask of fields to update. At least one path must be supplied in this field. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}/ldapssettings", +"request": { +"$ref": "LDAPSSettings" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"validateTrust": { +"description": "Validates a trust state, that the target domain is reachable, and that the target domain is able to accept incoming trust requests.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}:validateTrust", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.validateTrust", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource domain name, project name, and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:validateTrust", +"request": { +"$ref": "ValidateTrustRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"backups": { +"methods": { +"create": { +"description": "Creates a Backup for a domain.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/backups", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.backups.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"backupId": { +"description": "Required. Backup Id, unique name to identify the backups with the following restrictions: * Must be lowercase letters, numbers, and hyphens * Must start with a letter. * Must contain between 1-63 characters. * Must end with a number or a letter. * Must be unique within the domain.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/backups", +"request": { +"$ref": "Backup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes identified Backup.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}", +"httpMethod": "DELETE", +"id": "managedidentities.projects.locations.global.domains.backups.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The backup resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}/backups/{backup_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single Backup.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.backups.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The backup resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}/backups/{backup_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Backup" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}:getIamPolicy", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.backups.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists Backup in a given project.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/backups", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.backups.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filter specifying constraints of a list operation.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Specifies the ordering of results following syntax at https://cloud.google.com/apis/design/design_patterns#sorting_order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of items to return. If not specified, a default value of 1000 will be used by the service. Regardless of the page_size value, the response may include a partial list and a caller should only rely on response's next_page_token to determine if there are more instances left to be queried.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The `next_page_token` value returned from a previous List request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/backups", +"response": { +"$ref": "ListBackupsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the labels for specified Backup.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}", +"httpMethod": "PATCH", +"id": "managedidentities.projects.locations.global.domains.backups.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Output only. The unique name of the Backup in the form of `projects/{project_id}/locations/global/domains/{domain_name}/backups/{name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask of fields to update. At least one path must be supplied in this field. The elements of the repeated paths field may only include these fields from Backup: * `labels`", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "Backup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}:setIamPolicy", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.backups.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}:testIamPermissions", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.backups.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"sqlIntegrations": { +"methods": { +"get": { +"description": "Gets details of a single sqlIntegration.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/sqlIntegrations/{sqlIntegrationsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.sqlIntegrations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. SQLIntegration resource name using the form: `projects/{project_id}/locations/global/domains/{domain}/sqlIntegrations/{name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/sqlIntegrations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "SqlIntegration" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists SqlIntegrations in a given domain.", +"flatPath": "v1/projects/{projectsId}/locations/global/domains/{domainsId}/sqlIntegrations", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.sqlIntegrations.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filter specifying constraints of a list operation. For example, `SqlIntegration.name=\"sql\"`.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Specifies the ordering of results following syntax at https://cloud.google.com/apis/design/design_patterns#sorting_order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of items to return. If not specified, a default value of 1000 will be used by the service. Regardless of the page_size value, the response may include a partial list and a caller should only rely on response'ANIZATIONs next_page_token to determine if there are more instances left to be queried.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The next_page_token value returned from a previous List request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource name of the SqlIntegrations using the form: `projects/{project_id}/locations/global/domains/*`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/sqlIntegrations", +"response": { +"$ref": "ListSqlIntegrationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +}, +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/locations/global/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"request": { +"$ref": "CancelOperationRequest" +}, +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/locations/global/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "managedidentities.projects.locations.global.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/locations/global/operations/{operationsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/locations/global/operations", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/operations$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"peerings": { +"methods": { +"create": { +"description": "Creates a Peering for Managed AD instance.", +"flatPath": "v1/projects/{projectsId}/locations/global/peerings", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.peerings.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. Resource project name and location using the form: `projects/{project_id}/locations/global`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +}, +"peeringId": { +"description": "Required. Peering Id, unique name to identify peering. It should follow the regex format \"^(?:[a-z](?:[-a-z0-9]{0,61}[a-z0-9])?)$\"", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/peerings", +"request": { +"$ref": "Peering" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes identified Peering.", +"flatPath": "v1/projects/{projectsId}/locations/global/peerings/{peeringsId}", +"httpMethod": "DELETE", +"id": "managedidentities.projects.locations.global.peerings.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Peering resource name using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single Peering.", +"flatPath": "v1/projects/{projectsId}/locations/global/peerings/{peeringsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.peerings.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Peering resource name using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Peering" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/global/peerings/{peeringsId}:getIamPolicy", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.peerings.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists Peerings in a given project.", +"flatPath": "v1/projects/{projectsId}/locations/global/peerings", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.peerings.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filter specifying constraints of a list operation. For example, `peering.authorized_network=\"projects/myprojectid/global/networks/mynetwork\"`.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Specifies the ordering of results following syntax at https://cloud.google.com/apis/design/design_patterns#sorting_order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of items to return. If not specified, a default value of 1000 will be used by the service. Regardless of the page_size value, the response may include a partial list and a caller should only rely on response's next_page_token to determine if there are more instances left to be queried.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The next_page_token value returned from a previous List request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource name of the peering location using the form: `projects/{project_id}/locations/global`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/peerings", +"response": { +"$ref": "ListPeeringsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the labels for specified Peering.", +"flatPath": "v1/projects/{projectsId}/locations/global/peerings/{peeringsId}", +"httpMethod": "PATCH", +"id": "managedidentities.projects.locations.global.peerings.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Output only. Unique name of the peering in this scope including projects and location using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask of fields to update. At least one path must be supplied in this field. The elements of the repeated paths field may only include these fields from Peering: * `labels`", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "Peering" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/global/peerings/{peeringsId}:setIamPolicy", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.peerings.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/global/peerings/{peeringsId}:testIamPermissions", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.peerings.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +} +} +} +} +}, +"revision": "20240530", +"rootUrl": "https://managedidentities.googleapis.com/", +"schemas": { +"AttachTrustRequest": { +"description": "Request message for AttachTrust", +"id": "AttachTrustRequest", +"properties": { +"trust": { +"$ref": "Trust", +"description": "Required. The domain trust resource." +} +}, +"type": "object" +}, +"Backup": { +"description": "Represents a Managed Microsoft Identities backup.", +"id": "Backup", +"properties": { +"createTime": { +"description": "Output only. The time the backups was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels to represent user provided metadata.", +"type": "object" +}, +"name": { +"description": "Output only. The unique name of the Backup in the form of `projects/{project_id}/locations/global/domains/{domain_name}/backups/{name}`", +"readOnly": true, +"type": "string" +}, +"state": { +"description": "Output only. The current state of the backup.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"FAILED", +"DELETING" +], +"enumDescriptions": [ +"Not set.", +"Backup is being created.", +"Backup has been created and validated.", +"Backup has been created but failed validation.", +"Backup is being deleted." +], +"readOnly": true, +"type": "string" +}, +"statusMessage": { +"description": "Output only. Additional information about the current status of this backup, if available.", +"readOnly": true, +"type": "string" +}, +"type": { +"description": "Output only. Indicates whether it\u2019s an on-demand backup or scheduled.", +"enum": [ +"TYPE_UNSPECIFIED", +"ON_DEMAND", +"SCHEDULED" +], +"enumDescriptions": [ +"Backup was manually created.", +"Backup was manually created.", +"Backup was automatically created." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Binding": { +"description": "Associates `members`, or principals, with a `role`.", +"id": "Binding", +"properties": { +"condition": { +"$ref": "Expr", +"description": "The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies)." +}, +"members": { +"description": "Specifies the principals requesting access for a Google Cloud resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workforce identity pool. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/group/{group_id}`: All workforce identities in a group. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All workforce identities with a specific attribute value. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/*`: All identities in a workforce identity pool. * `principal://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workload identity pool. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/group/{group_id}`: A workload identity pool group. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All identities in a workload identity pool with a certain attribute. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/*`: All identities in a workload identity pool. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: Deleted single identity in a workforce identity pool. For example, `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-pool-id/subject/my-subject-attribute-value`.", +"items": { +"type": "string" +}, +"type": "array" +}, +"role": { +"description": "Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview of the IAM roles and permissions, see the [IAM documentation](https://cloud.google.com/iam/docs/roles-overview). For a list of the available pre-defined roles, see [here](https://cloud.google.com/iam/docs/understanding-roles).", +"type": "string" +} +}, +"type": "object" +}, +"CancelOperationRequest": { +"description": "The request message for Operations.CancelOperation.", +"id": "CancelOperationRequest", +"properties": {}, +"type": "object" +}, +"Certificate": { +"description": "Certificate used to configure LDAPS.", +"id": "Certificate", +"properties": { +"expireTime": { +"description": "The certificate expire time.", +"format": "google-datetime", +"type": "string" +}, +"issuingCertificate": { +"$ref": "Certificate", +"description": "The issuer of this certificate." +}, +"subject": { +"description": "The certificate subject.", +"type": "string" +}, +"subjectAlternativeName": { +"description": "The additional hostnames for the domain.", +"items": { +"type": "string" +}, +"type": "array" +}, +"thumbprint": { +"description": "The certificate thumbprint which uniquely identifies the certificate.", +"type": "string" +} +}, +"type": "object" +}, +"CheckMigrationPermissionRequest": { +"description": "CheckMigrationPermissionRequest is the request message for CheckMigrationPermission method.", +"id": "CheckMigrationPermissionRequest", +"properties": {}, +"type": "object" +}, +"CheckMigrationPermissionResponse": { +"description": "CheckMigrationPermissionResponse is the response message for CheckMigrationPermission method.", +"id": "CheckMigrationPermissionResponse", +"properties": { +"onpremDomains": { +"description": "The state of SID filtering of all the domains which has trust established.", +"items": { +"$ref": "OnPremDomainSIDDetails" +}, +"type": "array" +}, +"state": { +"description": "The state of DomainMigration.", +"enum": [ +"STATE_UNSPECIFIED", +"DISABLED", +"ENABLED", +"NEEDS_MAINTENANCE" +], +"enumDescriptions": [ +"DomainMigration is in unspecified state.", +"Domain Migration is Disabled.", +"Domain Migration is Enabled.", +"Domain Migration is not in valid state." +], +"type": "string" +} +}, +"type": "object" +}, +"DailyCycle": { +"description": "Time window specified for daily operations.", +"id": "DailyCycle", +"properties": { +"duration": { +"description": "Output only. Duration of the time window, set by service producer.", +"format": "google-duration", +"type": "string" +}, +"startTime": { +"$ref": "TimeOfDay", +"description": "Time within the day to start the operations." +} +}, +"type": "object" +}, +"Date": { +"description": "Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp", +"id": "Date", +"properties": { +"day": { +"description": "Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.", +"format": "int32", +"type": "integer" +}, +"month": { +"description": "Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.", +"format": "int32", +"type": "integer" +}, +"year": { +"description": "Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"DenyMaintenancePeriod": { +"description": "DenyMaintenancePeriod definition. Maintenance is forbidden within the deny period. The start_date must be less than the end_date.", +"id": "DenyMaintenancePeriod", +"properties": { +"endDate": { +"$ref": "Date", +"description": "Deny period end date. This can be: * A full date, with non-zero year, month and day values. * A month and day value, with a zero year. Allows recurring deny periods each year. Date matching this period will have to be before the end." +}, +"startDate": { +"$ref": "Date", +"description": "Deny period start date. This can be: * A full date, with non-zero year, month and day values. * A month and day value, with a zero year. Allows recurring deny periods each year. Date matching this period will have to be the same or after the start." +}, +"time": { +"$ref": "TimeOfDay", +"description": "Time in UTC when the Blackout period starts on start_date and ends on end_date. This can be: * Full time. * All zeros for 00:00:00 UTC" +} +}, +"type": "object" +}, +"DetachTrustRequest": { +"description": "Request message for DetachTrust", +"id": "DetachTrustRequest", +"properties": { +"trust": { +"$ref": "Trust", +"description": "Required. The domain trust resource to removed." +} +}, +"type": "object" +}, +"DisableMigrationRequest": { +"description": "DisableMigrationRequest is the request message for DisableMigration method.", +"id": "DisableMigrationRequest", +"properties": {}, +"type": "object" +}, +"Domain": { +"description": "Represents a managed Microsoft Active Directory domain. If the domain is being changed, it will be placed into the UPDATING state, which indicates that the resource is being reconciled. At this point, Get will reflect an intermediate state.", +"id": "Domain", +"properties": { +"admin": { +"description": "Optional. The name of delegated administrator account used to perform Active Directory operations. If not specified, `setupadmin` will be used.", +"type": "string" +}, +"auditLogsEnabled": { +"description": "Optional. Configuration for audit logs. True if audit logs are enabled, else false. Default is audit logs disabled.", +"type": "boolean" +}, +"authorizedNetworks": { +"description": "Optional. The full names of the Google Compute Engine [networks](/compute/docs/networks-and-firewalls#networks) the domain instance is connected to. Networks can be added using UpdateDomain. The domain is only available on networks listed in `authorized_networks`. If CIDR subnets overlap between networks, domain creation will fail.", +"items": { +"type": "string" +}, +"type": "array" +}, +"createTime": { +"description": "Output only. The time the instance was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"fqdn": { +"description": "Output only. The fully-qualified domain name of the exposed domain used by clients to connect to the service. Similar to what would be chosen for an Active Directory set up on an internal network.", +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels that can contain user-provided metadata.", +"type": "object" +}, +"locations": { +"description": "Required. Locations where domain needs to be provisioned. The locations can be specified according to https://cloud.google.com/compute/docs/regions-zones, such as `us-west1` or `us-east4`. Each domain supports up to 4 locations, separated by commas. Each location will use a /26 block.", +"items": { +"type": "string" +}, +"type": "array" +}, +"name": { +"description": "Required. The unique name of the domain using the form: `projects/{project_id}/locations/global/domains/{domain_name}`.", +"type": "string" +}, +"reservedIpRange": { +"description": "Required. The CIDR range of internal addresses that are reserved for this domain. Reserved networks must be /24 or larger. Ranges must be unique and non-overlapping with existing subnets in [Domain].[authorized_networks].", +"type": "string" +}, +"state": { +"description": "Output only. The current state of this domain.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY", +"UPDATING", +"DELETING", +"REPAIRING", +"PERFORMING_MAINTENANCE", +"UNAVAILABLE" +], +"enumDescriptions": [ +"Not set.", +"The domain is being created.", +"The domain has been created and is fully usable.", +"The domain's configuration is being updated.", +"The domain is being deleted.", +"The domain is being repaired and may be unusable. Details can be found in the `status_message` field.", +"The domain is undergoing maintenance.", +"The domain is not serving requests." +], +"readOnly": true, +"type": "string" +}, +"statusMessage": { +"description": "Output only. Additional information about the current status of this domain, if available.", +"readOnly": true, +"type": "string" +}, +"trusts": { +"description": "Output only. The current trusts associated with the domain.", +"items": { +"$ref": "Trust" +}, +"readOnly": true, +"type": "array" +}, +"updateTime": { +"description": "Output only. The last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"DomainJoinMachineRequest": { +"description": "DomainJoinMachineRequest is the request message for DomainJoinMachine method", +"id": "DomainJoinMachineRequest", +"properties": { +"force": { +"description": "Optional. force if True, forces domain join even if the computer account already exists.", +"type": "boolean" +}, +"ouName": { +"description": "Optional. OU name where the VM needs to be domain joined", +"type": "string" +}, +"vmIdToken": { +"description": "Required. Full instance id token of compute engine VM to verify instance identity. More about this: https://cloud.google.com/compute/docs/instances/verifying-instance-identity#request_signature", +"type": "string" +} +}, +"type": "object" +}, +"DomainJoinMachineResponse": { +"description": "DomainJoinMachineResponse is the response message for DomainJoinMachine method", +"id": "DomainJoinMachineResponse", +"properties": { +"domainJoinBlob": { +"description": "Offline domain join blob as the response", +"type": "string" +} +}, +"type": "object" +}, +"Empty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "Empty", +"properties": {}, +"type": "object" +}, +"EnableMigrationRequest": { +"description": "EnableMigrationRequest is the request message for EnableMigration method.", +"id": "EnableMigrationRequest", +"properties": { +"migratingDomains": { +"description": "Required. List of the on-prem domains to be migrated.", +"items": { +"$ref": "OnPremDomainDetails" +}, +"type": "array" +} +}, +"type": "object" +}, +"Expr": { +"description": "Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() < 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != 'private' && document.type != 'internal'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"'New message received at ' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.", +"id": "Expr", +"properties": { +"description": { +"description": "Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.", +"type": "string" +}, +"expression": { +"description": "Textual representation of an expression in Common Expression Language syntax.", +"type": "string" +}, +"location": { +"description": "Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.", +"type": "string" +}, +"title": { +"description": "Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.", +"type": "string" +} +}, +"type": "object" +}, +"ExtendSchemaRequest": { +"description": "ExtendSchemaRequest is the request message for ExtendSchema method.", +"id": "ExtendSchemaRequest", +"properties": { +"description": { +"description": "Required. Description for Schema Change.", +"type": "string" +}, +"fileContents": { +"description": "File uploaded as a byte stream input.", +"format": "byte", +"type": "string" +}, +"gcsPath": { +"description": "File stored in Cloud Storage bucket and represented in the form projects/{project_id}/buckets/{bucket_name}/objects/{object_name} File should be in the same project as the domain.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudManagedidentitiesV1OpMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "GoogleCloudManagedidentitiesV1OpMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"requestedCancellation": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudManagedidentitiesV1alpha1OpMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "GoogleCloudManagedidentitiesV1alpha1OpMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"requestedCancellation": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudManagedidentitiesV1beta1OpMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "GoogleCloudManagedidentitiesV1beta1OpMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"requestedCancellation": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1Instance": { +"description": "Instance represents the interface for SLM services to actuate the state of control plane resources. Example Instance in JSON, where consumer-project-number=123456, producer-project-id=cloud-sql: ```json Instance: { \"name\": \"projects/123456/locations/us-east1/instances/prod-instance\", \"create_time\": { \"seconds\": 1526406431, }, \"labels\": { \"env\": \"prod\", \"foo\": \"bar\" }, \"state\": READY, \"software_versions\": { \"software_update\": \"cloud-sql-09-28-2018\", }, \"maintenance_policy_names\": { \"UpdatePolicy\": \"projects/123456/locations/us-east1/maintenancePolicies/prod-update-policy\", } \"tenant_project_id\": \"cloud-sql-test-tenant\", \"producer_metadata\": { \"cloud-sql-tier\": \"basic\", \"cloud-sql-instance-size\": \"1G\", }, \"provisioned_resources\": [ { \"resource-type\": \"compute-instance\", \"resource-url\": \"https://www.googleapis.com/compute/v1/projects/cloud-sql/zones/us-east1-b/instances/vm-1\", } ], \"maintenance_schedules\": { \"csa_rollout\": { \"start_time\": { \"seconds\": 1526406431, }, \"end_time\": { \"seconds\": 1535406431, }, }, \"ncsa_rollout\": { \"start_time\": { \"seconds\": 1526406431, }, \"end_time\": { \"seconds\": 1535406431, }, } }, \"consumer_defined_name\": \"my-sql-instance1\", } ``` LINT.IfChange", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1Instance", +"properties": { +"consumerDefinedName": { +"description": "consumer_defined_name is the name of the instance set by the service consumers. Generally this is different from the `name` field which reperesents the system-assigned id of the instance which the service consumers do not recognize. This is a required field for tenants onboarding to Maintenance Window notifications (go/slm-rollout-maintenance-policies#prerequisites).", +"type": "string" +}, +"createTime": { +"description": "Output only. Timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"instanceType": { +"description": "Optional. The instance_type of this instance of format: projects/{project_number}/locations/{location_id}/instanceTypes/{instance_type_id}. Instance Type represents a high-level tier or SKU of the service that this instance belong to. When enabled(eg: Maintenance Rollout), Rollout uses 'instance_type' along with 'software_versions' to determine whether instance needs an update or not.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels to represent user provided metadata. Each label is a key-value pair, where both the key and the value are arbitrary strings provided by the user.", +"type": "object" +}, +"maintenancePolicyNames": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. The MaintenancePolicies that have been attached to the instance. The key must be of the type name of the oneof policy name defined in MaintenancePolicy, and the referenced policy must define the same policy type. For details, please refer to go/mr-user-guide. Should not be set if maintenance_settings.maintenance_policies is set.", +"type": "object" +}, +"maintenanceSchedules": { +"additionalProperties": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSchedule" +}, +"description": "The MaintenanceSchedule contains the scheduling information of published maintenance schedule with same key as software_versions.", +"type": "object" +}, +"maintenanceSettings": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSettings", +"description": "Optional. The MaintenanceSettings associated with instance." +}, +"name": { +"description": "Unique name of the resource. It uses the form: `projects/{project_number}/locations/{location_id}/instances/{instance_id}` Note: This name is passed, stored and logged across the rollout system. So use of consumer project_id or any other consumer PII in the name is strongly discouraged for wipeout (go/wipeout) compliance. See go/elysium/project_ids#storage-guidance for more details.", +"type": "string" +}, +"notificationParameters": { +"additionalProperties": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1NotificationParameter" +}, +"description": "Optional. notification_parameter are information that service producers may like to include that is not relevant to Rollout. This parameter will only be passed to Gamma and Cloud Logging for notification/logging purpose.", +"type": "object" +}, +"producerMetadata": { +"additionalProperties": { +"type": "string" +}, +"description": "Output only. Custom string attributes used primarily to expose producer-specific information in monitoring dashboards. See go/get-instance-metadata.", +"readOnly": true, +"type": "object" +}, +"provisionedResources": { +"description": "Output only. The list of data plane resources provisioned for this instance, e.g. compute VMs. See go/get-instance-metadata.", +"items": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1ProvisionedResource" +}, +"readOnly": true, +"type": "array" +}, +"slmInstanceTemplate": { +"description": "Link to the SLM instance template. Only populated when updating SLM instances via SSA's Actuation service adaptor. Service producers with custom control plane (e.g. Cloud SQL) doesn't need to populate this field. Instead they should use software_versions.", +"type": "string" +}, +"sloMetadata": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1SloMetadata", +"description": "Output only. SLO metadata for instance classification in the Standardized dataplane SLO platform. See go/cloud-ssa-standard-slo for feature description.", +"readOnly": true +}, +"softwareVersions": { +"additionalProperties": { +"type": "string" +}, +"description": "Software versions that are used to deploy this instance. This can be mutated by rollout services.", +"type": "object" +}, +"state": { +"description": "Output only. Current lifecycle state of the resource (e.g. if it's being created or ready to use).", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY", +"UPDATING", +"REPAIRING", +"DELETING", +"ERROR" +], +"enumDescriptions": [ +"Unspecified state.", +"Instance is being created.", +"Instance has been created and is ready to use.", +"Instance is being updated.", +"Instance is unheathy and under repair.", +"Instance is being deleted.", +"Instance encountered an error and is in indeterministic state." +], +"readOnly": true, +"type": "string" +}, +"tenantProjectId": { +"description": "Output only. ID of the associated GCP tenant project. See go/get-instance-metadata.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Timestamp when the resource was last modified.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSchedule": { +"description": "Maintenance schedule which is exposed to customer and potentially end user, indicating published upcoming future maintenance schedule", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSchedule", +"properties": { +"canReschedule": { +"deprecated": true, +"description": "This field is deprecated, and will be always set to true since reschedule can happen multiple times now. This field should not be removed until all service producers remove this for their customers.", +"type": "boolean" +}, +"endTime": { +"description": "The scheduled end time for the maintenance.", +"format": "google-datetime", +"type": "string" +}, +"rolloutManagementPolicy": { +"description": "The rollout management policy this maintenance schedule is associated with. When doing reschedule update request, the reschedule should be against this given policy.", +"type": "string" +}, +"scheduleDeadlineTime": { +"description": "schedule_deadline_time is the time deadline any schedule start time cannot go beyond, including reschedule. It's normally the initial schedule start time plus maintenance window length (1 day or 1 week). Maintenance cannot be scheduled to start beyond this deadline.", +"format": "google-datetime", +"type": "string" +}, +"startTime": { +"description": "The scheduled start time for the maintenance.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSettings": { +"description": "Maintenance settings associated with instance. Allows service producers and end users to assign settings that controls maintenance on this instance.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSettings", +"properties": { +"exclude": { +"description": "Optional. Exclude instance from maintenance. When true, rollout service will not attempt maintenance on the instance. Rollout service will include the instance in reported rollout progress as not attempted.", +"type": "boolean" +}, +"isRollback": { +"description": "Optional. If the update call is triggered from rollback, set the value as true.", +"type": "boolean" +}, +"maintenancePolicies": { +"additionalProperties": { +"$ref": "MaintenancePolicy" +}, +"description": "Optional. The MaintenancePolicies that have been attached to the instance. The key must be of the type name of the oneof policy name defined in MaintenancePolicy, and the embedded policy must define the same policy type. For details, please refer to go/mr-user-guide. Should not be set if maintenance_policy_names is set. If only the name is needed, then only populate MaintenancePolicy.name.", +"type": "object" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1NodeSloMetadata": { +"description": "Node information for custom per-node SLO implementations. SSA does not support per-node SLO, but producers can populate per-node information in SloMetadata for custom precomputations. SSA Eligibility Exporter will emit per-node metric based on this information.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1NodeSloMetadata", +"properties": { +"location": { +"description": "The location of the node, if different from instance location.", +"type": "string" +}, +"nodeId": { +"description": "The id of the node. This should be equal to SaasInstanceNode.node_id.", +"type": "string" +}, +"perSliEligibility": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1PerSliSloEligibility", +"description": "If present, this will override eligibility for the node coming from instance or exclusions for specified SLIs." +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1NotificationParameter": { +"description": "Contains notification related data.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1NotificationParameter", +"properties": { +"values": { +"description": "Optional. Array of string values. e.g. instance's replica information.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1PerSliSloEligibility": { +"description": "PerSliSloEligibility is a mapping from an SLI name to eligibility.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1PerSliSloEligibility", +"properties": { +"eligibilities": { +"additionalProperties": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1SloEligibility" +}, +"description": "An entry in the eligibilities map specifies an eligibility for a particular SLI for the given instance. The SLI key in the name must be a valid SLI name specified in the Eligibility Exporter binary flags otherwise an error will be emitted by Eligibility Exporter and the oncaller will be alerted. If an SLI has been defined in the binary flags but the eligibilities map does not contain it, the corresponding SLI time series will not be emitted by the Eligibility Exporter. This ensures a smooth rollout and compatibility between the data produced by different versions of the Eligibility Exporters. If eligibilities map contains a key for an SLI which has not been declared in the binary flags, there will be an error message emitted in the Eligibility Exporter log and the metric for the SLI in question will not be emitted.", +"type": "object" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1ProvisionedResource": { +"description": "Describes provisioned dataplane resources.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1ProvisionedResource", +"properties": { +"resourceType": { +"description": "Type of the resource. This can be either a GCP resource or a custom one (e.g. another cloud provider's VM). For GCP compute resources use singular form of the names listed in GCP compute API documentation (https://cloud.google.com/compute/docs/reference/rest/v1/), prefixed with 'compute-', for example: 'compute-instance', 'compute-disk', 'compute-autoscaler'.", +"type": "string" +}, +"resourceUrl": { +"description": "URL identifying the resource, e.g. \"https://www.googleapis.com/compute/v1/projects/...)\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1SloEligibility": { +"description": "SloEligibility is a tuple containing eligibility value: true if an instance is eligible for SLO calculation or false if it should be excluded from all SLO-related calculations along with a user-defined reason.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1SloEligibility", +"properties": { +"eligible": { +"description": "Whether an instance is eligible or ineligible.", +"type": "boolean" +}, +"reason": { +"description": "User-defined reason for the current value of instance eligibility. Usually, this can be directly mapped to the internal state. An empty reason is allowed.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1SloMetadata": { +"description": "SloMetadata contains resources required for proper SLO classification of the instance.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1SloMetadata", +"properties": { +"nodes": { +"description": "Optional. List of nodes. Some producers need to use per-node metadata to calculate SLO. This field allows such producers to publish per-node SLO meta data, which will be consumed by SSA Eligibility Exporter and published in the form of per node metric to Monarch.", +"items": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1NodeSloMetadata" +}, +"type": "array" +}, +"perSliEligibility": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1PerSliSloEligibility", +"description": "Optional. Multiple per-instance SLI eligibilities which apply for individual SLIs." +}, +"tier": { +"description": "Name of the SLO tier the Instance belongs to. This name will be expected to match the tiers specified in the service SLO configuration. Field is mandatory and must not be empty.", +"type": "string" +} +}, +"type": "object" +}, +"LDAPSSettings": { +"description": "LDAPSSettings represents the ldaps settings for domain resource. LDAP is the Lightweight Directory Access Protocol, defined in https://tools.ietf.org/html/rfc4511. The settings object configures LDAP over SSL/TLS, whether it is over port 636 or the StartTLS operation. If LDAPSSettings is being changed, it will be placed into the UPDATING state, which indicates that the resource is being reconciled. At this point, Get will reflect an intermediate state.", +"id": "LDAPSSettings", +"properties": { +"certificate": { +"$ref": "Certificate", +"description": "Output only. The certificate used to configure LDAPS. Certificates can be chained with a maximum length of 15.", +"readOnly": true +}, +"certificatePassword": { +"description": "Input only. The password used to encrypt the uploaded PFX certificate.", +"type": "string" +}, +"certificatePfx": { +"description": "Input only. The uploaded PKCS12-formatted certificate to configure LDAPS with. It will enable the domain controllers in this domain to accept LDAPS connections (either LDAP over SSL/TLS or the StartTLS operation). A valid certificate chain must form a valid x.509 certificate chain (or be comprised of a single self-signed certificate. It must be encrypted with either: 1) PBES2 + PBKDF2 + AES256 encryption and SHA256 PRF; or 2) pbeWithSHA1And3-KeyTripleDES-CBC Private key must be included for the leaf / single self-signed certificate. Note: For a fqdn your-example-domain.com, the wildcard fqdn is *.your-example-domain.com. Specifically the leaf certificate must have: - Either a blank subject or a subject with CN matching the wildcard fqdn. - Exactly two SANs - the fqdn and wildcard fqdn. - Encipherment and digital key signature key usages. - Server authentication extended key usage (OID=1.3.6.1.5.5.7.3.1) - Private key must be in one of the following formats: RSA, ECDSA, ED25519. - Private key must have appropriate key length: 2048 for RSA, 256 for ECDSA - Signature algorithm of the leaf certificate cannot be MD2, MD5 or SHA1.", +"format": "byte", +"type": "string" +}, +"name": { +"description": "The resource name of the LDAPS settings. Uses the form: `projects/{project}/locations/{location}/domains/{domain}`.", +"type": "string" +}, +"state": { +"description": "Output only. The current state of this LDAPS settings.", +"enum": [ +"STATE_UNSPECIFIED", +"UPDATING", +"ACTIVE", +"FAILED" +], +"enumDescriptions": [ +"Not Set", +"The LDAPS setting is being updated.", +"The LDAPS setting is ready.", +"The LDAPS setting is not applied correctly." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ListBackupsResponse": { +"description": "ListBackupsResponse is the response message for ListBackups method.", +"id": "ListBackupsResponse", +"properties": { +"backups": { +"description": "A list of Cloud AD backups in the domain.", +"items": { +"$ref": "Backup" +}, +"type": "array" +}, +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListDomainsResponse": { +"description": "Response message for ListDomains", +"id": "ListDomainsResponse", +"properties": { +"domains": { +"description": "A list of Managed Identities Service domains in the project.", +"items": { +"$ref": "Domain" +}, +"type": "array" +}, +"nextPageToken": { +"description": "A token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"unreachable": { +"description": "A list of locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListLocationsResponse": { +"description": "The response message for Locations.ListLocations.", +"id": "ListLocationsResponse", +"properties": { +"locations": { +"description": "A list of locations that matches the specified filter in the request.", +"items": { +"$ref": "Location" +}, +"type": "array" +}, +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +} +}, +"type": "object" +}, +"ListOperationsResponse": { +"description": "The response message for Operations.ListOperations.", +"id": "ListOperationsResponse", +"properties": { +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +}, +"operations": { +"description": "A list of operations that matches the specified filter in the request.", +"items": { +"$ref": "Operation" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListPeeringsResponse": { +"description": "ListPeeringsResponse is the response message for ListPeerings method.", +"id": "ListPeeringsResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"peerings": { +"description": "A list of Managed Identities Service Peerings in the project.", +"items": { +"$ref": "Peering" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListSqlIntegrationsResponse": { +"description": "ListSqlIntegrationsResponse is the response message for ListSqlIntegrations method.", +"id": "ListSqlIntegrationsResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"sqlIntegrations": { +"description": "A list of SQLIntegrations of a domain.", +"items": { +"$ref": "SqlIntegration" +}, +"type": "array" +}, +"unreachable": { +"description": "A list of locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Location": { +"description": "A resource that represents a Google Cloud location.", +"id": "Location", +"properties": { +"displayName": { +"description": "The friendly name for this location, typically a nearby city name. For example, \"Tokyo\".", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Cross-service attributes for the location. For example {\"cloud.googleapis.com/region\": \"us-east1\"}", +"type": "object" +}, +"locationId": { +"description": "The canonical id for this location. For example: `\"us-east1\"`.", +"type": "string" +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata. For example the available capacity at the given location.", +"type": "object" +}, +"name": { +"description": "Resource name for the location, which may vary between implementations. For example: `\"projects/example-project/locations/us-east1\"`", +"type": "string" +} +}, +"type": "object" +}, +"MaintenancePolicy": { +"description": "Defines policies to service maintenance events.", +"id": "MaintenancePolicy", +"properties": { +"createTime": { +"description": "Output only. The time when the resource was created.", +"format": "google-datetime", +"type": "string" +}, +"description": { +"description": "Optional. Description of what this policy is for. Create/Update methods return INVALID_ARGUMENT if the length is greater than 512.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels to represent user provided metadata. Each label is a key-value pair, where both the key and the value are arbitrary strings provided by the user.", +"type": "object" +}, +"name": { +"description": "Required. MaintenancePolicy name using the form: `projects/{project_id}/locations/{location_id}/maintenancePolicies/{maintenance_policy_id}` where {project_id} refers to a GCP consumer project ID, {location_id} refers to a GCP region/zone, {maintenance_policy_id} must be 1-63 characters long and match the regular expression `[a-z0-9]([-a-z0-9]*[a-z0-9])?`.", +"type": "string" +}, +"state": { +"description": "Optional. The state of the policy.", +"enum": [ +"STATE_UNSPECIFIED", +"READY", +"DELETING" +], +"enumDescriptions": [ +"Unspecified state.", +"Resource is ready to be used.", +"Resource is being deleted. It can no longer be attached to instances." +], +"type": "string" +}, +"updatePolicy": { +"$ref": "UpdatePolicy", +"description": "Maintenance policy applicable to instance update." +}, +"updateTime": { +"description": "Output only. The time when the resource was updated.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"MaintenanceWindow": { +"description": "MaintenanceWindow definition.", +"id": "MaintenanceWindow", +"properties": { +"dailyCycle": { +"$ref": "DailyCycle", +"description": "Daily cycle." +}, +"weeklyCycle": { +"$ref": "WeeklyCycle", +"description": "Weekly cycle." +} +}, +"type": "object" +}, +"OnPremDomainDetails": { +"description": "OnPremDomainDetails is the message which contains details of on-prem domain which is trusted and needs to be migrated.", +"id": "OnPremDomainDetails", +"properties": { +"disableSidFiltering": { +"description": "Optional. Option to disable SID filtering.", +"type": "boolean" +}, +"domainName": { +"description": "Required. FQDN of the on-prem domain being migrated.", +"type": "string" +} +}, +"type": "object" +}, +"OnPremDomainSIDDetails": { +"description": "OnPremDomainDetails is the message which contains details of on-prem domain which is trusted and needs to be migrated.", +"id": "OnPremDomainSIDDetails", +"properties": { +"name": { +"description": "FQDN of the on-prem domain being migrated.", +"type": "string" +}, +"sidFilteringState": { +"description": "Current SID filtering state.", +"enum": [ +"SID_FILTERING_STATE_UNSPECIFIED", +"ENABLED", +"DISABLED" +], +"enumDescriptions": [ +"SID Filtering is in unspecified state.", +"SID Filtering is Enabled.", +"SID Filtering is Disabled." +], +"type": "string" +} +}, +"type": "object" +}, +"Operation": { +"description": "This resource represents a long-running operation that is the result of a network API call.", +"id": "Operation", +"properties": { +"done": { +"description": "If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.", +"type": "boolean" +}, +"error": { +"$ref": "Status", +"description": "The error result of the operation in case of failure or cancellation." +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.", +"type": "object" +}, +"name": { +"description": "The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.", +"type": "string" +}, +"response": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.", +"type": "object" +} +}, +"type": "object" +}, +"OperationMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "OperationMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"cancelRequested": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have been cancelled successfully have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"statusDetail": { +"description": "Output only. Human-readable status of the operation, if any.", +"readOnly": true, +"type": "string" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Peering": { +"description": "Represents a Managed Service for Microsoft Active Directory Peering.", +"id": "Peering", +"properties": { +"authorizedNetwork": { +"description": "Required. The full names of the Google Compute Engine [networks](/compute/docs/networks-and-firewalls#networks) to which the instance is connected. Caller needs to make sure that CIDR subnets do not overlap between networks, else peering creation will fail.", +"type": "string" +}, +"createTime": { +"description": "Output only. The time the instance was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"domainResource": { +"description": "Required. Full domain resource path for the Managed AD Domain involved in peering. The resource path should be in the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels to represent user-provided metadata.", +"type": "object" +}, +"name": { +"description": "Output only. Unique name of the peering in this scope including projects and location using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`.", +"readOnly": true, +"type": "string" +}, +"state": { +"description": "Output only. The current state of this Peering.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"CONNECTED", +"DISCONNECTED", +"DELETING" +], +"enumDescriptions": [ +"Not set.", +"Peering is being created.", +"Peering is connected.", +"Peering is disconnected.", +"Peering is being deleted." +], +"readOnly": true, +"type": "string" +}, +"statusMessage": { +"description": "Output only. Additional information about the current status of this peering, if available.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Policy": { +"description": "An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** ``` { \"bindings\": [ { \"role\": \"roles/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike@example.com\", \"group:admins@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles/resourcemanager.organizationViewer\", \"members\": [ \"user:eve@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time < timestamp('2020-10-01T00:00:00.000Z')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 } ``` **YAML example:** ``` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 ``` For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).", +"id": "Policy", +"properties": { +"bindings": { +"description": "Associates a list of `members`, or principals, with a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one principal. The `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of these principals can be Google groups. Each occurrence of a principal counts towards these limits. For example, if the `bindings` grant 50 different roles to `user:alice@example.com`, and not to any other principal, then you can add another 1,450 principals to the `bindings` in the `Policy`.", +"items": { +"$ref": "Binding" +}, +"type": "array" +}, +"etag": { +"description": "`etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.", +"format": "byte", +"type": "string" +}, +"version": { +"description": "Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"ReconfigureTrustRequest": { +"description": "Request message for ReconfigureTrust", +"id": "ReconfigureTrustRequest", +"properties": { +"targetDnsIpAddresses": { +"description": "Required. The target DNS server IP addresses to resolve the remote domain involved in the trust.", +"items": { +"type": "string" +}, +"type": "array" +}, +"targetDomainName": { +"description": "Required. The fully-qualified target domain name which will be in trust with current domain.", +"type": "string" +} +}, +"type": "object" +}, +"ResetAdminPasswordRequest": { +"description": "Request message for ResetAdminPassword", +"id": "ResetAdminPasswordRequest", +"properties": {}, +"type": "object" +}, +"ResetAdminPasswordResponse": { +"description": "Response message for ResetAdminPassword", +"id": "ResetAdminPasswordResponse", +"properties": { +"password": { +"description": "A random password. See admin for more information.", +"type": "string" +} +}, +"type": "object" +}, +"RestoreDomainRequest": { +"description": "RestoreDomainRequest is the request received by RestoreDomain rpc", +"id": "RestoreDomainRequest", +"properties": { +"backupId": { +"description": "Required. ID of the backup to be restored", +"type": "string" +} +}, +"type": "object" +}, +"Schedule": { +"description": "Configure the schedule.", +"id": "Schedule", +"properties": { +"day": { +"description": "Allows to define schedule that runs specified day of the week.", +"enum": [ +"DAY_OF_WEEK_UNSPECIFIED", +"MONDAY", +"TUESDAY", +"WEDNESDAY", +"THURSDAY", +"FRIDAY", +"SATURDAY", +"SUNDAY" +], +"enumDescriptions": [ +"The day of the week is unspecified.", +"Monday", +"Tuesday", +"Wednesday", +"Thursday", +"Friday", +"Saturday", +"Sunday" +], +"type": "string" +}, +"duration": { +"description": "Output only. Duration of the time window, set by service producer.", +"format": "google-duration", +"type": "string" +}, +"startTime": { +"$ref": "TimeOfDay", +"description": "Time within the window to start the operations." +} +}, +"type": "object" +}, +"SetIamPolicyRequest": { +"description": "Request message for `SetIamPolicy` method.", +"id": "SetIamPolicyRequest", +"properties": { +"policy": { +"$ref": "Policy", +"description": "REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them." +} +}, +"type": "object" +}, +"SqlIntegration": { +"description": "Represents the SQL instance integrated with Managed AD.", +"id": "SqlIntegration", +"properties": { +"createTime": { +"description": "Output only. The time the SQL integration was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"name": { +"description": "The unique name of the SQL integration in the form of `projects/{project_id}/locations/global/domains/{domain_name}/sqlIntegrations/{sql_integration}`", +"type": "string" +}, +"sqlInstance": { +"description": "The full resource name of an integrated SQL instance", +"type": "string" +}, +"state": { +"description": "Output only. The current state of the SQL integration.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"DELETING", +"READY" +], +"enumDescriptions": [ +"Not Set", +"The SQL integration is being created.", +"The SQL integration is being deleted.", +"The SQL integration is ready." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time the SQL integration was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Status": { +"description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", +"id": "Status", +"properties": { +"code": { +"description": "The status code, which should be an enum value of google.rpc.Code.", +"format": "int32", +"type": "integer" +}, +"details": { +"description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", +"items": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"type": "object" +}, +"type": "array" +}, +"message": { +"description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", +"type": "string" +} +}, +"type": "object" +}, +"TestIamPermissionsRequest": { +"description": "Request message for `TestIamPermissions` method.", +"id": "TestIamPermissionsRequest", +"properties": { +"permissions": { +"description": "The set of permissions to check for the `resource`. Permissions with wildcards (such as `*` or `storage.*`) are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"TestIamPermissionsResponse": { +"description": "Response message for `TestIamPermissions` method.", +"id": "TestIamPermissionsResponse", +"properties": { +"permissions": { +"description": "A subset of `TestPermissionsRequest.permissions` that the caller is allowed.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"TimeOfDay": { +"description": "Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`.", +"id": "TimeOfDay", +"properties": { +"hours": { +"description": "Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value \"24:00:00\" for scenarios like business closing time.", +"format": "int32", +"type": "integer" +}, +"minutes": { +"description": "Minutes of hour of day. Must be from 0 to 59.", +"format": "int32", +"type": "integer" +}, +"nanos": { +"description": "Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.", +"format": "int32", +"type": "integer" +}, +"seconds": { +"description": "Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"Trust": { +"description": "Represents a relationship between two domains. This allows a controller in one domain to authenticate a user in another domain. If the trust is being changed, it will be placed into the UPDATING state, which indicates that the resource is being reconciled. At this point, Get will reflect an intermediate state.", +"id": "Trust", +"properties": { +"createTime": { +"description": "Output only. The time the instance was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"lastTrustHeartbeatTime": { +"description": "Output only. The last heartbeat time when the trust was known to be connected.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"selectiveAuthentication": { +"description": "Optional. The trust authentication type, which decides whether the trusted side has forest/domain wide access or selective access to an approved set of resources.", +"type": "boolean" +}, +"state": { +"description": "Output only. The current state of the trust.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"UPDATING", +"DELETING", +"CONNECTED", +"DISCONNECTED" +], +"enumDescriptions": [ +"Not set.", +"The domain trust is being created.", +"The domain trust is being updated.", +"The domain trust is being deleted.", +"The domain trust is connected.", +"The domain trust is disconnected." +], +"readOnly": true, +"type": "string" +}, +"stateDescription": { +"description": "Output only. Additional information about the current state of the trust, if available.", +"readOnly": true, +"type": "string" +}, +"targetDnsIpAddresses": { +"description": "Required. The target DNS server IP addresses which can resolve the remote domain involved in the trust.", +"items": { +"type": "string" +}, +"type": "array" +}, +"targetDomainName": { +"description": "Required. The fully qualified target domain name which will be in trust with the current domain.", +"type": "string" +}, +"trustDirection": { +"description": "Required. The trust direction, which decides if the current domain is trusted, trusting, or both.", +"enum": [ +"TRUST_DIRECTION_UNSPECIFIED", +"INBOUND", +"OUTBOUND", +"BIDIRECTIONAL" +], +"enumDescriptions": [ +"Not set.", +"The inbound direction represents the trusting side.", +"The outboud direction represents the trusted side.", +"The bidirectional direction represents the trusted / trusting side." +], +"type": "string" +}, +"trustHandshakeSecret": { +"description": "Required. The trust secret used for the handshake with the target domain. This will not be stored.", +"type": "string" +}, +"trustType": { +"description": "Required. The type of trust represented by the trust resource.", +"enum": [ +"TRUST_TYPE_UNSPECIFIED", +"FOREST", +"EXTERNAL" +], +"enumDescriptions": [ +"Not set.", +"The forest trust.", +"The external domain trust." +], +"type": "string" +}, +"updateTime": { +"description": "Output only. The last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"UpdatePolicy": { +"description": "Maintenance policy applicable to instance updates.", +"id": "UpdatePolicy", +"properties": { +"channel": { +"description": "Optional. Relative scheduling channel applied to resource.", +"enum": [ +"UPDATE_CHANNEL_UNSPECIFIED", +"EARLIER", +"LATER", +"WEEK1", +"WEEK2", +"WEEK5" +], +"enumDescriptions": [ +"Unspecified channel.", +"Early channel within a customer project.", +"Later channel within a customer project.", +"! ! The follow channels can ONLY be used if you adopt the new MW system! ! ! NOTE: all WEEK channels are assumed to be under a weekly window. ! There is currently no dedicated channel definitions for Daily windows. ! If you use Daily window, the system will assume a 1d (24Hours) advanced ! notification period b/w EARLY and LATER. ! We may consider support more flexible daily channel specifications in ! the future. WEEK1 == EARLIER with minimum 7d advanced notification. {7d, 14d} The system will treat them equally and will use WEEK1 whenever it can. New customers are encouraged to use this channel annotation.", +"WEEK2 == LATER with minimum 14d advanced notification {14d, 21d}.", +"WEEK5 == 40d support. minimum 35d advanced notification {35d, 42d}." +], +"type": "string" +}, +"denyMaintenancePeriods": { +"description": "Deny Maintenance Period that is applied to resource to indicate when maintenance is forbidden. The protocol supports zero-to-many such periods, but the current SLM Rollout implementation only supports zero-to-one.", +"items": { +"$ref": "DenyMaintenancePeriod" +}, +"type": "array" +}, +"window": { +"$ref": "MaintenanceWindow", +"description": "Optional. Maintenance window that is applied to resources covered by this policy." +} +}, +"type": "object" +}, +"ValidateTrustRequest": { +"description": "Request message for ValidateTrust", +"id": "ValidateTrustRequest", +"properties": { +"trust": { +"$ref": "Trust", +"description": "Required. The domain trust to validate trust state for." +} +}, +"type": "object" +}, +"WeeklyCycle": { +"description": "Time window specified for weekly operations.", +"id": "WeeklyCycle", +"properties": { +"schedule": { +"description": "User can specify multiple windows in a week. Minimum of 1 window.", +"items": { +"$ref": "Schedule" +}, +"type": "array" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Managed Service for Microsoft Active Directory API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/managedidentities.v1beta1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/managedidentities.v1beta1.json new file mode 100644 index 0000000000000000000000000000000000000000..3a2e0e7bd2b01e2a3ffe21ace9dd26ba46e28a0f --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/managedidentities.v1beta1.json @@ -0,0 +1,3247 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +} +} +} +}, +"basePath": "", +"baseUrl": "https://managedidentities.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Managed Service for Microsoft Active Directory Consumer API", +"description": "The Managed Service for Microsoft Active Directory API is used for managing a highly available, hardened service running Microsoft Active Directory (AD).", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/managed-microsoft-ad/", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "managedidentities:v1beta1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://managedidentities.mtls.googleapis.com/", +"name": "managedidentities", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"projects": { +"resources": { +"locations": { +"methods": { +"get": { +"description": "Gets information about a location.", +"flatPath": "v1beta1/projects/{projectsId}/locations/{locationsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Resource name for the location.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Location" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists information about the supported locations for this service.", +"flatPath": "v1beta1/projects/{projectsId}/locations", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "A filter to narrow down results to a preferred subset. The filtering language accepts strings like `\"displayName=tokyo\"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160).", +"location": "query", +"type": "string" +}, +"name": { +"description": "The resource that owns the locations collection, if applicable.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return. If not set, the service selects a default.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.", +"location": "query", +"type": "string" +} +}, +"path": "v1beta1/{+name}/locations", +"response": { +"$ref": "ListLocationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"global": { +"resources": { +"domains": { +"methods": { +"attachTrust": { +"description": "Adds an AD trust to a domain.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:attachTrust", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.attachTrust", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource domain name, project name and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}:attachTrust", +"request": { +"$ref": "AttachTrustRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"checkMigrationPermission": { +"description": "CheckMigrationPermission API gets the current state of DomainMigration", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:checkMigrationPermission", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.checkMigrationPermission", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+domain}:checkMigrationPermission", +"request": { +"$ref": "CheckMigrationPermissionRequest" +}, +"response": { +"$ref": "CheckMigrationPermissionResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"create": { +"description": "Creates a Microsoft AD domain.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"domainName": { +"description": "Required. A domain name, e.g. mydomain.myorg.com, with the following restrictions: * Must contain only lowercase letters, numbers, periods and hyphens. * Must start with a letter. * Must contain between 2-64 characters. * Must end with a number or a letter. * Must not start with period. * First segment length (mydomain form example above) shouldn't exceed 15 chars. * The last segment cannot be fully numeric. * Must be unique within the customer project.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource project name and location using the form: `projects/{project_id}/locations/global`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+parent}/domains", +"request": { +"$ref": "Domain" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a domain.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}", +"httpMethod": "DELETE", +"id": "managedidentities.projects.locations.global.domains.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"detachTrust": { +"description": "Removes an AD trust.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:detachTrust", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.detachTrust", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource domain name, project name, and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}:detachTrust", +"request": { +"$ref": "DetachTrustRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"disableMigration": { +"description": "Disable Domain Migration", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:disableMigration", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.disableMigration", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+domain}:disableMigration", +"request": { +"$ref": "DisableMigrationRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"domainJoinMachine": { +"description": "DomainJoinMachine API joins a Compute Engine VM to the domain", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:domainJoinMachine", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.domainJoinMachine", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: projects/{project_id}/locations/global/domains/{domain_name}", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+domain}:domainJoinMachine", +"request": { +"$ref": "DomainJoinMachineRequest" +}, +"response": { +"$ref": "DomainJoinMachineResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"enableMigration": { +"description": "Enable Domain Migration", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:enableMigration", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.enableMigration", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+domain}:enableMigration", +"request": { +"$ref": "EnableMigrationRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"extendSchema": { +"description": "Extend Schema for Domain", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:extendSchema", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.extendSchema", +"parameterOrder": [ +"domain" +], +"parameters": { +"domain": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+domain}:extendSchema", +"request": { +"$ref": "ExtendSchemaRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets information about a domain.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Domain" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:getIamPolicy", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getLdapssettings": { +"description": "Gets the domain ldaps settings.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/ldapssettings", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.getLdapssettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}/ldapssettings", +"response": { +"$ref": "LDAPSSettings" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists domains in a project.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. A filter specifying constraints of a list operation. For example, `Domain.fqdn=\"mydomain.myorginization\"`.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Specifies the ordering of results. See [Sorting order](https://cloud.google.com/apis/design/design_patterns#sorting_order) for more information.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of items to return. If not specified, a default value of 1000 will be used. Regardless of the page_size value, the response may include a partial list. Callers should rely on a response's next_page_token to determine if there are additional results to list.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The `next_page_token` value returned from a previous ListDomainsRequest request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource name of the domain location using the form: `projects/{project_id}/locations/global`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+parent}/domains", +"response": { +"$ref": "ListDomainsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the metadata and configuration of a domain.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}", +"httpMethod": "PATCH", +"id": "managedidentities.projects.locations.global.domains.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Output only. The unique name of the domain using the form: `projects/{project_id}/locations/global/domains/{domain_name}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask of fields to update. At least one path must be supplied in this field. The elements of the repeated paths field may only include fields from Domain: * `labels` * `locations` * `authorized_networks` * `audit_logs_enabled`", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"request": { +"$ref": "Domain" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"reconfigureTrust": { +"description": "Updates the DNS conditional forwarder.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:reconfigureTrust", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.reconfigureTrust", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource domain name, project name and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}:reconfigureTrust", +"request": { +"$ref": "ReconfigureTrustRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"resetAdminPassword": { +"description": "Resets a domain's administrator password.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:resetAdminPassword", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.resetAdminPassword", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}:resetAdminPassword", +"request": { +"$ref": "ResetAdminPasswordRequest" +}, +"response": { +"$ref": "ResetAdminPasswordResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"restore": { +"description": "RestoreBackup restores domain mentioned in the RestoreBackupRequest", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:restore", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.restore", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. resource name for the domain to which the backup belongs", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}:restore", +"request": { +"$ref": "RestoreDomainRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:setIamPolicy", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:testIamPermissions", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"updateLdapssettings": { +"description": "Patches a single ldaps settings.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/ldapssettings", +"httpMethod": "PATCH", +"id": "managedidentities.projects.locations.global.domains.updateLdapssettings", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The resource name of the LDAPS settings. Uses the form: `projects/{project}/locations/{location}/domains/{domain}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask of fields to update. At least one path must be supplied in this field. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1beta1/{+name}/ldapssettings", +"request": { +"$ref": "LDAPSSettings" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"validateTrust": { +"description": "Validates a trust state, that the target domain is reachable, and that the target domain is able to accept incoming trust requests.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}:validateTrust", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.validateTrust", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource domain name, project name, and location using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}:validateTrust", +"request": { +"$ref": "ValidateTrustRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"backups": { +"methods": { +"create": { +"description": "Creates a Backup for a domain.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/backups", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.backups.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"backupId": { +"description": "Required. Backup Id, unique name to identify the backups with the following restrictions: * Must be lowercase letters, numbers, and hyphens * Must start with a letter. * Must contain between 1-63 characters. * Must end with a number or a letter. * Must be unique within the domain.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+parent}/backups", +"request": { +"$ref": "Backup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes identified Backup.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}", +"httpMethod": "DELETE", +"id": "managedidentities.projects.locations.global.domains.backups.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The backup resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}/backups/{backup_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single Backup.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.backups.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The backup resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}/backups/{backup_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Backup" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}:getIamPolicy", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.backups.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists Backup in a given project.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/backups", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.backups.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filter specifying constraints of a list operation.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Specifies the ordering of results following syntax at https://cloud.google.com/apis/design/design_patterns#sorting_order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of items to return. If not specified, a default value of 1000 will be used by the service. Regardless of the page_size value, the response may include a partial list and a caller should only rely on response's next_page_token to determine if there are more instances left to be queried.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The next_page_token value returned from a previous List request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The domain resource name using the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+parent}/backups", +"response": { +"$ref": "ListBackupsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the labels for specified Backup.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}", +"httpMethod": "PATCH", +"id": "managedidentities.projects.locations.global.domains.backups.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Output only. The unique name of the Backup in the form of projects/{project_id}/locations/global/domains/{domain_name}/backups/{name}", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask of fields to update. At least one path must be supplied in this field. The elements of the repeated paths field may only include these fields from Backup: * `labels`", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"request": { +"$ref": "Backup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}:setIamPolicy", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.backups.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/backups/{backupsId}:testIamPermissions", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.domains.backups.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"sqlIntegrations": { +"methods": { +"get": { +"description": "Gets details of a single sqlIntegration.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/sqlIntegrations/{sqlIntegrationsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.sqlIntegrations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. SqlIntegration resource name using the form: `projects/{project_id}/locations/global/domains/*/sqlIntegrations/{name}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+/sqlIntegrations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "SqlIntegration" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists SqlIntegrations in a given domain.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/domains/{domainsId}/sqlIntegrations", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.domains.sqlIntegrations.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filter specifying constraints of a list operation. For example, `SqlIntegration.name=\"sql\"`.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Specifies the ordering of results following syntax at https://cloud.google.com/apis/design/design_patterns#sorting_order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of items to return. If not specified, a default value of 1000 will be used by the service. Regardless of the page_size value, the response may include a partial list and a caller should only rely on response'ANIZATIONs next_page_token to determine if there are more instances left to be queried.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The next_page_token value returned from a previous List request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource name of the SqlIntegrations using the form: `projects/{project_id}/locations/global/domains/*`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/domains/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+parent}/sqlIntegrations", +"response": { +"$ref": "ListSqlIntegrationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +}, +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}:cancel", +"request": { +"$ref": "CancelOperationRequest" +}, +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "managedidentities.projects.locations.global.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/operations/{operationsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/operations", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/operations$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"peerings": { +"methods": { +"create": { +"description": "Creates a Peering for Managed AD instance.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/peerings", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.peerings.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. Resource project name and location using the form: `projects/{project_id}/locations/global`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +}, +"peeringId": { +"description": "Required. Peering Id, unique name to identify peering.", +"location": "query", +"type": "string" +} +}, +"path": "v1beta1/{+parent}/peerings", +"request": { +"$ref": "Peering" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes identified Peering.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/peerings/{peeringsId}", +"httpMethod": "DELETE", +"id": "managedidentities.projects.locations.global.peerings.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Peering resource name using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single Peering.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/peerings/{peeringsId}", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.peerings.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Peering resource name using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"response": { +"$ref": "Peering" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/peerings/{peeringsId}:getIamPolicy", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.peerings.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists Peerings in a given project.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/peerings", +"httpMethod": "GET", +"id": "managedidentities.projects.locations.global.peerings.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filter specifying constraints of a list operation. For example, `peering.authoized_network =\"/projects/myprojectid\"`.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Specifies the ordering of results following syntax at https://cloud.google.com/apis/design/design_patterns#sorting_order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of items to return. If not specified, a default value of 1000 will be used by the service. Regardless of the page_size value, the response may include a partial list and a caller should only rely on response's next_page_token to determine if there are more instances left to be queried.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The next_page_token value returned from a previous List request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource name of the domain location using the form: `projects/{project_id}/locations/global`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+parent}/peerings", +"response": { +"$ref": "ListPeeringsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the labels for specified Peering.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/peerings/{peeringsId}", +"httpMethod": "PATCH", +"id": "managedidentities.projects.locations.global.peerings.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Output only. Unique name of the peering in this scope including projects and location using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask of fields to update. At least one path must be supplied in this field. The elements of the repeated paths field may only include these fields from Peering: * `labels`", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1beta1/{+name}", +"request": { +"$ref": "Peering" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/peerings/{peeringsId}:setIamPolicy", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.peerings.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1beta1/projects/{projectsId}/locations/global/peerings/{peeringsId}:testIamPermissions", +"httpMethod": "POST", +"id": "managedidentities.projects.locations.global.peerings.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/peerings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +} +} +} +} +}, +"revision": "20240530", +"rootUrl": "https://managedidentities.googleapis.com/", +"schemas": { +"AttachTrustRequest": { +"description": "Request message for AttachTrust", +"id": "AttachTrustRequest", +"properties": { +"trust": { +"$ref": "Trust", +"description": "Required. The domain trust resource." +} +}, +"type": "object" +}, +"Backup": { +"description": "Represents a Managed Microsoft Identities backup.", +"id": "Backup", +"properties": { +"createTime": { +"description": "Output only. The time the backups was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. A short description of the backup.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels to represent user provided metadata.", +"type": "object" +}, +"name": { +"description": "Output only. The unique name of the Backup in the form of projects/{project_id}/locations/global/domains/{domain_name}/backups/{name}", +"readOnly": true, +"type": "string" +}, +"state": { +"description": "Output only. The current state of the backup.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"FAILED", +"DELETING" +], +"enumDescriptions": [ +"Not set.", +"Backup is being created.", +"Backup has been created and validated.", +"Backup has been created but failed validation.", +"Backup is being deleted." +], +"readOnly": true, +"type": "string" +}, +"statusMessage": { +"description": "Output only. Additional information about the current status of this backup, if available.", +"readOnly": true, +"type": "string" +}, +"type": { +"description": "Output only. Indicates whether it\u2019s an on-demand backup or scheduled.", +"enum": [ +"TYPE_UNSPECIFIED", +"ON_DEMAND", +"SCHEDULED", +"SCHEMA_EXTENSION" +], +"enumDescriptions": [ +"Backup type not specified.", +"Backup was manually created.", +"Backup was automatically created.", +"Backup was taken as part of Schema Extension request." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Binding": { +"description": "Associates `members`, or principals, with a `role`.", +"id": "Binding", +"properties": { +"condition": { +"$ref": "Expr", +"description": "The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies)." +}, +"members": { +"description": "Specifies the principals requesting access for a Google Cloud resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workforce identity pool. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/group/{group_id}`: All workforce identities in a group. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All workforce identities with a specific attribute value. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/*`: All identities in a workforce identity pool. * `principal://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workload identity pool. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/group/{group_id}`: A workload identity pool group. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All identities in a workload identity pool with a certain attribute. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/*`: All identities in a workload identity pool. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: Deleted single identity in a workforce identity pool. For example, `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-pool-id/subject/my-subject-attribute-value`.", +"items": { +"type": "string" +}, +"type": "array" +}, +"role": { +"description": "Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview of the IAM roles and permissions, see the [IAM documentation](https://cloud.google.com/iam/docs/roles-overview). For a list of the available pre-defined roles, see [here](https://cloud.google.com/iam/docs/understanding-roles).", +"type": "string" +} +}, +"type": "object" +}, +"CancelOperationRequest": { +"description": "The request message for Operations.CancelOperation.", +"id": "CancelOperationRequest", +"properties": {}, +"type": "object" +}, +"Certificate": { +"description": "Certificate used to configure LDAPS.", +"id": "Certificate", +"properties": { +"expireTime": { +"description": "The certificate expire time.", +"format": "google-datetime", +"type": "string" +}, +"issuingCertificate": { +"$ref": "Certificate", +"description": "The issuer of this certificate." +}, +"subject": { +"description": "The certificate subject.", +"type": "string" +}, +"subjectAlternativeName": { +"description": "The additional hostnames for the domain.", +"items": { +"type": "string" +}, +"type": "array" +}, +"thumbprint": { +"description": "The certificate thumbprint which uniquely identifies the certificate.", +"type": "string" +} +}, +"type": "object" +}, +"CheckMigrationPermissionRequest": { +"description": "CheckMigrationPermissionRequest is the request message for CheckMigrationPermission method.", +"id": "CheckMigrationPermissionRequest", +"properties": {}, +"type": "object" +}, +"CheckMigrationPermissionResponse": { +"description": "CheckMigrationPermissionResponse is the response message for CheckMigrationPermission method.", +"id": "CheckMigrationPermissionResponse", +"properties": { +"onpremDomains": { +"description": "The state of SID filtering of all the domains which has trust established.", +"items": { +"$ref": "OnPremDomainSIDDetails" +}, +"type": "array" +}, +"state": { +"description": "The state of DomainMigration.", +"enum": [ +"STATE_UNSPECIFIED", +"DISABLED", +"ENABLED", +"NEEDS_MAINTENANCE" +], +"enumDescriptions": [ +"DomainMigration is in unspecified state.", +"Domain Migration is Disabled.", +"Domain Migration is Enabled.", +"Domain Migration is not in valid state." +], +"type": "string" +} +}, +"type": "object" +}, +"DailyCycle": { +"description": "Time window specified for daily operations.", +"id": "DailyCycle", +"properties": { +"duration": { +"description": "Output only. Duration of the time window, set by service producer.", +"format": "google-duration", +"type": "string" +}, +"startTime": { +"$ref": "TimeOfDay", +"description": "Time within the day to start the operations." +} +}, +"type": "object" +}, +"Date": { +"description": "Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp", +"id": "Date", +"properties": { +"day": { +"description": "Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.", +"format": "int32", +"type": "integer" +}, +"month": { +"description": "Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.", +"format": "int32", +"type": "integer" +}, +"year": { +"description": "Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"DenyMaintenancePeriod": { +"description": "DenyMaintenancePeriod definition. Maintenance is forbidden within the deny period. The start_date must be less than the end_date.", +"id": "DenyMaintenancePeriod", +"properties": { +"endDate": { +"$ref": "Date", +"description": "Deny period end date. This can be: * A full date, with non-zero year, month and day values. * A month and day value, with a zero year. Allows recurring deny periods each year. Date matching this period will have to be before the end." +}, +"startDate": { +"$ref": "Date", +"description": "Deny period start date. This can be: * A full date, with non-zero year, month and day values. * A month and day value, with a zero year. Allows recurring deny periods each year. Date matching this period will have to be the same or after the start." +}, +"time": { +"$ref": "TimeOfDay", +"description": "Time in UTC when the Blackout period starts on start_date and ends on end_date. This can be: * Full time. * All zeros for 00:00:00 UTC" +} +}, +"type": "object" +}, +"DetachTrustRequest": { +"description": "Request message for DetachTrust", +"id": "DetachTrustRequest", +"properties": { +"trust": { +"$ref": "Trust", +"description": "Required. The domain trust resource to removed." +} +}, +"type": "object" +}, +"DisableMigrationRequest": { +"description": "DisableMigrationRequest is the request message for DisableMigration method.", +"id": "DisableMigrationRequest", +"properties": {}, +"type": "object" +}, +"Domain": { +"description": "Represents a managed Microsoft Active Directory domain. If the domain is being changed, it will be placed into the UPDATING state, which indicates that the resource is being reconciled. At this point, Get will reflect an intermediate state.", +"id": "Domain", +"properties": { +"admin": { +"description": "Optional. The name of delegated administrator account used to perform Active Directory operations. If not specified, `setupadmin` will be used.", +"type": "string" +}, +"auditLogsEnabled": { +"description": "Optional. Configuration for audit logs. True if audit logs are enabled, else false. Default is audit logs disabled.", +"type": "boolean" +}, +"authorizedNetworks": { +"description": "Optional. The full names of the Google Compute Engine [networks](/compute/docs/networks-and-firewalls#networks) the domain instance is connected to. Networks can be added using UpdateDomain. The domain is only available on networks listed in `authorized_networks`. If CIDR subnets overlap between networks, domain creation will fail.", +"items": { +"type": "string" +}, +"type": "array" +}, +"createTime": { +"description": "Output only. The time the instance was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"fqdn": { +"description": "Output only. The fully-qualified domain name of the exposed domain used by clients to connect to the service. Similar to what would be chosen for an Active Directory set up on an internal network.", +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels that can contain user-provided metadata.", +"type": "object" +}, +"locations": { +"description": "Required. Locations where domain needs to be provisioned. regions e.g. us-west1 or us-east4 Service supports up to 4 locations at once. Each location will use a /26 block.", +"items": { +"type": "string" +}, +"type": "array" +}, +"name": { +"description": "Output only. The unique name of the domain using the form: `projects/{project_id}/locations/global/domains/{domain_name}`.", +"readOnly": true, +"type": "string" +}, +"reservedIpRange": { +"description": "Required. The CIDR range of internal addresses that are reserved for this domain. Reserved networks must be /24 or larger. Ranges must be unique and non-overlapping with existing subnets in [Domain].[authorized_networks].", +"type": "string" +}, +"state": { +"description": "Output only. The current state of this domain.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY", +"UPDATING", +"DELETING", +"REPAIRING", +"PERFORMING_MAINTENANCE", +"UNAVAILABLE" +], +"enumDescriptions": [ +"Not set.", +"The domain is being created.", +"The domain has been created and is fully usable.", +"The domain's configuration is being updated.", +"The domain is being deleted.", +"The domain is being repaired and may be unusable. Details can be found in the `status_message` field.", +"The domain is undergoing maintenance.", +"The domain is not serving requests." +], +"readOnly": true, +"type": "string" +}, +"statusMessage": { +"description": "Output only. Additional information about the current status of this domain, if available.", +"readOnly": true, +"type": "string" +}, +"trusts": { +"description": "Output only. The current trusts associated with the domain.", +"items": { +"$ref": "Trust" +}, +"readOnly": true, +"type": "array" +}, +"updateTime": { +"description": "Output only. The last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"DomainJoinMachineRequest": { +"description": "DomainJoinMachineRequest is the request message for DomainJoinMachine method", +"id": "DomainJoinMachineRequest", +"properties": { +"force": { +"description": "Optional. force if True, forces domain join even if the computer account already exists.", +"type": "boolean" +}, +"ouName": { +"description": "Optional. OU name to which the VM needs to be domain joined. If the field is not provided, the VM is joined to the default OU which is created. The default OU for the domain join api is created as GCE Instances under the Cloud OU. Example - OU=GCE Instances,OU=Cloud,DC=ad,DC=test,DC=com If the field is provided, then the custom OU is searched for under GCE Instances OU. Example - if ou_name=test_ou then the VM is domain joined to the following OU: OU=test_ou,OU=GCE Instances,OU=Cloud,DC=ad,DC=test,DC=com if present. If OU is not present under GCE Instances, then error is returned.", +"type": "string" +}, +"vmIdToken": { +"description": "Required. Full instance id token of compute engine VM to verify instance identity. More about this: https://cloud.google.com/compute/docs/instances/verifying-instance-identity#request_signature", +"type": "string" +} +}, +"type": "object" +}, +"DomainJoinMachineResponse": { +"description": "DomainJoinMachineResponse is the response message for DomainJoinMachine method", +"id": "DomainJoinMachineResponse", +"properties": { +"domainJoinBlob": { +"description": "The response is the offline domain join blob that is returned after running the djoin command. To correctly use the response of the API, please refer to the sample usage.", +"type": "string" +} +}, +"type": "object" +}, +"Empty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "Empty", +"properties": {}, +"type": "object" +}, +"EnableMigrationRequest": { +"description": "EnableMigrationRequest is the request message for EnableMigration method.", +"id": "EnableMigrationRequest", +"properties": { +"enableDuration": { +"description": "Optional. Period after which the migration would be auto disabled. If unspecified, a default timeout of 48h is used.", +"format": "google-duration", +"type": "string" +}, +"migratingDomains": { +"description": "Required. List of the on-prem domains to be migrated.", +"items": { +"$ref": "OnPremDomainDetails" +}, +"type": "array" +} +}, +"type": "object" +}, +"Expr": { +"description": "Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() < 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != 'private' && document.type != 'internal'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"'New message received at ' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.", +"id": "Expr", +"properties": { +"description": { +"description": "Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.", +"type": "string" +}, +"expression": { +"description": "Textual representation of an expression in Common Expression Language syntax.", +"type": "string" +}, +"location": { +"description": "Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.", +"type": "string" +}, +"title": { +"description": "Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.", +"type": "string" +} +}, +"type": "object" +}, +"ExtendSchemaRequest": { +"description": "ExtendSchemaRequest is the request message for ExtendSchema method.", +"id": "ExtendSchemaRequest", +"properties": { +"description": { +"description": "Required. Description for Schema Change.", +"type": "string" +}, +"fileContents": { +"description": "File uploaded as a byte stream input.", +"format": "byte", +"type": "string" +}, +"gcsPath": { +"description": "File stored in Cloud Storage bucket and represented in the form projects/{project_id}/buckets/{bucket_name}/objects/{object_name} File should be in the same project as the domain.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudManagedidentitiesV1OpMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "GoogleCloudManagedidentitiesV1OpMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"requestedCancellation": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudManagedidentitiesV1alpha1OpMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "GoogleCloudManagedidentitiesV1alpha1OpMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"requestedCancellation": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudManagedidentitiesV1beta1OpMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "GoogleCloudManagedidentitiesV1beta1OpMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"requestedCancellation": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1Instance": { +"description": "Instance represents the interface for SLM services to actuate the state of control plane resources. Example Instance in JSON, where consumer-project-number=123456, producer-project-id=cloud-sql: ```json Instance: { \"name\": \"projects/123456/locations/us-east1/instances/prod-instance\", \"create_time\": { \"seconds\": 1526406431, }, \"labels\": { \"env\": \"prod\", \"foo\": \"bar\" }, \"state\": READY, \"software_versions\": { \"software_update\": \"cloud-sql-09-28-2018\", }, \"maintenance_policy_names\": { \"UpdatePolicy\": \"projects/123456/locations/us-east1/maintenancePolicies/prod-update-policy\", } \"tenant_project_id\": \"cloud-sql-test-tenant\", \"producer_metadata\": { \"cloud-sql-tier\": \"basic\", \"cloud-sql-instance-size\": \"1G\", }, \"provisioned_resources\": [ { \"resource-type\": \"compute-instance\", \"resource-url\": \"https://www.googleapis.com/compute/v1/projects/cloud-sql/zones/us-east1-b/instances/vm-1\", } ], \"maintenance_schedules\": { \"csa_rollout\": { \"start_time\": { \"seconds\": 1526406431, }, \"end_time\": { \"seconds\": 1535406431, }, }, \"ncsa_rollout\": { \"start_time\": { \"seconds\": 1526406431, }, \"end_time\": { \"seconds\": 1535406431, }, } }, \"consumer_defined_name\": \"my-sql-instance1\", } ``` LINT.IfChange", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1Instance", +"properties": { +"consumerDefinedName": { +"description": "consumer_defined_name is the name of the instance set by the service consumers. Generally this is different from the `name` field which reperesents the system-assigned id of the instance which the service consumers do not recognize. This is a required field for tenants onboarding to Maintenance Window notifications (go/slm-rollout-maintenance-policies#prerequisites).", +"type": "string" +}, +"createTime": { +"description": "Output only. Timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"instanceType": { +"description": "Optional. The instance_type of this instance of format: projects/{project_number}/locations/{location_id}/instanceTypes/{instance_type_id}. Instance Type represents a high-level tier or SKU of the service that this instance belong to. When enabled(eg: Maintenance Rollout), Rollout uses 'instance_type' along with 'software_versions' to determine whether instance needs an update or not.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels to represent user provided metadata. Each label is a key-value pair, where both the key and the value are arbitrary strings provided by the user.", +"type": "object" +}, +"maintenancePolicyNames": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. The MaintenancePolicies that have been attached to the instance. The key must be of the type name of the oneof policy name defined in MaintenancePolicy, and the referenced policy must define the same policy type. For details, please refer to go/mr-user-guide. Should not be set if maintenance_settings.maintenance_policies is set.", +"type": "object" +}, +"maintenanceSchedules": { +"additionalProperties": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSchedule" +}, +"description": "The MaintenanceSchedule contains the scheduling information of published maintenance schedule with same key as software_versions.", +"type": "object" +}, +"maintenanceSettings": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSettings", +"description": "Optional. The MaintenanceSettings associated with instance." +}, +"name": { +"description": "Unique name of the resource. It uses the form: `projects/{project_number}/locations/{location_id}/instances/{instance_id}` Note: This name is passed, stored and logged across the rollout system. So use of consumer project_id or any other consumer PII in the name is strongly discouraged for wipeout (go/wipeout) compliance. See go/elysium/project_ids#storage-guidance for more details.", +"type": "string" +}, +"notificationParameters": { +"additionalProperties": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1NotificationParameter" +}, +"description": "Optional. notification_parameter are information that service producers may like to include that is not relevant to Rollout. This parameter will only be passed to Gamma and Cloud Logging for notification/logging purpose.", +"type": "object" +}, +"producerMetadata": { +"additionalProperties": { +"type": "string" +}, +"description": "Output only. Custom string attributes used primarily to expose producer-specific information in monitoring dashboards. See go/get-instance-metadata.", +"readOnly": true, +"type": "object" +}, +"provisionedResources": { +"description": "Output only. The list of data plane resources provisioned for this instance, e.g. compute VMs. See go/get-instance-metadata.", +"items": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1ProvisionedResource" +}, +"readOnly": true, +"type": "array" +}, +"slmInstanceTemplate": { +"description": "Link to the SLM instance template. Only populated when updating SLM instances via SSA's Actuation service adaptor. Service producers with custom control plane (e.g. Cloud SQL) doesn't need to populate this field. Instead they should use software_versions.", +"type": "string" +}, +"sloMetadata": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1SloMetadata", +"description": "Output only. SLO metadata for instance classification in the Standardized dataplane SLO platform. See go/cloud-ssa-standard-slo for feature description.", +"readOnly": true +}, +"softwareVersions": { +"additionalProperties": { +"type": "string" +}, +"description": "Software versions that are used to deploy this instance. This can be mutated by rollout services.", +"type": "object" +}, +"state": { +"description": "Output only. Current lifecycle state of the resource (e.g. if it's being created or ready to use).", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY", +"UPDATING", +"REPAIRING", +"DELETING", +"ERROR" +], +"enumDescriptions": [ +"Unspecified state.", +"Instance is being created.", +"Instance has been created and is ready to use.", +"Instance is being updated.", +"Instance is unheathy and under repair.", +"Instance is being deleted.", +"Instance encountered an error and is in indeterministic state." +], +"readOnly": true, +"type": "string" +}, +"tenantProjectId": { +"description": "Output only. ID of the associated GCP tenant project. See go/get-instance-metadata.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Timestamp when the resource was last modified.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSchedule": { +"description": "Maintenance schedule which is exposed to customer and potentially end user, indicating published upcoming future maintenance schedule", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSchedule", +"properties": { +"canReschedule": { +"deprecated": true, +"description": "This field is deprecated, and will be always set to true since reschedule can happen multiple times now. This field should not be removed until all service producers remove this for their customers.", +"type": "boolean" +}, +"endTime": { +"description": "The scheduled end time for the maintenance.", +"format": "google-datetime", +"type": "string" +}, +"rolloutManagementPolicy": { +"description": "The rollout management policy this maintenance schedule is associated with. When doing reschedule update request, the reschedule should be against this given policy.", +"type": "string" +}, +"scheduleDeadlineTime": { +"description": "schedule_deadline_time is the time deadline any schedule start time cannot go beyond, including reschedule. It's normally the initial schedule start time plus maintenance window length (1 day or 1 week). Maintenance cannot be scheduled to start beyond this deadline.", +"format": "google-datetime", +"type": "string" +}, +"startTime": { +"description": "The scheduled start time for the maintenance.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSettings": { +"description": "Maintenance settings associated with instance. Allows service producers and end users to assign settings that controls maintenance on this instance.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1MaintenanceSettings", +"properties": { +"exclude": { +"description": "Optional. Exclude instance from maintenance. When true, rollout service will not attempt maintenance on the instance. Rollout service will include the instance in reported rollout progress as not attempted.", +"type": "boolean" +}, +"isRollback": { +"description": "Optional. If the update call is triggered from rollback, set the value as true.", +"type": "boolean" +}, +"maintenancePolicies": { +"additionalProperties": { +"$ref": "MaintenancePolicy" +}, +"description": "Optional. The MaintenancePolicies that have been attached to the instance. The key must be of the type name of the oneof policy name defined in MaintenancePolicy, and the embedded policy must define the same policy type. For details, please refer to go/mr-user-guide. Should not be set if maintenance_policy_names is set. If only the name is needed, then only populate MaintenancePolicy.name.", +"type": "object" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1NodeSloMetadata": { +"description": "Node information for custom per-node SLO implementations. SSA does not support per-node SLO, but producers can populate per-node information in SloMetadata for custom precomputations. SSA Eligibility Exporter will emit per-node metric based on this information.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1NodeSloMetadata", +"properties": { +"location": { +"description": "The location of the node, if different from instance location.", +"type": "string" +}, +"nodeId": { +"description": "The id of the node. This should be equal to SaasInstanceNode.node_id.", +"type": "string" +}, +"perSliEligibility": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1PerSliSloEligibility", +"description": "If present, this will override eligibility for the node coming from instance or exclusions for specified SLIs." +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1NotificationParameter": { +"description": "Contains notification related data.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1NotificationParameter", +"properties": { +"values": { +"description": "Optional. Array of string values. e.g. instance's replica information.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1PerSliSloEligibility": { +"description": "PerSliSloEligibility is a mapping from an SLI name to eligibility.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1PerSliSloEligibility", +"properties": { +"eligibilities": { +"additionalProperties": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1SloEligibility" +}, +"description": "An entry in the eligibilities map specifies an eligibility for a particular SLI for the given instance. The SLI key in the name must be a valid SLI name specified in the Eligibility Exporter binary flags otherwise an error will be emitted by Eligibility Exporter and the oncaller will be alerted. If an SLI has been defined in the binary flags but the eligibilities map does not contain it, the corresponding SLI time series will not be emitted by the Eligibility Exporter. This ensures a smooth rollout and compatibility between the data produced by different versions of the Eligibility Exporters. If eligibilities map contains a key for an SLI which has not been declared in the binary flags, there will be an error message emitted in the Eligibility Exporter log and the metric for the SLI in question will not be emitted.", +"type": "object" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1ProvisionedResource": { +"description": "Describes provisioned dataplane resources.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1ProvisionedResource", +"properties": { +"resourceType": { +"description": "Type of the resource. This can be either a GCP resource or a custom one (e.g. another cloud provider's VM). For GCP compute resources use singular form of the names listed in GCP compute API documentation (https://cloud.google.com/compute/docs/reference/rest/v1/), prefixed with 'compute-', for example: 'compute-instance', 'compute-disk', 'compute-autoscaler'.", +"type": "string" +}, +"resourceUrl": { +"description": "URL identifying the resource, e.g. \"https://www.googleapis.com/compute/v1/projects/...)\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1SloEligibility": { +"description": "SloEligibility is a tuple containing eligibility value: true if an instance is eligible for SLO calculation or false if it should be excluded from all SLO-related calculations along with a user-defined reason.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1SloEligibility", +"properties": { +"eligible": { +"description": "Whether an instance is eligible or ineligible.", +"type": "boolean" +}, +"reason": { +"description": "User-defined reason for the current value of instance eligibility. Usually, this can be directly mapped to the internal state. An empty reason is allowed.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudSaasacceleratorManagementProvidersV1SloMetadata": { +"description": "SloMetadata contains resources required for proper SLO classification of the instance.", +"id": "GoogleCloudSaasacceleratorManagementProvidersV1SloMetadata", +"properties": { +"nodes": { +"description": "Optional. List of nodes. Some producers need to use per-node metadata to calculate SLO. This field allows such producers to publish per-node SLO meta data, which will be consumed by SSA Eligibility Exporter and published in the form of per node metric to Monarch.", +"items": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1NodeSloMetadata" +}, +"type": "array" +}, +"perSliEligibility": { +"$ref": "GoogleCloudSaasacceleratorManagementProvidersV1PerSliSloEligibility", +"description": "Optional. Multiple per-instance SLI eligibilities which apply for individual SLIs." +}, +"tier": { +"description": "Name of the SLO tier the Instance belongs to. This name will be expected to match the tiers specified in the service SLO configuration. Field is mandatory and must not be empty.", +"type": "string" +} +}, +"type": "object" +}, +"LDAPSSettings": { +"description": "LDAPSSettings represents the ldaps settings for domain resource. LDAP is the Lightweight Directory Access Protocol, defined in https://tools.ietf.org/html/rfc4511. The settings object configures LDAP over SSL/TLS, whether it is over port 636 or the StartTLS operation. If LDAPSSettings is being changed, it will be placed into the UPDATING state, which indicates that the resource is being reconciled. At this point, Get will reflect an intermediate state.", +"id": "LDAPSSettings", +"properties": { +"certificate": { +"$ref": "Certificate", +"description": "Output only. The certificate used to configure LDAPS. Certificates can be chained with a maximum length of 15.", +"readOnly": true +}, +"certificatePassword": { +"description": "Input only. The password used to encrypt the uploaded pfx certificate.", +"type": "string" +}, +"certificatePfx": { +"description": "Input only. The uploaded PKCS12-formatted certificate to configure LDAPS with. It will enable the domain controllers in this domain to accept LDAPS connections (either LDAP over SSL/TLS or the StartTLS operation). A valid certificate chain must form a valid x.509 certificate chain (or be comprised of a single self-signed certificate. It must be encrypted with either: 1) PBES2 + PBKDF2 + AES256 encryption and SHA256 PRF; or 2) pbeWithSHA1And3-KeyTripleDES-CBC Private key must be included for the leaf / single self-signed certificate. Note: For a fqdn your-example-domain.com, the wildcard fqdn is *.your-example-domain.com. Specifically the leaf certificate must have: - Either a blank subject or a subject with CN matching the wildcard fqdn. - Exactly two SANs - the fqdn and wildcard fqdn. - Encipherment and digital key signature key usages. - Server authentication extended key usage (OID=1.3.6.1.5.5.7.3.1) - Private key must be in one of the following formats: RSA, ECDSA, ED25519. - Private key must have appropriate key length: 2048 for RSA, 256 for ECDSA - Signature algorithm of the leaf certificate cannot be MD2, MD5 or SHA1.", +"format": "byte", +"type": "string" +}, +"name": { +"description": "The resource name of the LDAPS settings. Uses the form: `projects/{project}/locations/{location}/domains/{domain}`.", +"type": "string" +}, +"state": { +"description": "Output only. The current state of this LDAPS settings.", +"enum": [ +"STATE_UNSPECIFIED", +"UPDATING", +"ACTIVE", +"FAILED" +], +"enumDescriptions": [ +"Not Set", +"The LDAPS setting is being updated.", +"The LDAPS setting is ready.", +"The LDAPS setting is not applied correctly." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ListBackupsResponse": { +"description": "ListBackupsResponse is the response message for ListBackups method.", +"id": "ListBackupsResponse", +"properties": { +"backups": { +"description": "A list of Cloud AD backups in the domain.", +"items": { +"$ref": "Backup" +}, +"type": "array" +}, +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListDomainsResponse": { +"description": "Response message for ListDomains", +"id": "ListDomainsResponse", +"properties": { +"domains": { +"description": "A list of Managed Identities Service domains in the project.", +"items": { +"$ref": "Domain" +}, +"type": "array" +}, +"nextPageToken": { +"description": "A token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"unreachable": { +"description": "A list of locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListLocationsResponse": { +"description": "The response message for Locations.ListLocations.", +"id": "ListLocationsResponse", +"properties": { +"locations": { +"description": "A list of locations that matches the specified filter in the request.", +"items": { +"$ref": "Location" +}, +"type": "array" +}, +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +} +}, +"type": "object" +}, +"ListOperationsResponse": { +"description": "The response message for Operations.ListOperations.", +"id": "ListOperationsResponse", +"properties": { +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +}, +"operations": { +"description": "A list of operations that matches the specified filter in the request.", +"items": { +"$ref": "Operation" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListPeeringsResponse": { +"description": "ListPeeringsResponse is the response message for ListPeerings method.", +"id": "ListPeeringsResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"peerings": { +"description": "A list of Managed Identities Service Peerings in the project.", +"items": { +"$ref": "Peering" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListSqlIntegrationsResponse": { +"description": "ListSqlIntegrationsResponse is the response message for ListSqlIntegrations method.", +"id": "ListSqlIntegrationsResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"sqlIntegrations": { +"description": "A list of SqlIntegrations of a domain.", +"items": { +"$ref": "SqlIntegration" +}, +"type": "array" +}, +"unreachable": { +"description": "A list of locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Location": { +"description": "A resource that represents a Google Cloud location.", +"id": "Location", +"properties": { +"displayName": { +"description": "The friendly name for this location, typically a nearby city name. For example, \"Tokyo\".", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Cross-service attributes for the location. For example {\"cloud.googleapis.com/region\": \"us-east1\"}", +"type": "object" +}, +"locationId": { +"description": "The canonical id for this location. For example: `\"us-east1\"`.", +"type": "string" +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata. For example the available capacity at the given location.", +"type": "object" +}, +"name": { +"description": "Resource name for the location, which may vary between implementations. For example: `\"projects/example-project/locations/us-east1\"`", +"type": "string" +} +}, +"type": "object" +}, +"MaintenancePolicy": { +"description": "Defines policies to service maintenance events.", +"id": "MaintenancePolicy", +"properties": { +"createTime": { +"description": "Output only. The time when the resource was created.", +"format": "google-datetime", +"type": "string" +}, +"description": { +"description": "Optional. Description of what this policy is for. Create/Update methods return INVALID_ARGUMENT if the length is greater than 512.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels to represent user provided metadata. Each label is a key-value pair, where both the key and the value are arbitrary strings provided by the user.", +"type": "object" +}, +"name": { +"description": "Required. MaintenancePolicy name using the form: `projects/{project_id}/locations/{location_id}/maintenancePolicies/{maintenance_policy_id}` where {project_id} refers to a GCP consumer project ID, {location_id} refers to a GCP region/zone, {maintenance_policy_id} must be 1-63 characters long and match the regular expression `[a-z0-9]([-a-z0-9]*[a-z0-9])?`.", +"type": "string" +}, +"state": { +"description": "Optional. The state of the policy.", +"enum": [ +"STATE_UNSPECIFIED", +"READY", +"DELETING" +], +"enumDescriptions": [ +"Unspecified state.", +"Resource is ready to be used.", +"Resource is being deleted. It can no longer be attached to instances." +], +"type": "string" +}, +"updatePolicy": { +"$ref": "UpdatePolicy", +"description": "Maintenance policy applicable to instance update." +}, +"updateTime": { +"description": "Output only. The time when the resource was updated.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"MaintenanceWindow": { +"description": "MaintenanceWindow definition.", +"id": "MaintenanceWindow", +"properties": { +"dailyCycle": { +"$ref": "DailyCycle", +"description": "Daily cycle." +}, +"weeklyCycle": { +"$ref": "WeeklyCycle", +"description": "Weekly cycle." +} +}, +"type": "object" +}, +"OnPremDomainDetails": { +"description": "OnPremDomainDetails is the message which contains details of on-prem domain which is trusted and needs to be migrated.", +"id": "OnPremDomainDetails", +"properties": { +"disableSidFiltering": { +"description": "Optional. Option to disable SID filtering.", +"type": "boolean" +}, +"domainName": { +"description": "Required. FQDN of the on-prem domain being migrated.", +"type": "string" +} +}, +"type": "object" +}, +"OnPremDomainSIDDetails": { +"description": "OnPremDomainDetails is the message which contains details of on-prem domain which is trusted and needs to be migrated.", +"id": "OnPremDomainSIDDetails", +"properties": { +"name": { +"description": "FQDN of the on-prem domain being migrated.", +"type": "string" +}, +"sidFilteringState": { +"description": "Current SID filtering state.", +"enum": [ +"SID_FILTERING_STATE_UNSPECIFIED", +"ENABLED", +"DISABLED" +], +"enumDescriptions": [ +"SID Filtering is in unspecified state.", +"SID Filtering is Enabled.", +"SID Filtering is Disabled." +], +"type": "string" +} +}, +"type": "object" +}, +"Operation": { +"description": "This resource represents a long-running operation that is the result of a network API call.", +"id": "Operation", +"properties": { +"done": { +"description": "If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.", +"type": "boolean" +}, +"error": { +"$ref": "Status", +"description": "The error result of the operation in case of failure or cancellation." +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.", +"type": "object" +}, +"name": { +"description": "The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.", +"type": "string" +}, +"response": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.", +"type": "object" +} +}, +"type": "object" +}, +"OperationMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "OperationMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"cancelRequested": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have been cancelled successfully have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"statusDetail": { +"description": "Output only. Human-readable status of the operation, if any.", +"readOnly": true, +"type": "string" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Peering": { +"description": "Represents a Managed Microsoft Identities Peering.", +"id": "Peering", +"properties": { +"authorizedNetwork": { +"description": "Required. The full names of the Google Compute Engine [networks](/compute/docs/networks-and-firewalls#networks) to which the instance is connected. Caller needs to make sure that CIDR subnets do not overlap between networks, else peering creation will fail.", +"type": "string" +}, +"createTime": { +"description": "Output only. The time the instance was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"domainResource": { +"description": "Required. Full domain resource path for the Managed AD Domain involved in peering. The resource path should be in the form: `projects/{project_id}/locations/global/domains/{domain_name}`", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Resource labels to represent user provided metadata.", +"type": "object" +}, +"name": { +"description": "Output only. Unique name of the peering in this scope including projects and location using the form: `projects/{project_id}/locations/global/peerings/{peering_id}`.", +"readOnly": true, +"type": "string" +}, +"state": { +"description": "Output only. The current state of this Peering.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"CONNECTED", +"DISCONNECTED", +"DELETING" +], +"enumDescriptions": [ +"Not set.", +"Peering is being created.", +"Peering is connected.", +"Peering is disconnected.", +"Peering is being deleted." +], +"readOnly": true, +"type": "string" +}, +"statusMessage": { +"description": "Output only. Additional information about the current status of this peering, if available.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Policy": { +"description": "An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** ``` { \"bindings\": [ { \"role\": \"roles/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike@example.com\", \"group:admins@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles/resourcemanager.organizationViewer\", \"members\": [ \"user:eve@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time < timestamp('2020-10-01T00:00:00.000Z')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 } ``` **YAML example:** ``` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 ``` For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).", +"id": "Policy", +"properties": { +"bindings": { +"description": "Associates a list of `members`, or principals, with a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one principal. The `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of these principals can be Google groups. Each occurrence of a principal counts towards these limits. For example, if the `bindings` grant 50 different roles to `user:alice@example.com`, and not to any other principal, then you can add another 1,450 principals to the `bindings` in the `Policy`.", +"items": { +"$ref": "Binding" +}, +"type": "array" +}, +"etag": { +"description": "`etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.", +"format": "byte", +"type": "string" +}, +"version": { +"description": "Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"ReconfigureTrustRequest": { +"description": "Request message for ReconfigureTrust", +"id": "ReconfigureTrustRequest", +"properties": { +"targetDnsIpAddresses": { +"description": "Required. The target DNS server IP addresses to resolve the remote domain involved in the trust.", +"items": { +"type": "string" +}, +"type": "array" +}, +"targetDomainName": { +"description": "Required. The fully-qualified target domain name which will be in trust with current domain.", +"type": "string" +} +}, +"type": "object" +}, +"ResetAdminPasswordRequest": { +"description": "Request message for ResetAdminPassword", +"id": "ResetAdminPasswordRequest", +"properties": {}, +"type": "object" +}, +"ResetAdminPasswordResponse": { +"description": "Response message for ResetAdminPassword", +"id": "ResetAdminPasswordResponse", +"properties": { +"password": { +"description": "A random password. See admin for more information.", +"type": "string" +} +}, +"type": "object" +}, +"RestoreDomainRequest": { +"description": "RestoreDomainRequest is the request received by RestoreDomain rpc", +"id": "RestoreDomainRequest", +"properties": { +"backupId": { +"description": "Required. ID of the backup to be restored", +"type": "string" +} +}, +"type": "object" +}, +"Schedule": { +"description": "Configure the schedule.", +"id": "Schedule", +"properties": { +"day": { +"description": "Allows to define schedule that runs specified day of the week.", +"enum": [ +"DAY_OF_WEEK_UNSPECIFIED", +"MONDAY", +"TUESDAY", +"WEDNESDAY", +"THURSDAY", +"FRIDAY", +"SATURDAY", +"SUNDAY" +], +"enumDescriptions": [ +"The day of the week is unspecified.", +"Monday", +"Tuesday", +"Wednesday", +"Thursday", +"Friday", +"Saturday", +"Sunday" +], +"type": "string" +}, +"duration": { +"description": "Output only. Duration of the time window, set by service producer.", +"format": "google-duration", +"type": "string" +}, +"startTime": { +"$ref": "TimeOfDay", +"description": "Time within the window to start the operations." +} +}, +"type": "object" +}, +"SetIamPolicyRequest": { +"description": "Request message for `SetIamPolicy` method.", +"id": "SetIamPolicyRequest", +"properties": { +"policy": { +"$ref": "Policy", +"description": "REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them." +} +}, +"type": "object" +}, +"SqlIntegration": { +"description": "Represents the Sql instance integrated with AD.", +"id": "SqlIntegration", +"properties": { +"createTime": { +"description": "Output only. The time sql integration was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"name": { +"description": "The unique name of the sql integration in the form of `projects/{project_id}/locations/global/domains/{domain_name}/sqlIntegrations/{sql_integration}`", +"type": "string" +}, +"sqlInstance": { +"description": "The full resource name of an integrated sql instance", +"type": "string" +}, +"state": { +"description": "Output only. The current state of the sql integration.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"DELETING", +"READY" +], +"enumDescriptions": [ +"Not Set", +"The sqlIntegration is being created.", +"The sqlIntegration is being deleted.", +"The sqlIntegration is ready." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time sql integration was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Status": { +"description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", +"id": "Status", +"properties": { +"code": { +"description": "The status code, which should be an enum value of google.rpc.Code.", +"format": "int32", +"type": "integer" +}, +"details": { +"description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", +"items": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"type": "object" +}, +"type": "array" +}, +"message": { +"description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", +"type": "string" +} +}, +"type": "object" +}, +"TestIamPermissionsRequest": { +"description": "Request message for `TestIamPermissions` method.", +"id": "TestIamPermissionsRequest", +"properties": { +"permissions": { +"description": "The set of permissions to check for the `resource`. Permissions with wildcards (such as `*` or `storage.*`) are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"TestIamPermissionsResponse": { +"description": "Response message for `TestIamPermissions` method.", +"id": "TestIamPermissionsResponse", +"properties": { +"permissions": { +"description": "A subset of `TestPermissionsRequest.permissions` that the caller is allowed.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"TimeOfDay": { +"description": "Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`.", +"id": "TimeOfDay", +"properties": { +"hours": { +"description": "Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value \"24:00:00\" for scenarios like business closing time.", +"format": "int32", +"type": "integer" +}, +"minutes": { +"description": "Minutes of hour of day. Must be from 0 to 59.", +"format": "int32", +"type": "integer" +}, +"nanos": { +"description": "Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.", +"format": "int32", +"type": "integer" +}, +"seconds": { +"description": "Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"Trust": { +"description": "Represents a relationship between two domains. This allows a controller in one domain to authenticate a user in another domain.", +"id": "Trust", +"properties": { +"createTime": { +"description": "Output only. The time the instance was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"lastTrustHeartbeatTime": { +"description": "Output only. The last heartbeat time when the trust was known to be connected.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"selectiveAuthentication": { +"description": "The trust authentication type, which decides whether the trusted side has forest/domain wide access or selective access to an approved set of resources.", +"type": "boolean" +}, +"state": { +"description": "Output only. The current state of the trust.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"UPDATING", +"DELETING", +"CONNECTED", +"DISCONNECTED" +], +"enumDescriptions": [ +"Not set.", +"The domain trust is being created.", +"The domain trust is being updated.", +"The domain trust is being deleted.", +"The domain trust is connected.", +"The domain trust is disconnected." +], +"readOnly": true, +"type": "string" +}, +"stateDescription": { +"description": "Output only. Additional information about the current state of the trust, if available.", +"readOnly": true, +"type": "string" +}, +"targetDnsIpAddresses": { +"description": "The target DNS server IP addresses which can resolve the remote domain involved in the trust.", +"items": { +"type": "string" +}, +"type": "array" +}, +"targetDomainName": { +"description": "The fully qualified target domain name which will be in trust with the current domain.", +"type": "string" +}, +"trustDirection": { +"description": "The trust direction, which decides if the current domain is trusted, trusting, or both.", +"enum": [ +"TRUST_DIRECTION_UNSPECIFIED", +"INBOUND", +"OUTBOUND", +"BIDIRECTIONAL" +], +"enumDescriptions": [ +"Not set.", +"The inbound direction represents the trusting side.", +"The outboud direction represents the trusted side.", +"The bidirectional direction represents the trusted / trusting side." +], +"type": "string" +}, +"trustHandshakeSecret": { +"description": "Input only. The trust secret used for the handshake with the target domain. It will not be stored.", +"type": "string" +}, +"trustType": { +"description": "The type of trust represented by the trust resource.", +"enum": [ +"TRUST_TYPE_UNSPECIFIED", +"FOREST", +"EXTERNAL" +], +"enumDescriptions": [ +"Not set.", +"The forest trust.", +"The external domain trust." +], +"type": "string" +}, +"updateTime": { +"description": "Output only. The last update time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"UpdatePolicy": { +"description": "Maintenance policy applicable to instance updates.", +"id": "UpdatePolicy", +"properties": { +"channel": { +"description": "Optional. Relative scheduling channel applied to resource.", +"enum": [ +"UPDATE_CHANNEL_UNSPECIFIED", +"EARLIER", +"LATER", +"WEEK1", +"WEEK2", +"WEEK5" +], +"enumDescriptions": [ +"Unspecified channel.", +"Early channel within a customer project.", +"Later channel within a customer project.", +"! ! The follow channels can ONLY be used if you adopt the new MW system! ! ! NOTE: all WEEK channels are assumed to be under a weekly window. ! There is currently no dedicated channel definitions for Daily windows. ! If you use Daily window, the system will assume a 1d (24Hours) advanced ! notification period b/w EARLY and LATER. ! We may consider support more flexible daily channel specifications in ! the future. WEEK1 == EARLIER with minimum 7d advanced notification. {7d, 14d} The system will treat them equally and will use WEEK1 whenever it can. New customers are encouraged to use this channel annotation.", +"WEEK2 == LATER with minimum 14d advanced notification {14d, 21d}.", +"WEEK5 == 40d support. minimum 35d advanced notification {35d, 42d}." +], +"type": "string" +}, +"denyMaintenancePeriods": { +"description": "Deny Maintenance Period that is applied to resource to indicate when maintenance is forbidden. The protocol supports zero-to-many such periods, but the current SLM Rollout implementation only supports zero-to-one.", +"items": { +"$ref": "DenyMaintenancePeriod" +}, +"type": "array" +}, +"window": { +"$ref": "MaintenanceWindow", +"description": "Optional. Maintenance window that is applied to resources covered by this policy." +} +}, +"type": "object" +}, +"ValidateTrustRequest": { +"description": "Request message for ValidateTrust", +"id": "ValidateTrustRequest", +"properties": { +"trust": { +"$ref": "Trust", +"description": "Required. The domain trust to validate trust state for." +} +}, +"type": "object" +}, +"WeeklyCycle": { +"description": "Time window specified for weekly operations.", +"id": "WeeklyCycle", +"properties": { +"schedule": { +"description": "User can specify multiple windows in a week. Minimum of 1 window.", +"items": { +"$ref": "Schedule" +}, +"type": "array" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Managed Service for Microsoft Active Directory API", +"version": "v1beta1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/networkconnectivity.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/networkconnectivity.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..efb1232c2bc43e9c20242c94f2e17da2f3c42425 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/networkconnectivity.v1.json @@ -0,0 +1,5689 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +} +} +} +}, +"basePath": "", +"baseUrl": "https://networkconnectivity.googleapis.com/", +"batchPath": "batch", +"canonicalName": "networkconnectivity", +"description": "This API enables connectivity with and between Google Cloud resources.", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/network-connectivity/docs/reference/networkconnectivity/rest", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "networkconnectivity:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://networkconnectivity.mtls.googleapis.com/", +"name": "networkconnectivity", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"projects": { +"resources": { +"locations": { +"methods": { +"get": { +"description": "Gets information about a location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Resource name for the location.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Location" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists information about the supported locations for this service.", +"flatPath": "v1/projects/{projectsId}/locations", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "A filter to narrow down results to a preferred subset. The filtering language accepts strings like `\"displayName=tokyo\"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160).", +"location": "query", +"type": "string" +}, +"name": { +"description": "The resource that owns the locations collection, if applicable.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return. If not set, the service selects a default.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}/locations", +"response": { +"$ref": "ListLocationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"global": { +"resources": { +"hubs": { +"methods": { +"acceptSpoke": { +"description": "Accepts a proposal to attach a Network Connectivity Center spoke to a hub.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}:acceptSpoke", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.hubs.acceptSpoke", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the hub into which to accept the spoke.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:acceptSpoke", +"request": { +"$ref": "AcceptHubSpokeRequest" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"create": { +"description": "Creates a new Network Connectivity Center hub in the specified project.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.hubs.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"hubId": { +"description": "Required. A unique identifier for the hub.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/hubs", +"request": { +"$ref": "Hub" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a Network Connectivity Center hub.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.global.hubs.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the hub to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details about a Network Connectivity Center hub.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the hub resource to get.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Hub" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}:getIamPolicy", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists the Network Connectivity Center hubs associated with a given project.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of results.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results per page to return.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/hubs", +"response": { +"$ref": "ListHubsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"listSpokes": { +"description": "Lists the Network Connectivity Center spokes associated with a specified hub and location. The list includes both spokes that are attached to the hub and spokes that have been proposed but not yet accepted.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}:listSpokes", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.listSpokes", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of results.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the hub.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +}, +"orderBy": { +"description": "Sort the results by name or create_time.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return per page.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"spokeLocations": { +"description": "A list of locations. Specify one of the following: `[global]`, a single region (for example, `[us-central1]`), or a combination of values (for example, `[global, us-central1, us-west1]`). If the spoke_locations field is populated, the list of results includes only spokes in the specified location. If the spoke_locations field is not populated, the list of results includes spokes in all locations.", +"location": "query", +"repeated": true, +"type": "string" +}, +"view": { +"description": "The view of the spoke to return. The view that you use determines which spoke fields are included in the response.", +"enum": [ +"SPOKE_VIEW_UNSPECIFIED", +"BASIC", +"DETAILED" +], +"enumDescriptions": [ +"The spoke view is unspecified. When the spoke view is unspecified, the API returns the same fields as the `BASIC` view.", +"Includes `name`, `create_time`, `hub`, `unique_id`, `state`, `reasons`, and `spoke_type`. This is the default value.", +"Includes all spoke fields except `labels`. You can use the `DETAILED` view only when you set the `spoke_locations` field to `[global]`." +], +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}:listSpokes", +"response": { +"$ref": "ListHubSpokesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the description and/or labels of a Network Connectivity Center hub.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}", +"httpMethod": "PATCH", +"id": "networkconnectivity.projects.locations.global.hubs.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. The name of the hub. Hub names must be unique. They use the following form: `projects/{project_number}/locations/global/hubs/{hub_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. In the case of an update to an existing hub, field mask is used to specify the fields to be overwritten. The fields specified in the update_mask are relative to the resource, not the full request. A field is overwritten if it is in the mask. If the user does not provide a mask, then all fields are overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "Hub" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"queryStatus": { +"description": "Query the Private Service Connect propagation status of a Network Connectivity Center hub.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}:queryStatus", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.queryStatus", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "Optional. An expression that filters the list of results. The filter can be used to filter the results by the following fields: * `psc_propagation_status.source_spoke` * `psc_propagation_status.source_group` * `psc_propagation_status.source_forwarding_rule` * `psc_propagation_status.target_spoke` * `psc_propagation_status.target_group` * `psc_propagation_status.code` * `psc_propagation_status.message`", +"location": "query", +"type": "string" +}, +"groupBy": { +"description": "Optional. Aggregate the results by the specified fields. A comma-separated list of any of these fields: * `psc_propagation_status.source_spoke` * `psc_propagation_status.source_group` * `psc_propagation_status.source_forwarding_rule` * `psc_propagation_status.target_spoke` * `psc_propagation_status.target_group` * `psc_propagation_status.code`", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the hub.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +}, +"orderBy": { +"description": "Optional. Sort the results in ascending order by the specified fields. A comma-separated list of any of these fields: * `psc_propagation_status.source_spoke` * `psc_propagation_status.source_group` * `psc_propagation_status.source_forwarding_rule` * `psc_propagation_status.target_spoke` * `psc_propagation_status.target_group` * `psc_propagation_status.code` If `group_by` is set, the value of the `order_by` field must be the same as or a subset of the `group_by` field.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of results to return per page.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}:queryStatus", +"response": { +"$ref": "QueryHubStatusResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"rejectSpoke": { +"description": "Rejects a Network Connectivity Center spoke from being attached to a hub. If the spoke was previously in the `ACTIVE` state, it transitions to the `INACTIVE` state and is no longer able to connect to other spokes that are attached to the hub.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}:rejectSpoke", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.hubs.rejectSpoke", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the hub from which to reject the spoke.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:rejectSpoke", +"request": { +"$ref": "RejectHubSpokeRequest" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}:setIamPolicy", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.hubs.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}:testIamPermissions", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.hubs.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"groups": { +"methods": { +"get": { +"description": "Gets details about a Network Connectivity Center group.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/groups/{groupsId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.groups.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the route table resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+/groups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Group" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/groups/{groupsId}:getIamPolicy", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.groups.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+/groups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists groups in a given hub.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/groups", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.groups.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of results.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return per page.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/groups", +"response": { +"$ref": "ListGroupsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a Network Connectivity Center group.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/groups/{groupsId}", +"httpMethod": "PATCH", +"id": "networkconnectivity.projects.locations.global.hubs.groups.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. The name of the group. Group names must be unique. They use the following form: `projects/{project_number}/locations/global/hubs/{hub}/groups/{group_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+/groups/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. In the case of an update to an existing group, field mask is used to specify the fields to be overwritten. The fields specified in the update_mask are relative to the resource, not the full request. A field is overwritten if it is in the mask. If the user does not provide a mask, then all fields are overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "Group" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/groups/{groupsId}:setIamPolicy", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.hubs.groups.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+/groups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/groups/{groupsId}:testIamPermissions", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.hubs.groups.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+/groups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"routeTables": { +"methods": { +"get": { +"description": "Gets details about a Network Connectivity Center route table.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/routeTables/{routeTablesId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.routeTables.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the route table resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+/routeTables/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "RouteTable" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists route tables in a given hub.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/routeTables", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.routeTables.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of results.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return per page.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/routeTables", +"response": { +"$ref": "ListRouteTablesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"routes": { +"methods": { +"get": { +"description": "Gets details about the specified route.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/routeTables/{routeTablesId}/routes/{routesId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.routeTables.routes.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the route resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+/routeTables/[^/]+/routes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Route" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists routes in a given route table.", +"flatPath": "v1/projects/{projectsId}/locations/global/hubs/{hubsId}/routeTables/{routeTablesId}/routes", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.hubs.routeTables.routes.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of results.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return per page.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/hubs/[^/]+/routeTables/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/routes", +"response": { +"$ref": "ListRoutesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +} +}, +"policyBasedRoutes": { +"methods": { +"create": { +"description": "Creates a new policy-based route in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/global/policyBasedRoutes", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.policyBasedRoutes.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource's name of the PolicyBasedRoute.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +}, +"policyBasedRouteId": { +"description": "Required. Unique id for the policy-based route to create.", +"location": "query", +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/policyBasedRoutes", +"request": { +"$ref": "PolicyBasedRoute" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single policy-based route.", +"flatPath": "v1/projects/{projectsId}/locations/global/policyBasedRoutes/{policyBasedRoutesId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.global.policyBasedRoutes.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the policy-based route resource to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/policyBasedRoutes/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single policy-based route.", +"flatPath": "v1/projects/{projectsId}/locations/global/policyBasedRoutes/{policyBasedRoutesId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.policyBasedRoutes.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the PolicyBasedRoute resource to get.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/policyBasedRoutes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "PolicyBasedRoute" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/global/policyBasedRoutes/{policyBasedRoutesId}:getIamPolicy", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.policyBasedRoutes.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/policyBasedRoutes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists policy-based routes in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/global/policyBasedRoutes", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.global.policyBasedRoutes.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter expression that filters the results listed in the response.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results per page that should be returned.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/policyBasedRoutes", +"response": { +"$ref": "ListPolicyBasedRoutesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/global/policyBasedRoutes/{policyBasedRoutesId}:setIamPolicy", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.policyBasedRoutes.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/policyBasedRoutes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/global/policyBasedRoutes/{policyBasedRoutesId}:testIamPermissions", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.global.policyBasedRoutes.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/global/policyBasedRoutes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +}, +"internalRanges": { +"methods": { +"create": { +"description": "Creates a new internal range in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/internalRanges", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.internalRanges.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"internalRangeId": { +"description": "Optional. Resource ID (i.e. 'foo' in '[...]/projects/p/locations/l/internalRanges/foo') See https://google.aip.dev/122#resource-id-segments Unique per location.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name of the internal range.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/internalRanges", +"request": { +"$ref": "InternalRange" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single internal range.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/internalRanges/{internalRangesId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.internalRanges.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the internal range to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/internalRanges/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single internal range.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/internalRanges/{internalRangesId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.internalRanges.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the InternalRange to get.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/internalRanges/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "InternalRange" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists internal ranges in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/internalRanges", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.internalRanges.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter expression that filters the results listed in the response.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results per page that should be returned.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/internalRanges", +"response": { +"$ref": "ListInternalRangesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single internal range.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/internalRanges/{internalRangesId}", +"httpMethod": "PATCH", +"id": "networkconnectivity.projects.locations.internalRanges.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. The name of an internal range. Format: projects/{project}/locations/{location}/internalRanges/{internal_range} See: https://google.aip.dev/122#fields-representing-resource-names", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/internalRanges/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the InternalRange resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "InternalRange" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"request": { +"$ref": "GoogleLongrunningCancelOperationRequest" +}, +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/operations", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}/operations", +"response": { +"$ref": "GoogleLongrunningListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"regionalEndpoints": { +"methods": { +"create": { +"description": "Creates a new RegionalEndpoint in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/regionalEndpoints", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.regionalEndpoints.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource's name of the RegionalEndpoint.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"regionalEndpointId": { +"description": "Required. Unique id of the Regional Endpoint to be created.", +"location": "query", +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if the original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/regionalEndpoints", +"request": { +"$ref": "RegionalEndpoint" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single RegionalEndpoint.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/regionalEndpoints/{regionalEndpointsId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.regionalEndpoints.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the RegionalEndpoint to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/regionalEndpoints/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if the original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single RegionalEndpoint.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/regionalEndpoints/{regionalEndpointsId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.regionalEndpoints.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the RegionalEndpoint resource to get. Format: `projects/{project}/locations/{location}/regionalEndpoints/{regional_endpoint}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/regionalEndpoints/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "RegionalEndpoint" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists RegionalEndpoints in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/regionalEndpoints", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.regionalEndpoints.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter expression that filters the results listed in the response.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name of the RegionalEndpoint.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/regionalEndpoints", +"response": { +"$ref": "ListRegionalEndpointsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"serviceClasses": { +"methods": { +"delete": { +"description": "Deletes a single ServiceClass.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceClasses/{serviceClassesId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.serviceClasses.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"etag": { +"description": "Optional. The etag is computed by the server, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the ServiceClass to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceClasses/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single ServiceClass.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceClasses/{serviceClassesId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceClasses.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the ServiceClass to get.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceClasses/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ServiceClass" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceClasses/{serviceClassesId}:getIamPolicy", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceClasses.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceClasses/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists ServiceClasses in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceClasses", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceClasses.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter expression that filters the results listed in the response.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results per page that should be returned.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name. ex. projects/123/locations/us-east1", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/serviceClasses", +"response": { +"$ref": "ListServiceClassesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single ServiceClass.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceClasses/{serviceClassesId}", +"httpMethod": "PATCH", +"id": "networkconnectivity.projects.locations.serviceClasses.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. The name of a ServiceClass resource. Format: projects/{project}/locations/{location}/serviceClasses/{service_class} See: https://google.aip.dev/122#fields-representing-resource-names", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceClasses/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the ServiceClass resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "ServiceClass" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceClasses/{serviceClassesId}:setIamPolicy", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceClasses.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceClasses/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceClasses/{serviceClassesId}:testIamPermissions", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceClasses.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceClasses/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"serviceConnectionMaps": { +"methods": { +"create": { +"description": "Creates a new ServiceConnectionMap in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionMaps", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceConnectionMaps.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource's name of the ServiceConnectionMap. ex. projects/123/locations/us-east1", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"serviceConnectionMapId": { +"description": "Optional. Resource ID (i.e. 'foo' in '[...]/projects/p/locations/l/serviceConnectionMaps/foo') See https://google.aip.dev/122#resource-id-segments Unique per location. If one is not provided, one will be generated.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/serviceConnectionMaps", +"request": { +"$ref": "ServiceConnectionMap" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single ServiceConnectionMap.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionMaps/{serviceConnectionMapsId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.serviceConnectionMaps.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"etag": { +"description": "Optional. The etag is computed by the server, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the ServiceConnectionMap to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionMaps/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single ServiceConnectionMap.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionMaps/{serviceConnectionMapsId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceConnectionMaps.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the ServiceConnectionMap to get.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionMaps/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ServiceConnectionMap" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionMaps/{serviceConnectionMapsId}:getIamPolicy", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceConnectionMaps.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionMaps/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists ServiceConnectionMaps in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionMaps", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceConnectionMaps.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter expression that filters the results listed in the response.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results per page that should be returned.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name. ex. projects/123/locations/us-east1", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/serviceConnectionMaps", +"response": { +"$ref": "ListServiceConnectionMapsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single ServiceConnectionMap.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionMaps/{serviceConnectionMapsId}", +"httpMethod": "PATCH", +"id": "networkconnectivity.projects.locations.serviceConnectionMaps.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. The name of a ServiceConnectionMap. Format: projects/{project}/locations/{location}/serviceConnectionMaps/{service_connection_map} See: https://google.aip.dev/122#fields-representing-resource-names", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionMaps/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the ServiceConnectionMap resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "ServiceConnectionMap" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionMaps/{serviceConnectionMapsId}:setIamPolicy", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceConnectionMaps.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionMaps/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionMaps/{serviceConnectionMapsId}:testIamPermissions", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceConnectionMaps.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionMaps/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"serviceConnectionPolicies": { +"methods": { +"create": { +"description": "Creates a new ServiceConnectionPolicy in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionPolicies", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceConnectionPolicies.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource's name of the ServiceConnectionPolicy. ex. projects/123/locations/us-east1", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"serviceConnectionPolicyId": { +"description": "Optional. Resource ID (i.e. 'foo' in '[...]/projects/p/locations/l/serviceConnectionPolicies/foo') See https://google.aip.dev/122#resource-id-segments Unique per location.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/serviceConnectionPolicies", +"request": { +"$ref": "ServiceConnectionPolicy" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single ServiceConnectionPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionPolicies/{serviceConnectionPoliciesId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.serviceConnectionPolicies.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"etag": { +"description": "Optional. The etag is computed by the server, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the ServiceConnectionPolicy to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single ServiceConnectionPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionPolicies/{serviceConnectionPoliciesId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceConnectionPolicies.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the ServiceConnectionPolicy to get.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ServiceConnectionPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionPolicies/{serviceConnectionPoliciesId}:getIamPolicy", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceConnectionPolicies.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists ServiceConnectionPolicies in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionPolicies", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceConnectionPolicies.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter expression that filters the results listed in the response.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results per page that should be returned.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name. ex. projects/123/locations/us-east1", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/serviceConnectionPolicies", +"response": { +"$ref": "ListServiceConnectionPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single ServiceConnectionPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionPolicies/{serviceConnectionPoliciesId}", +"httpMethod": "PATCH", +"id": "networkconnectivity.projects.locations.serviceConnectionPolicies.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. The name of a ServiceConnectionPolicy. Format: projects/{project}/locations/{location}/serviceConnectionPolicies/{service_connection_policy} See: https://google.aip.dev/122#fields-representing-resource-names", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the ServiceConnectionPolicy resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "ServiceConnectionPolicy" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionPolicies/{serviceConnectionPoliciesId}:setIamPolicy", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceConnectionPolicies.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionPolicies/{serviceConnectionPoliciesId}:testIamPermissions", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceConnectionPolicies.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"serviceConnectionTokens": { +"methods": { +"create": { +"description": "Creates a new ServiceConnectionToken in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionTokens", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.serviceConnectionTokens.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource's name of the ServiceConnectionToken. ex. projects/123/locations/us-east1", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"serviceConnectionTokenId": { +"description": "Optional. Resource ID (i.e. 'foo' in '[...]/projects/p/locations/l/ServiceConnectionTokens/foo') See https://google.aip.dev/122#resource-id-segments Unique per location. If one is not provided, one will be generated.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/serviceConnectionTokens", +"request": { +"$ref": "ServiceConnectionToken" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single ServiceConnectionToken.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionTokens/{serviceConnectionTokensId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.serviceConnectionTokens.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"etag": { +"description": "Optional. The etag is computed by the server, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the ServiceConnectionToken to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionTokens/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single ServiceConnectionToken.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionTokens/{serviceConnectionTokensId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceConnectionTokens.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the ServiceConnectionToken to get.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serviceConnectionTokens/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ServiceConnectionToken" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists ServiceConnectionTokens in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serviceConnectionTokens", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.serviceConnectionTokens.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter expression that filters the results listed in the response.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results per page that should be returned.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource's name. ex. projects/123/locations/us-east1", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/serviceConnectionTokens", +"response": { +"$ref": "ListServiceConnectionTokensResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"spokes": { +"methods": { +"create": { +"description": "Creates a Network Connectivity Center spoke.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/spokes", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.spokes.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"spokeId": { +"description": "Required. Unique id for the spoke to create.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/spokes", +"request": { +"$ref": "Spoke" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a Network Connectivity Center spoke.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/spokes/{spokesId}", +"httpMethod": "DELETE", +"id": "networkconnectivity.projects.locations.spokes.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the spoke to delete.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/spokes/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details about a Network Connectivity Center spoke.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/spokes/{spokesId}", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.spokes.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the spoke resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/spokes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Spoke" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/spokes/{spokesId}:getIamPolicy", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.spokes.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/spokes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists the Network Connectivity Center spokes in a specified project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/spokes", +"httpMethod": "GET", +"id": "networkconnectivity.projects.locations.spokes.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of results.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Sort the results by a certain order.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return per page.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/spokes", +"response": { +"$ref": "ListSpokesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a Network Connectivity Center spoke.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/spokes/{spokesId}", +"httpMethod": "PATCH", +"id": "networkconnectivity.projects.locations.spokes.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. The name of the spoke. Spoke names must be unique. They use the following form: `projects/{project_number}/locations/{region}/spokes/{spoke_id}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/spokes/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. In the case of an update to an existing spoke, field mask is used to specify the fields to be overwritten. The fields specified in the update_mask are relative to the resource, not the full request. A field is overwritten if it is in the mask. If the user does not provide a mask, then all fields are overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "Spoke" +}, +"response": { +"$ref": "GoogleLongrunningOperation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/spokes/{spokesId}:setIamPolicy", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.spokes.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/spokes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/spokes/{spokesId}:testIamPermissions", +"httpMethod": "POST", +"id": "networkconnectivity.projects.locations.spokes.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/spokes/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +} +} +}, +"revision": "20250101", +"rootUrl": "https://networkconnectivity.googleapis.com/", +"schemas": { +"AcceptHubSpokeRequest": { +"description": "The request for HubService.AcceptHubSpoke.", +"id": "AcceptHubSpokeRequest", +"properties": { +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"type": "string" +}, +"spokeUri": { +"description": "Required. The URI of the spoke to accept into the hub.", +"type": "string" +} +}, +"type": "object" +}, +"AcceptHubSpokeResponse": { +"description": "The response for HubService.AcceptHubSpoke.", +"id": "AcceptHubSpokeResponse", +"properties": { +"spoke": { +"$ref": "Spoke", +"description": "The spoke that was operated on." +} +}, +"type": "object" +}, +"AuditConfig": { +"description": "Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { \"audit_configs\": [ { \"service\": \"allServices\", \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\", \"exempted_members\": [ \"user:jose@example.com\" ] }, { \"log_type\": \"DATA_WRITE\" }, { \"log_type\": \"ADMIN_READ\" } ] }, { \"service\": \"sampleservice.googleapis.com\", \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\" }, { \"log_type\": \"DATA_WRITE\", \"exempted_members\": [ \"user:aliya@example.com\" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.", +"id": "AuditConfig", +"properties": { +"auditLogConfigs": { +"description": "The configuration for logging of each type of permission.", +"items": { +"$ref": "AuditLogConfig" +}, +"type": "array" +}, +"service": { +"description": "Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.", +"type": "string" +} +}, +"type": "object" +}, +"AuditLogConfig": { +"description": "Provides the configuration for logging a type of permissions. Example: { \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\", \"exempted_members\": [ \"user:jose@example.com\" ] }, { \"log_type\": \"DATA_WRITE\" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.", +"id": "AuditLogConfig", +"properties": { +"exemptedMembers": { +"description": "Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.", +"items": { +"type": "string" +}, +"type": "array" +}, +"logType": { +"description": "The log type that this config enables.", +"enum": [ +"LOG_TYPE_UNSPECIFIED", +"ADMIN_READ", +"DATA_WRITE", +"DATA_READ" +], +"enumDescriptions": [ +"Default case. Should never be this.", +"Admin reads. Example: CloudIAM getIamPolicy", +"Data writes. Example: CloudSQL Users create", +"Data reads. Example: CloudSQL Users list" +], +"type": "string" +} +}, +"type": "object" +}, +"AutoAccept": { +"description": "The auto-accept setting for a group controls whether proposed spokes are automatically attached to the hub. If auto-accept is enabled, the spoke immediately is attached to the hub and becomes part of the group. In this case, the new spoke is in the ACTIVE state. If auto-accept is disabled, the spoke goes to the INACTIVE state, and it must be reviewed and accepted by a hub administrator.", +"id": "AutoAccept", +"properties": { +"autoAcceptProjects": { +"description": "Optional. A list of project ids or project numbers for which you want to enable auto-accept. The auto-accept setting is applied to spokes being created or updated in these projects.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Binding": { +"description": "Associates `members`, or principals, with a `role`.", +"id": "Binding", +"properties": { +"condition": { +"$ref": "Expr", +"description": "The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies)." +}, +"members": { +"description": "Specifies the principals requesting access for a Google Cloud resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workforce identity pool. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/group/{group_id}`: All workforce identities in a group. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All workforce identities with a specific attribute value. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/*`: All identities in a workforce identity pool. * `principal://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workload identity pool. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/group/{group_id}`: A workload identity pool group. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All identities in a workload identity pool with a certain attribute. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/*`: All identities in a workload identity pool. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: Deleted single identity in a workforce identity pool. For example, `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-pool-id/subject/my-subject-attribute-value`.", +"items": { +"type": "string" +}, +"type": "array" +}, +"role": { +"description": "Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview of the IAM roles and permissions, see the [IAM documentation](https://cloud.google.com/iam/docs/roles-overview). For a list of the available pre-defined roles, see [here](https://cloud.google.com/iam/docs/understanding-roles).", +"type": "string" +} +}, +"type": "object" +}, +"ConsumerPscConfig": { +"description": "Allow the producer to specify which consumers can connect to it.", +"id": "ConsumerPscConfig", +"properties": { +"consumerInstanceProject": { +"description": "Required. The project ID or project number of the consumer project. This project is the one that the consumer uses to interact with the producer instance. From the perspective of a consumer who's created a producer instance, this is the project of the producer instance. Format: 'projects/' Eg. 'projects/consumer-project' or 'projects/1234'", +"type": "string" +}, +"disableGlobalAccess": { +"description": "This is used in PSC consumer ForwardingRule to control whether the PSC endpoint can be accessed from another region.", +"type": "boolean" +}, +"ipVersion": { +"description": "The requested IP version for the PSC connection.", +"enum": [ +"IP_VERSION_UNSPECIFIED", +"IPV4", +"IPV6" +], +"enumDescriptions": [ +"Default value. We will use IPv4 or IPv6 depending on the IP version of first available subnetwork.", +"Will use IPv4 only.", +"Will use IPv6 only." +], +"type": "string" +}, +"network": { +"description": "The resource path of the consumer network where PSC connections are allowed to be created in. Note, this network does not need be in the ConsumerPscConfig.project in the case of SharedVPC. Example: projects/{projectNumOrId}/global/networks/{networkId}.", +"type": "string" +}, +"producerInstanceId": { +"deprecated": true, +"description": "Immutable. Deprecated. Use producer_instance_metadata instead. An immutable identifier for the producer instance.", +"type": "string" +}, +"producerInstanceMetadata": { +"additionalProperties": { +"type": "string" +}, +"description": "Immutable. An immutable map for the producer instance metadata.", +"type": "object" +}, +"project": { +"description": "The consumer project where PSC connections are allowed to be created in.", +"type": "string" +}, +"serviceAttachmentIpAddressMap": { +"additionalProperties": { +"type": "string" +}, +"description": "Output only. A map to store mapping between customer vip and target service attachment. Only service attachment with producer specified ip addresses are stored here.", +"readOnly": true, +"type": "object" +}, +"state": { +"description": "Output only. Overall state of PSC Connections management for this consumer psc config.", +"enum": [ +"STATE_UNSPECIFIED", +"VALID", +"CONNECTION_POLICY_MISSING", +"POLICY_LIMIT_REACHED", +"CONSUMER_INSTANCE_PROJECT_NOT_ALLOWLISTED" +], +"enumDescriptions": [ +"Default state, when Connection Map is created initially.", +"Set when policy and map configuration is valid, and their matching can lead to allowing creation of PSC Connections subject to other constraints like connections limit.", +"No Service Connection Policy found for this network and Service Class", +"Service Connection Policy limit reached for this network and Service Class", +"The consumer instance project is not in AllowedGoogleProducersResourceHierarchyLevels of the matching ServiceConnectionPolicy." +], +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ConsumerPscConnection": { +"description": "PSC connection details on consumer side.", +"id": "ConsumerPscConnection", +"properties": { +"error": { +"$ref": "GoogleRpcStatus", +"deprecated": true, +"description": "The most recent error during operating this connection." +}, +"errorInfo": { +"$ref": "GoogleRpcErrorInfo", +"description": "Output only. The error info for the latest error during operating this connection.", +"readOnly": true +}, +"errorType": { +"deprecated": true, +"description": "The error type indicates whether the error is consumer facing, producer facing or system internal.", +"enum": [ +"CONNECTION_ERROR_TYPE_UNSPECIFIED", +"ERROR_INTERNAL", +"ERROR_CONSUMER_SIDE", +"ERROR_PRODUCER_SIDE" +], +"enumDescriptions": [ +"An invalid error type as the default case.", +"The error is due to Service Automation system internal.", +"The error is due to the setup on consumer side.", +"The error is due to the setup on producer side." +], +"type": "string" +}, +"forwardingRule": { +"description": "The URI of the consumer forwarding rule created. Example: projects/{projectNumOrId}/regions/us-east1/networks/{resourceId}.", +"type": "string" +}, +"gceOperation": { +"description": "The last Compute Engine operation to setup PSC connection.", +"type": "string" +}, +"ip": { +"description": "The IP literal allocated on the consumer network for the PSC forwarding rule that is created to connect to the producer service attachment in this service connection map.", +"type": "string" +}, +"ipVersion": { +"description": "The requested IP version for the PSC connection.", +"enum": [ +"IP_VERSION_UNSPECIFIED", +"IPV4", +"IPV6" +], +"enumDescriptions": [ +"Default value. We will use IPv4 or IPv6 depending on the IP version of first available subnetwork.", +"Will use IPv4 only.", +"Will use IPv6 only." +], +"type": "string" +}, +"network": { +"description": "The consumer network whose PSC forwarding rule is connected to the service attachments in this service connection map. Note that the network could be on a different project (shared VPC).", +"type": "string" +}, +"producerInstanceId": { +"deprecated": true, +"description": "Immutable. Deprecated. Use producer_instance_metadata instead. An immutable identifier for the producer instance.", +"type": "string" +}, +"producerInstanceMetadata": { +"additionalProperties": { +"type": "string" +}, +"description": "Immutable. An immutable map for the producer instance metadata.", +"type": "object" +}, +"project": { +"description": "The consumer project whose PSC forwarding rule is connected to the service attachments in this service connection map.", +"type": "string" +}, +"pscConnectionId": { +"description": "The PSC connection id of the PSC forwarding rule connected to the service attachments in this service connection map.", +"type": "string" +}, +"selectedSubnetwork": { +"description": "Output only. The URI of the selected subnetwork selected to allocate IP address for this connection.", +"readOnly": true, +"type": "string" +}, +"serviceAttachmentUri": { +"description": "The URI of a service attachment which is the target of the PSC connection.", +"type": "string" +}, +"state": { +"description": "The state of the PSC connection.", +"enum": [ +"STATE_UNSPECIFIED", +"ACTIVE", +"FAILED", +"CREATING", +"DELETING", +"CREATE_REPAIRING", +"DELETE_REPAIRING" +], +"enumDescriptions": [ +"An invalid state as the default case.", +"The connection has been created successfully. However, for the up-to-date connection status, please use the service attachment's \"ConnectedEndpoint.status\" as the source of truth.", +"The connection is not functional since some resources on the connection fail to be created.", +"The connection is being created.", +"The connection is being deleted.", +"The connection is being repaired to complete creation.", +"The connection is being repaired to complete deletion." +], +"type": "string" +} +}, +"type": "object" +}, +"Empty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "Empty", +"properties": {}, +"type": "object" +}, +"Expr": { +"description": "Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() < 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != 'private' && document.type != 'internal'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"'New message received at ' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.", +"id": "Expr", +"properties": { +"description": { +"description": "Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.", +"type": "string" +}, +"expression": { +"description": "Textual representation of an expression in Common Expression Language syntax.", +"type": "string" +}, +"location": { +"description": "Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.", +"type": "string" +}, +"title": { +"description": "Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.", +"type": "string" +} +}, +"type": "object" +}, +"Filter": { +"description": "Filter matches L4 traffic.", +"id": "Filter", +"properties": { +"destRange": { +"description": "Optional. The destination IP range of outgoing packets that this policy-based route applies to. Default is \"0.0.0.0/0\" if protocol version is IPv4.", +"type": "string" +}, +"ipProtocol": { +"description": "Optional. The IP protocol that this policy-based route applies to. Valid values are 'TCP', 'UDP', and 'ALL'. Default is 'ALL'.", +"type": "string" +}, +"protocolVersion": { +"description": "Required. Internet protocol versions this policy-based route applies to. For this version, only IPV4 is supported. IPV6 is supported in preview.", +"enum": [ +"PROTOCOL_VERSION_UNSPECIFIED", +"IPV4" +], +"enumDescriptions": [ +"Default value.", +"The PBR is for IPv4 internet protocol traffic." +], +"type": "string" +}, +"srcRange": { +"description": "Optional. The source IP range of outgoing packets that this policy-based route applies to. Default is \"0.0.0.0/0\" if protocol version is IPv4.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleLongrunningCancelOperationRequest": { +"description": "The request message for Operations.CancelOperation.", +"id": "GoogleLongrunningCancelOperationRequest", +"properties": {}, +"type": "object" +}, +"GoogleLongrunningListOperationsResponse": { +"description": "The response message for Operations.ListOperations.", +"id": "GoogleLongrunningListOperationsResponse", +"properties": { +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +}, +"operations": { +"description": "A list of operations that matches the specified filter in the request.", +"items": { +"$ref": "GoogleLongrunningOperation" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleLongrunningOperation": { +"description": "This resource represents a long-running operation that is the result of a network API call.", +"id": "GoogleLongrunningOperation", +"properties": { +"done": { +"description": "If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.", +"type": "boolean" +}, +"error": { +"$ref": "GoogleRpcStatus", +"description": "The error result of the operation in case of failure or cancellation." +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.", +"type": "object" +}, +"name": { +"description": "The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.", +"type": "string" +}, +"response": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.", +"type": "object" +} +}, +"type": "object" +}, +"GoogleRpcErrorInfo": { +"description": "Describes the cause of the error with structured details. Example of an error when contacting the \"pubsub.googleapis.com\" API when it is not enabled: { \"reason\": \"API_DISABLED\" \"domain\": \"googleapis.com\" \"metadata\": { \"resource\": \"projects/123\", \"service\": \"pubsub.googleapis.com\" } } This response indicates that the pubsub.googleapis.com API is not enabled. Example of an error that is returned when attempting to create a Spanner instance in a region that is out of stock: { \"reason\": \"STOCKOUT\" \"domain\": \"spanner.googleapis.com\", \"metadata\": { \"availableRegions\": \"us-central1,us-east2\" } }", +"id": "GoogleRpcErrorInfo", +"properties": { +"domain": { +"description": "The logical grouping to which the \"reason\" belongs. The error domain is typically the registered service name of the tool or product that generates the error. Example: \"pubsub.googleapis.com\". If the error is generated by some common infrastructure, the error domain must be a globally unique value that identifies the infrastructure. For Google API infrastructure, the error domain is \"googleapis.com\".", +"type": "string" +}, +"metadata": { +"additionalProperties": { +"type": "string" +}, +"description": "Additional structured details about this error. Keys must match a regular expression of `a-z+` but should ideally be lowerCamelCase. Also, they must be limited to 64 characters in length. When identifying the current value of an exceeded limit, the units should be contained in the key, not the value. For example, rather than `{\"instanceLimit\": \"100/request\"}`, should be returned as, `{\"instanceLimitPerRequest\": \"100\"}`, if the client exceeds the number of instances that can be created in a single (batch) request.", +"type": "object" +}, +"reason": { +"description": "The reason of the error. This is a constant value that identifies the proximate cause of the error. Error reasons are unique within a particular domain of errors. This should be at most 63 characters and match a regular expression of `A-Z+[A-Z0-9]`, which represents UPPER_SNAKE_CASE.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleRpcStatus": { +"description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", +"id": "GoogleRpcStatus", +"properties": { +"code": { +"description": "The status code, which should be an enum value of google.rpc.Code.", +"format": "int32", +"type": "integer" +}, +"details": { +"description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", +"items": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"type": "object" +}, +"type": "array" +}, +"message": { +"description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", +"type": "string" +} +}, +"type": "object" +}, +"Group": { +"description": "A group represents a subset of spokes attached to a hub.", +"id": "Group", +"properties": { +"autoAccept": { +"$ref": "AutoAccept", +"description": "Optional. The auto-accept setting for this group." +}, +"createTime": { +"description": "Output only. The time the group was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. The description of the group.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Labels in key-value pair format. For more information about labels, see [Requirements for labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).", +"type": "object" +}, +"name": { +"description": "Immutable. The name of the group. Group names must be unique. They use the following form: `projects/{project_number}/locations/global/hubs/{hub}/groups/{group_id}`", +"type": "string" +}, +"routeTable": { +"description": "Output only. The name of the route table that corresponds to this group. They use the following form: `projects/{project_number}/locations/global/hubs/{hub_id}/routeTables/{route_table_id}`", +"readOnly": true, +"type": "string" +}, +"state": { +"description": "Output only. The current lifecycle state of this group.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"DELETING", +"ACCEPTING", +"REJECTING", +"UPDATING", +"INACTIVE", +"OBSOLETE" +], +"enumDescriptions": [ +"No state information available", +"The resource's create operation is in progress.", +"The resource is active", +"The resource's delete operation is in progress.", +"The resource's accept operation is in progress.", +"The resource's reject operation is in progress.", +"The resource's update operation is in progress.", +"The resource is inactive.", +"The hub associated with this spoke resource has been deleted. This state applies to spoke resources only." +], +"readOnly": true, +"type": "string" +}, +"uid": { +"description": "Output only. The Google-generated UUID for the group. This value is unique across all group resources. If a group is deleted and another with the same name is created, the new route table is assigned a different unique_id.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time the group was last updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Hub": { +"description": "A Network Connectivity Center hub is a global management resource to which you attach spokes. A single hub can contain spokes from multiple regions. However, if any of a hub's spokes use the site-to-site data transfer feature, the resources associated with those spokes must all be in the same VPC network. Spokes that do not use site-to-site data transfer can be associated with any VPC network in your project.", +"id": "Hub", +"properties": { +"createTime": { +"description": "Output only. The time the hub was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. An optional description of the hub.", +"type": "string" +}, +"exportPsc": { +"description": "Optional. Whether Private Service Connect transitivity is enabled for the hub. If true, Private Service Connect endpoints in VPC spokes attached to the hub are made accessible to other VPC spokes attached to the hub. The default value is false.", +"type": "boolean" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional labels in key-value pair format. For more information about labels, see [Requirements for labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).", +"type": "object" +}, +"name": { +"description": "Immutable. The name of the hub. Hub names must be unique. They use the following form: `projects/{project_number}/locations/global/hubs/{hub_id}`", +"type": "string" +}, +"policyMode": { +"description": "Optional. The policy mode of this hub. This field can be either PRESET or CUSTOM. If unspecified, the policy_mode defaults to PRESET.", +"enum": [ +"POLICY_MODE_UNSPECIFIED", +"PRESET" +], +"enumDescriptions": [ +"Policy mode is unspecified. It defaults to PRESET with preset_topology = MESH.", +"Hub uses one of the preset topologies." +], +"type": "string" +}, +"presetTopology": { +"description": "Optional. The topology implemented in this hub. Currently, this field is only used when policy_mode = PRESET. The available preset topologies are MESH and STAR. If preset_topology is unspecified and policy_mode = PRESET, the preset_topology defaults to MESH. When policy_mode = CUSTOM, the preset_topology is set to PRESET_TOPOLOGY_UNSPECIFIED.", +"enum": [ +"PRESET_TOPOLOGY_UNSPECIFIED", +"MESH", +"STAR" +], +"enumDescriptions": [ +"Preset topology is unspecified. When policy_mode = PRESET, it defaults to MESH.", +"Mesh topology is implemented. Group `default` is automatically created. All spokes in the hub are added to group `default`.", +"Star topology is implemented. Two groups, `center` and `edge`, are automatically created along with hub creation. Spokes have to join one of the groups during creation." +], +"type": "string" +}, +"routeTables": { +"description": "Output only. The route tables that belong to this hub. They use the following form: `projects/{project_number}/locations/global/hubs/{hub_id}/routeTables/{route_table_id}` This field is read-only. Network Connectivity Center automatically populates it based on the route tables nested under the hub.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"routingVpcs": { +"description": "The VPC networks associated with this hub's spokes. This field is read-only. Network Connectivity Center automatically populates it based on the set of spokes attached to the hub.", +"items": { +"$ref": "RoutingVPC" +}, +"type": "array" +}, +"spokeSummary": { +"$ref": "SpokeSummary", +"description": "Output only. A summary of the spokes associated with a hub. The summary includes a count of spokes according to type and according to state. If any spokes are inactive, the summary also lists the reasons they are inactive, including a count for each reason.", +"readOnly": true +}, +"state": { +"description": "Output only. The current lifecycle state of this hub.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"DELETING", +"ACCEPTING", +"REJECTING", +"UPDATING", +"INACTIVE", +"OBSOLETE" +], +"enumDescriptions": [ +"No state information available", +"The resource's create operation is in progress.", +"The resource is active", +"The resource's delete operation is in progress.", +"The resource's accept operation is in progress.", +"The resource's reject operation is in progress.", +"The resource's update operation is in progress.", +"The resource is inactive.", +"The hub associated with this spoke resource has been deleted. This state applies to spoke resources only." +], +"readOnly": true, +"type": "string" +}, +"uniqueId": { +"description": "Output only. The Google-generated UUID for the hub. This value is unique across all hub resources. If a hub is deleted and another with the same name is created, the new hub is assigned a different unique_id.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time the hub was last updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"HubStatusEntry": { +"description": "A hub status entry represents the status of a set of propagated Private Service Connect connections grouped by certain fields.", +"id": "HubStatusEntry", +"properties": { +"count": { +"description": "The number of propagated Private Service Connect connections with this status. If the `group_by` field was not set in the request message, the value of this field is 1.", +"format": "int32", +"type": "integer" +}, +"groupBy": { +"description": "The fields that this entry is grouped by. This has the same value as the `group_by` field in the request message.", +"type": "string" +}, +"pscPropagationStatus": { +"$ref": "PscPropagationStatus", +"description": "The Private Service Connect propagation status." +} +}, +"type": "object" +}, +"InterconnectAttachment": { +"description": "InterconnectAttachment that this route applies to.", +"id": "InterconnectAttachment", +"properties": { +"region": { +"description": "Optional. Cloud region to install this policy-based route on interconnect attachment. Use `all` to install it on all interconnect attachments.", +"type": "string" +} +}, +"type": "object" +}, +"InternalRange": { +"description": "The internal range resource for IPAM operations within a VPC network. Used to represent a private address range along with behavioral characteristics of that range (its usage and peering behavior). Networking resources can link to this range if they are created as belonging to it.", +"id": "InternalRange", +"properties": { +"createTime": { +"description": "Time when the internal range was created.", +"format": "google-datetime", +"type": "string" +}, +"description": { +"description": "A description of this resource.", +"type": "string" +}, +"ipCidrRange": { +"description": "The IP range that this internal range defines. NOTE: IPv6 ranges are limited to usage=EXTERNAL_TO_VPC and peering=FOR_SELF. NOTE: For IPv6 Ranges this field is compulsory, i.e. the address range must be specified explicitly.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "User-defined labels.", +"type": "object" +}, +"migration": { +"$ref": "Migration", +"description": "Optional. Must be present if usage is set to FOR_MIGRATION. This field is for internal use." +}, +"name": { +"description": "Immutable. The name of an internal range. Format: projects/{project}/locations/{location}/internalRanges/{internal_range} See: https://google.aip.dev/122#fields-representing-resource-names", +"type": "string" +}, +"network": { +"description": "The URL or resource ID of the network in which to reserve the internal range. The network cannot be deleted if there are any reserved internal ranges referring to it. Legacy networks are not supported. For example: https://www.googleapis.com/compute/v1/projects/{project}/locations/global/networks/{network} projects/{project}/locations/global/networks/{network} {network}", +"type": "string" +}, +"overlaps": { +"description": "Optional. Types of resources that are allowed to overlap with the current internal range.", +"items": { +"enum": [ +"OVERLAP_UNSPECIFIED", +"OVERLAP_ROUTE_RANGE", +"OVERLAP_EXISTING_SUBNET_RANGE" +], +"enumDescriptions": [ +"No overlap overrides.", +"Allow creation of static routes more specific that the current internal range.", +"Allow creation of internal ranges that overlap with existing subnets." +], +"type": "string" +}, +"type": "array" +}, +"peering": { +"description": "The type of peering set for this internal range.", +"enum": [ +"PEERING_UNSPECIFIED", +"FOR_SELF", +"FOR_PEER", +"NOT_SHARED" +], +"enumDescriptions": [ +"If Peering is left unspecified in CreateInternalRange or UpdateInternalRange, it will be defaulted to FOR_SELF.", +"This is the default behavior and represents the case that this internal range is intended to be used in the VPC in which it is created and is accessible from its peers. This implies that peers or peers-of-peers cannot use this range.", +"This behavior can be set when the internal range is being reserved for usage by peers. This means that no resource within the VPC in which it is being created can use this to associate with a VPC resource, but one of the peers can. This represents donating a range for peers to use.", +"This behavior can be set when the internal range is being reserved for usage by the VPC in which it is created, but not shared with peers. In a sense, it is local to the VPC. This can be used to create internal ranges for various purposes like HTTP_INTERNAL_LOAD_BALANCER or for Interconnect routes that are not shared with peers. This also implies that peers cannot use this range in a way that is visible to this VPC, but can re-use this range as long as it is NOT_SHARED from the peer VPC, too." +], +"type": "string" +}, +"prefixLength": { +"description": "An alternate to ip_cidr_range. Can be set when trying to create an IPv4 reservation that automatically finds a free range of the given size. If both ip_cidr_range and prefix_length are set, there is an error if the range sizes do not match. Can also be used during updates to change the range size. NOTE: For IPv6 this field only works if ip_cidr_range is set as well, and both fields must match. In other words, with IPv6 this field only works as a redundant parameter.", +"format": "int32", +"type": "integer" +}, +"targetCidrRange": { +"description": "Optional. Can be set to narrow down or pick a different address space while searching for a free range. If not set, defaults to the \"10.0.0.0/8\" address space. This can be used to search in other rfc-1918 address spaces like \"172.16.0.0/12\" and \"192.168.0.0/16\" or non-rfc-1918 address spaces used in the VPC.", +"items": { +"type": "string" +}, +"type": "array" +}, +"updateTime": { +"description": "Time when the internal range was updated.", +"format": "google-datetime", +"type": "string" +}, +"usage": { +"description": "The type of usage set for this InternalRange.", +"enum": [ +"USAGE_UNSPECIFIED", +"FOR_VPC", +"EXTERNAL_TO_VPC", +"FOR_MIGRATION" +], +"enumDescriptions": [ +"Unspecified usage is allowed in calls which identify the resource by other fields and do not need Usage set to complete. These are, i.e.: GetInternalRange and DeleteInternalRange. Usage needs to be specified explicitly in CreateInternalRange or UpdateInternalRange calls.", +"A VPC resource can use the reserved CIDR block by associating it with the internal range resource if usage is set to FOR_VPC.", +"Ranges created with EXTERNAL_TO_VPC cannot be associated with VPC resources and are meant to block out address ranges for various use cases, like for example, usage on-prem, with dynamic route announcements via interconnect.", +"Ranges created FOR_MIGRATION can be used to lock a CIDR range between a source and target subnet. If usage is set to FOR_MIGRATION, the peering value has to be set to FOR_SELF or default to FOR_SELF when unset. This value is for internal use." +], +"type": "string" +}, +"users": { +"description": "Output only. The list of resources that refer to this internal range. Resources that use the internal range for their range allocation are referred to as users of the range. Other resources mark themselves as users while doing so by creating a reference to this internal range. Having a user, based on this reference, prevents deletion of the internal range referred to. Can be empty.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"LinkedInterconnectAttachments": { +"description": "A collection of VLAN attachment resources. These resources should be redundant attachments that all advertise the same prefixes to Google Cloud. Alternatively, in active/passive configurations, all attachments should be capable of advertising the same prefixes.", +"id": "LinkedInterconnectAttachments", +"properties": { +"includeImportRanges": { +"description": "Optional. IP ranges allowed to be included during import from hub (does not control transit connectivity). The only allowed value for now is \"ALL_IPV4_RANGES\".", +"items": { +"type": "string" +}, +"type": "array" +}, +"siteToSiteDataTransfer": { +"description": "A value that controls whether site-to-site data transfer is enabled for these resources. Data transfer is available only in [supported locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).", +"type": "boolean" +}, +"uris": { +"description": "The URIs of linked interconnect attachment resources", +"items": { +"type": "string" +}, +"type": "array" +}, +"vpcNetwork": { +"description": "Output only. The VPC network where these VLAN attachments are located.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"LinkedProducerVpcNetwork": { +"id": "LinkedProducerVpcNetwork", +"properties": { +"excludeExportRanges": { +"description": "Optional. IP ranges encompassing the subnets to be excluded from peering.", +"items": { +"type": "string" +}, +"type": "array" +}, +"includeExportRanges": { +"description": "Optional. IP ranges allowed to be included from peering.", +"items": { +"type": "string" +}, +"type": "array" +}, +"network": { +"description": "Immutable. The URI of the Service Consumer VPC that the Producer VPC is peered with.", +"type": "string" +}, +"peering": { +"description": "Immutable. The name of the VPC peering between the Service Consumer VPC and the Producer VPC (defined in the Tenant project) which is added to the NCC hub. This peering must be in ACTIVE state.", +"type": "string" +}, +"producerNetwork": { +"description": "Output only. The URI of the Producer VPC.", +"readOnly": true, +"type": "string" +}, +"serviceConsumerVpcSpoke": { +"description": "Output only. The Service Consumer Network spoke.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"LinkedRouterApplianceInstances": { +"description": "A collection of router appliance instances. If you configure multiple router appliance instances to receive data from the same set of sites outside of Google Cloud, we recommend that you associate those instances with the same spoke.", +"id": "LinkedRouterApplianceInstances", +"properties": { +"includeImportRanges": { +"description": "Optional. IP ranges allowed to be included during import from hub (does not control transit connectivity). The only allowed value for now is \"ALL_IPV4_RANGES\".", +"items": { +"type": "string" +}, +"type": "array" +}, +"instances": { +"description": "The list of router appliance instances.", +"items": { +"$ref": "RouterApplianceInstance" +}, +"type": "array" +}, +"siteToSiteDataTransfer": { +"description": "A value that controls whether site-to-site data transfer is enabled for these resources. Data transfer is available only in [supported locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).", +"type": "boolean" +}, +"vpcNetwork": { +"description": "Output only. The VPC network where these router appliance instances are located.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"LinkedVpcNetwork": { +"description": "An existing VPC network.", +"id": "LinkedVpcNetwork", +"properties": { +"excludeExportRanges": { +"description": "Optional. IP ranges encompassing the subnets to be excluded from peering.", +"items": { +"type": "string" +}, +"type": "array" +}, +"includeExportRanges": { +"description": "Optional. IP ranges allowed to be included from peering.", +"items": { +"type": "string" +}, +"type": "array" +}, +"producerVpcSpokes": { +"description": "Output only. The list of Producer VPC spokes that this VPC spoke is a service consumer VPC spoke for. These producer VPCs are connected through VPC peering to this spoke's backing VPC network.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"uri": { +"description": "Required. The URI of the VPC network resource.", +"type": "string" +} +}, +"type": "object" +}, +"LinkedVpnTunnels": { +"description": "A collection of Cloud VPN tunnel resources. These resources should be redundant HA VPN tunnels that all advertise the same prefixes to Google Cloud. Alternatively, in a passive/active configuration, all tunnels should be capable of advertising the same prefixes.", +"id": "LinkedVpnTunnels", +"properties": { +"includeImportRanges": { +"description": "Optional. IP ranges allowed to be included during import from hub (does not control transit connectivity). The only allowed value for now is \"ALL_IPV4_RANGES\".", +"items": { +"type": "string" +}, +"type": "array" +}, +"siteToSiteDataTransfer": { +"description": "A value that controls whether site-to-site data transfer is enabled for these resources. Data transfer is available only in [supported locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).", +"type": "boolean" +}, +"uris": { +"description": "The URIs of linked VPN tunnel resources.", +"items": { +"type": "string" +}, +"type": "array" +}, +"vpcNetwork": { +"description": "Output only. The VPC network where these VPN tunnels are located.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ListGroupsResponse": { +"description": "Response for HubService.ListGroups method.", +"id": "ListGroupsResponse", +"properties": { +"groups": { +"description": "The requested groups.", +"items": { +"$ref": "Group" +}, +"type": "array" +}, +"nextPageToken": { +"description": "The token for the next page of the response. To see more results, use this value as the page_token for your next request. If this value is empty, there are no more results.", +"type": "string" +}, +"unreachable": { +"description": "Hubs that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListHubSpokesResponse": { +"description": "The response for HubService.ListHubSpokes.", +"id": "ListHubSpokesResponse", +"properties": { +"nextPageToken": { +"description": "The token for the next page of the response. To see more results, use this value as the page_token for your next request. If this value is empty, there are no more results.", +"type": "string" +}, +"spokes": { +"description": "The requested spokes. The spoke fields can be partially populated based on the `view` field in the request message.", +"items": { +"$ref": "Spoke" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListHubsResponse": { +"description": "Response for HubService.ListHubs method.", +"id": "ListHubsResponse", +"properties": { +"hubs": { +"description": "The requested hubs.", +"items": { +"$ref": "Hub" +}, +"type": "array" +}, +"nextPageToken": { +"description": "The token for the next page of the response. To see more results, use this value as the page_token for your next request. If this value is empty, there are no more results.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListInternalRangesResponse": { +"description": "Response for InternalRange.ListInternalRanges", +"id": "ListInternalRangesResponse", +"properties": { +"internalRanges": { +"description": "Internal ranges to be returned.", +"items": { +"$ref": "InternalRange" +}, +"type": "array" +}, +"nextPageToken": { +"description": "The next pagination token in the List response. It should be used as page_token for the following request. An empty value means no more result.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListLocationsResponse": { +"description": "The response message for Locations.ListLocations.", +"id": "ListLocationsResponse", +"properties": { +"locations": { +"description": "A list of locations that matches the specified filter in the request.", +"items": { +"$ref": "Location" +}, +"type": "array" +}, +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +} +}, +"type": "object" +}, +"ListPolicyBasedRoutesResponse": { +"description": "Response for PolicyBasedRoutingService.ListPolicyBasedRoutes method.", +"id": "ListPolicyBasedRoutesResponse", +"properties": { +"nextPageToken": { +"description": "The next pagination token in the List response. It should be used as page_token for the following request. An empty value means no more result.", +"type": "string" +}, +"policyBasedRoutes": { +"description": "Policy-based routes to be returned.", +"items": { +"$ref": "PolicyBasedRoute" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListRegionalEndpointsResponse": { +"description": "Response for ListRegionalEndpoints.", +"id": "ListRegionalEndpointsResponse", +"properties": { +"nextPageToken": { +"description": "The next pagination token in the List response. It should be used as page_token for the following request. An empty value means no more result.", +"type": "string" +}, +"regionalEndpoints": { +"description": "Regional endpoints to be returned.", +"items": { +"$ref": "RegionalEndpoint" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListRouteTablesResponse": { +"description": "Response for HubService.ListRouteTables method.", +"id": "ListRouteTablesResponse", +"properties": { +"nextPageToken": { +"description": "The token for the next page of the response. To see more results, use this value as the page_token for your next request. If this value is empty, there are no more results.", +"type": "string" +}, +"routeTables": { +"description": "The requested route tables.", +"items": { +"$ref": "RouteTable" +}, +"type": "array" +}, +"unreachable": { +"description": "Hubs that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListRoutesResponse": { +"description": "Response for HubService.ListRoutes method.", +"id": "ListRoutesResponse", +"properties": { +"nextPageToken": { +"description": "The token for the next page of the response. To see more results, use this value as the page_token for your next request. If this value is empty, there are no more results.", +"type": "string" +}, +"routes": { +"description": "The requested routes.", +"items": { +"$ref": "Route" +}, +"type": "array" +}, +"unreachable": { +"description": "RouteTables that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListServiceClassesResponse": { +"description": "Response for ListServiceClasses.", +"id": "ListServiceClassesResponse", +"properties": { +"nextPageToken": { +"description": "The next pagination token in the List response. It should be used as page_token for the following request. An empty value means no more result.", +"type": "string" +}, +"serviceClasses": { +"description": "ServiceClasses to be returned.", +"items": { +"$ref": "ServiceClass" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListServiceConnectionMapsResponse": { +"description": "Response for ListServiceConnectionMaps.", +"id": "ListServiceConnectionMapsResponse", +"properties": { +"nextPageToken": { +"description": "The next pagination token in the List response. It should be used as page_token for the following request. An empty value means no more result.", +"type": "string" +}, +"serviceConnectionMaps": { +"description": "ServiceConnectionMaps to be returned.", +"items": { +"$ref": "ServiceConnectionMap" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListServiceConnectionPoliciesResponse": { +"description": "Response for ListServiceConnectionPolicies.", +"id": "ListServiceConnectionPoliciesResponse", +"properties": { +"nextPageToken": { +"description": "The next pagination token in the List response. It should be used as page_token for the following request. An empty value means no more result.", +"type": "string" +}, +"serviceConnectionPolicies": { +"description": "ServiceConnectionPolicies to be returned.", +"items": { +"$ref": "ServiceConnectionPolicy" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListServiceConnectionTokensResponse": { +"description": "Response for ListServiceConnectionTokens.", +"id": "ListServiceConnectionTokensResponse", +"properties": { +"nextPageToken": { +"description": "The next pagination token in the List response. It should be used as page_token for the following request. An empty value means no more result.", +"type": "string" +}, +"serviceConnectionTokens": { +"description": "ServiceConnectionTokens to be returned.", +"items": { +"$ref": "ServiceConnectionToken" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListSpokesResponse": { +"description": "The response for HubService.ListSpokes.", +"id": "ListSpokesResponse", +"properties": { +"nextPageToken": { +"description": "The token for the next page of the response. To see more results, use this value as the page_token for your next request. If this value is empty, there are no more results.", +"type": "string" +}, +"spokes": { +"description": "The requested spokes.", +"items": { +"$ref": "Spoke" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Location": { +"description": "A resource that represents a Google Cloud location.", +"id": "Location", +"properties": { +"displayName": { +"description": "The friendly name for this location, typically a nearby city name. For example, \"Tokyo\".", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Cross-service attributes for the location. For example {\"cloud.googleapis.com/region\": \"us-east1\"}", +"type": "object" +}, +"locationId": { +"description": "The canonical id for this location. For example: `\"us-east1\"`.", +"type": "string" +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata. For example the available capacity at the given location.", +"type": "object" +}, +"name": { +"description": "Resource name for the location, which may vary between implementations. For example: `\"projects/example-project/locations/us-east1\"`", +"type": "string" +} +}, +"type": "object" +}, +"LocationMetadata": { +"description": "Metadata about locations", +"id": "LocationMetadata", +"properties": { +"locationFeatures": { +"description": "List of supported features", +"items": { +"enum": [ +"LOCATION_FEATURE_UNSPECIFIED", +"SITE_TO_CLOUD_SPOKES", +"SITE_TO_SITE_SPOKES" +], +"enumDescriptions": [ +"No publicly supported feature in this location", +"Site-to-cloud spokes are supported in this location", +"Site-to-site spokes are supported in this location" +], +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Migration": { +"description": "Specification for migration with source and target resource names.", +"id": "Migration", +"properties": { +"source": { +"description": "Immutable. Resource path as an URI of the source resource, for example a subnet. The project for the source resource should match the project for the InternalRange. An example: /projects/{project}/regions/{region}/subnetworks/{subnet}", +"type": "string" +}, +"target": { +"description": "Immutable. Resource path of the target resource. The target project can be different, as in the cases when migrating to peer networks. The resource For example: /projects/{project}/regions/{region}/subnetworks/{subnet}", +"type": "string" +} +}, +"type": "object" +}, +"NextHopInterconnectAttachment": { +"description": "A route next hop that leads to an interconnect attachment resource.", +"id": "NextHopInterconnectAttachment", +"properties": { +"siteToSiteDataTransfer": { +"description": "Indicates whether site-to-site data transfer is allowed for this interconnect attachment resource. Data transfer is available only in [supported locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).", +"type": "boolean" +}, +"uri": { +"description": "The URI of the interconnect attachment resource.", +"type": "string" +}, +"vpcNetwork": { +"description": "The VPC network where this interconnect attachment is located.", +"type": "string" +} +}, +"type": "object" +}, +"NextHopRouterApplianceInstance": { +"description": "A route next hop that leads to a Router appliance instance.", +"id": "NextHopRouterApplianceInstance", +"properties": { +"siteToSiteDataTransfer": { +"description": "Indicates whether site-to-site data transfer is allowed for this Router appliance instance resource. Data transfer is available only in [supported locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).", +"type": "boolean" +}, +"uri": { +"description": "The URI of the Router appliance instance.", +"type": "string" +}, +"vpcNetwork": { +"description": "The VPC network where this VM is located.", +"type": "string" +} +}, +"type": "object" +}, +"NextHopVPNTunnel": { +"description": "A route next hop that leads to a VPN tunnel resource.", +"id": "NextHopVPNTunnel", +"properties": { +"siteToSiteDataTransfer": { +"description": "Indicates whether site-to-site data transfer is allowed for this VPN tunnel resource. Data transfer is available only in [supported locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations).", +"type": "boolean" +}, +"uri": { +"description": "The URI of the VPN tunnel resource.", +"type": "string" +}, +"vpcNetwork": { +"description": "The VPC network where this VPN tunnel is located.", +"type": "string" +} +}, +"type": "object" +}, +"NextHopVpcNetwork": { +"id": "NextHopVpcNetwork", +"properties": { +"uri": { +"description": "The URI of the VPC network resource", +"type": "string" +} +}, +"type": "object" +}, +"OperationMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "OperationMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"requestedCancellation": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have been cancelled successfully have google.longrunning.Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"statusMessage": { +"description": "Output only. Human-readable status of the operation, if any.", +"readOnly": true, +"type": "string" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Policy": { +"description": "An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** ``` { \"bindings\": [ { \"role\": \"roles/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike@example.com\", \"group:admins@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles/resourcemanager.organizationViewer\", \"members\": [ \"user:eve@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time < timestamp('2020-10-01T00:00:00.000Z')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 } ``` **YAML example:** ``` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 ``` For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).", +"id": "Policy", +"properties": { +"auditConfigs": { +"description": "Specifies cloud audit logging configuration for this policy.", +"items": { +"$ref": "AuditConfig" +}, +"type": "array" +}, +"bindings": { +"description": "Associates a list of `members`, or principals, with a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one principal. The `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of these principals can be Google groups. Each occurrence of a principal counts towards these limits. For example, if the `bindings` grant 50 different roles to `user:alice@example.com`, and not to any other principal, then you can add another 1,450 principals to the `bindings` in the `Policy`.", +"items": { +"$ref": "Binding" +}, +"type": "array" +}, +"etag": { +"description": "`etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.", +"format": "byte", +"type": "string" +}, +"version": { +"description": "Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"PolicyBasedRoute": { +"description": "Policy-based routes route L4 network traffic based on not just destination IP address, but also source IP address, protocol, and more. If a policy-based route conflicts with other types of routes, the policy-based route always takes precedence.", +"id": "PolicyBasedRoute", +"properties": { +"createTime": { +"description": "Output only. Time when the policy-based route was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. An optional description of this resource. Provide this field when you create the resource.", +"type": "string" +}, +"filter": { +"$ref": "Filter", +"description": "Required. The filter to match L4 traffic." +}, +"interconnectAttachment": { +"$ref": "InterconnectAttachment", +"description": "Optional. The interconnect attachments that this policy-based route applies to." +}, +"kind": { +"description": "Output only. Type of this resource. Always networkconnectivity#policyBasedRoute for policy-based Route resources.", +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "User-defined labels.", +"type": "object" +}, +"name": { +"description": "Immutable. A unique name of the resource in the form of `projects/{project_number}/locations/global/PolicyBasedRoutes/{policy_based_route_id}`", +"type": "string" +}, +"network": { +"description": "Required. Fully-qualified URL of the network that this route applies to, for example: projects/my-project/global/networks/my-network.", +"type": "string" +}, +"nextHopIlbIp": { +"description": "Optional. The IP address of a global-access-enabled L4 ILB that is the next hop for matching packets. For this version, only nextHopIlbIp is supported.", +"type": "string" +}, +"nextHopOtherRoutes": { +"description": "Optional. Other routes that will be referenced to determine the next hop of the packet.", +"enum": [ +"OTHER_ROUTES_UNSPECIFIED", +"DEFAULT_ROUTING" +], +"enumDescriptions": [ +"Default value.", +"Use the routes from the default routing tables (system-generated routes, custom routes, peering route) to determine the next hop. This effectively excludes matching packets being applied on other PBRs with a lower priority." +], +"type": "string" +}, +"priority": { +"description": "Optional. The priority of this policy-based route. Priority is used to break ties in cases where there are more than one matching policy-based routes found. In cases where multiple policy-based routes are matched, the one with the lowest-numbered priority value wins. The default value is 1000. The priority value must be from 1 to 65535, inclusive.", +"format": "int32", +"type": "integer" +}, +"selfLink": { +"description": "Output only. Server-defined fully-qualified URL for this resource.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Time when the policy-based route was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"virtualMachine": { +"$ref": "VirtualMachine", +"description": "Optional. VM instances that this policy-based route applies to." +}, +"warnings": { +"description": "Output only. If potential misconfigurations are detected for this route, this field will be populated with warning messages.", +"items": { +"$ref": "Warnings" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"ProducerPscConfig": { +"description": "The PSC configurations on producer side.", +"id": "ProducerPscConfig", +"properties": { +"serviceAttachmentUri": { +"description": "The resource path of a service attachment. Example: projects/{projectNumOrId}/regions/{region}/serviceAttachments/{resourceId}.", +"type": "string" +} +}, +"type": "object" +}, +"PscConfig": { +"description": "Configuration used for Private Service Connect connections. Used when Infrastructure is PSC.", +"id": "PscConfig", +"properties": { +"allowedGoogleProducersResourceHierarchyLevel": { +"description": "Optional. List of Projects, Folders, or Organizations from where the Producer instance can be within. For example, a network administrator can provide both 'organizations/foo' and 'projects/bar' as allowed_google_producers_resource_hierarchy_levels. This allowlists this network to connect with any Producer instance within the 'foo' organization or the 'bar' project. By default, allowed_google_producers_resource_hierarchy_level is empty. The format for each allowed_google_producers_resource_hierarchy_level is / where is one of 'projects', 'folders', or 'organizations' and is either the ID or the number of the resource type. Format for each allowed_google_producers_resource_hierarchy_level value: 'projects/' or 'folders/' or 'organizations/' Eg. [projects/my-project-id, projects/567, folders/891, organizations/123]", +"items": { +"type": "string" +}, +"type": "array" +}, +"limit": { +"description": "Optional. Max number of PSC connections for this policy.", +"format": "int64", +"type": "string" +}, +"producerInstanceLocation": { +"description": "Required. ProducerInstanceLocation is used to specify which authorization mechanism to use to determine which projects the Producer instance can be within.", +"enum": [ +"PRODUCER_INSTANCE_LOCATION_UNSPECIFIED", +"CUSTOM_RESOURCE_HIERARCHY_LEVELS" +], +"enumDescriptions": [ +"Producer instance location is not specified. When this option is chosen, then the PSC connections created by this ServiceConnectionPolicy must be within the same project as the Producer instance. This is the default ProducerInstanceLocation value. To allow for PSC connections from this network to other networks, use the CUSTOM_RESOURCE_HIERARCHY_LEVELS option.", +"Producer instance must be within one of the values provided in allowed_google_producers_resource_hierarchy_level." +], +"type": "string" +}, +"subnetworks": { +"description": "The resource paths of subnetworks to use for IP address management. Example: projects/{projectNumOrId}/regions/{region}/subnetworks/{resourceId}.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"PscConnection": { +"description": "Information about a specific Private Service Connect connection.", +"id": "PscConnection", +"properties": { +"consumerAddress": { +"description": "The resource reference of the consumer address.", +"type": "string" +}, +"consumerForwardingRule": { +"description": "The resource reference of the PSC Forwarding Rule within the consumer VPC.", +"type": "string" +}, +"consumerTargetProject": { +"description": "The project where the PSC connection is created.", +"type": "string" +}, +"error": { +"$ref": "GoogleRpcStatus", +"deprecated": true, +"description": "The most recent error during operating this connection. Deprecated, please use error_info instead." +}, +"errorInfo": { +"$ref": "GoogleRpcErrorInfo", +"description": "Output only. The error info for the latest error during operating this connection.", +"readOnly": true +}, +"errorType": { +"deprecated": true, +"description": "The error type indicates whether the error is consumer facing, producer facing or system internal.", +"enum": [ +"CONNECTION_ERROR_TYPE_UNSPECIFIED", +"ERROR_INTERNAL", +"ERROR_CONSUMER_SIDE", +"ERROR_PRODUCER_SIDE" +], +"enumDescriptions": [ +"An invalid error type as the default case.", +"The error is due to Service Automation system internal.", +"The error is due to the setup on consumer side.", +"The error is due to the setup on producer side." +], +"type": "string" +}, +"gceOperation": { +"description": "The last Compute Engine operation to setup PSC connection.", +"type": "string" +}, +"ipVersion": { +"description": "The requested IP version for the PSC connection.", +"enum": [ +"IP_VERSION_UNSPECIFIED", +"IPV4", +"IPV6" +], +"enumDescriptions": [ +"Default value. We will use IPv4 or IPv6 depending on the IP version of first available subnetwork.", +"Will use IPv4 only.", +"Will use IPv6 only." +], +"type": "string" +}, +"producerInstanceId": { +"deprecated": true, +"description": "Immutable. Deprecated. Use producer_instance_metadata instead. An immutable identifier for the producer instance.", +"type": "string" +}, +"producerInstanceMetadata": { +"additionalProperties": { +"type": "string" +}, +"description": "Immutable. An immutable map for the producer instance metadata.", +"type": "object" +}, +"pscConnectionId": { +"description": "The PSC connection id of the PSC forwarding rule.", +"type": "string" +}, +"selectedSubnetwork": { +"description": "Output only. The URI of the subnetwork selected to allocate IP address for this connection.", +"readOnly": true, +"type": "string" +}, +"serviceClass": { +"description": "Output only. [Output only] The service class associated with this PSC Connection. The value is derived from the SCPolicy and matches the service class name provided by the customer.", +"readOnly": true, +"type": "string" +}, +"state": { +"description": "State of the PSC Connection", +"enum": [ +"STATE_UNSPECIFIED", +"ACTIVE", +"FAILED", +"CREATING", +"DELETING", +"CREATE_REPAIRING", +"DELETE_REPAIRING" +], +"enumDescriptions": [ +"An invalid state as the default case.", +"The connection has been created successfully. However, for the up-to-date connection status, please use the created forwarding rule's \"PscConnectionStatus\" as the source of truth.", +"The connection is not functional since some resources on the connection fail to be created.", +"The connection is being created.", +"The connection is being deleted.", +"The connection is being repaired to complete creation.", +"The connection is being repaired to complete deletion." +], +"type": "string" +} +}, +"type": "object" +}, +"PscPropagationStatus": { +"description": "The status of one or more propagated Private Service Connect connections in a hub.", +"id": "PscPropagationStatus", +"properties": { +"code": { +"description": "The propagation status.", +"enum": [ +"CODE_UNSPECIFIED", +"READY", +"PROPAGATING", +"ERROR_PRODUCER_PROPAGATED_CONNECTION_LIMIT_EXCEEDED", +"ERROR_PRODUCER_NAT_IP_SPACE_EXHAUSTED", +"ERROR_PRODUCER_QUOTA_EXCEEDED", +"ERROR_CONSUMER_QUOTA_EXCEEDED" +], +"enumDescriptions": [ +"The code is unspecified.", +"The propagated Private Service Connect connection is ready.", +"The Private Service Connect connection is propagating. This is a transient state.", +"The Private Service Connect connection propagation failed because the VPC network or the project of the target spoke has exceeded the connection limit set by the producer.", +"The Private Service Connect connection propagation failed because the NAT IP subnet space has been exhausted. It is equivalent to the `Needs attention` status of the Private Service Connect connection. See https://cloud.google.com/vpc/docs/about-accessing-vpc-hosted-services-endpoints#connection-statuses.", +"The Private Service Connect connection propagation failed because the `PSC_ILB_CONSUMER_FORWARDING_RULES_PER_PRODUCER_NETWORK` quota in the producer VPC network has been exceeded.", +"The Private Service Connect connection propagation failed because the `PSC_PROPAGATED_CONNECTIONS_PER_VPC_NETWORK` quota in the consumer VPC network has been exceeded." +], +"type": "string" +}, +"message": { +"description": "The human-readable summary of the Private Service Connect connection propagation status.", +"type": "string" +}, +"sourceForwardingRule": { +"description": "The name of the forwarding rule exported to the hub.", +"type": "string" +}, +"sourceGroup": { +"description": "The name of the group that the source spoke belongs to.", +"type": "string" +}, +"sourceSpoke": { +"description": "The name of the spoke that the source forwarding rule belongs to.", +"type": "string" +}, +"targetGroup": { +"description": "The name of the group that the target spoke belongs to.", +"type": "string" +}, +"targetSpoke": { +"description": "The name of the spoke that the source forwarding rule propagates to.", +"type": "string" +} +}, +"type": "object" +}, +"QueryHubStatusResponse": { +"description": "The response for HubService.QueryHubStatus.", +"id": "QueryHubStatusResponse", +"properties": { +"hubStatusEntries": { +"description": "The list of hub status.", +"items": { +"$ref": "HubStatusEntry" +}, +"type": "array" +}, +"nextPageToken": { +"description": "The token for the next page of the response. To see more results, use this value as the page_token for your next request. If this value is empty, there are no more results.", +"type": "string" +} +}, +"type": "object" +}, +"RegionalEndpoint": { +"description": "The RegionalEndpoint resource.", +"id": "RegionalEndpoint", +"properties": { +"accessType": { +"description": "Required. The access type of this regional endpoint. This field is reflected in the PSC Forwarding Rule configuration to enable global access.", +"enum": [ +"ACCESS_TYPE_UNSPECIFIED", +"GLOBAL", +"REGIONAL" +], +"enumDescriptions": [ +"An invalid type as the default case.", +"This regional endpoint is accessible from all regions.", +"This regional endpoint is only accessible from the same region where it resides." +], +"type": "string" +}, +"address": { +"description": "Optional. The IP Address of the Regional Endpoint. When no address is provided, an IP from the subnetwork is allocated. Use one of the following formats: * IPv4 address as in `10.0.0.1` * Address resource URI as in `projects/{project}/regions/{region}/addresses/{address_name}` for an IPv4 or IPv6 address.", +"type": "string" +}, +"createTime": { +"description": "Output only. Time when the RegionalEndpoint was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. A description of this resource.", +"type": "string" +}, +"ipAddress": { +"deprecated": true, +"description": "Output only. The literal IP address of the PSC Forwarding Rule created on behalf of the customer. This field is deprecated. Use address instead.", +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "User-defined labels.", +"type": "object" +}, +"name": { +"description": "Output only. The name of a RegionalEndpoint. Format: `projects/{project}/locations/{location}/regionalEndpoints/{regional_endpoint}`.", +"readOnly": true, +"type": "string" +}, +"network": { +"description": "The name of the VPC network for this private regional endpoint. Format: `projects/{project}/global/networks/{network}`", +"type": "string" +}, +"pscForwardingRule": { +"description": "Output only. The resource reference of the PSC Forwarding Rule created on behalf of the customer. Format: `//compute.googleapis.com/projects/{project}/regions/{region}/forwardingRules/{forwarding_rule_name}`", +"readOnly": true, +"type": "string" +}, +"subnetwork": { +"description": "The name of the subnetwork from which the IP address will be allocated. Format: `projects/{project}/regions/{region}/subnetworks/{subnetwork}`", +"type": "string" +}, +"targetGoogleApi": { +"description": "Required. The service endpoint this private regional endpoint connects to. Format: `{apiname}.{region}.p.rep.googleapis.com` Example: \"cloudkms.us-central1.p.rep.googleapis.com\".", +"type": "string" +}, +"updateTime": { +"description": "Output only. Time when the RegionalEndpoint was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"RejectHubSpokeRequest": { +"description": "The request for HubService.RejectHubSpoke.", +"id": "RejectHubSpokeRequest", +"properties": { +"details": { +"description": "Optional. Additional information provided by the hub administrator.", +"type": "string" +}, +"requestId": { +"description": "Optional. A request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server knows to ignore the request if it has already been completed. The server guarantees that a request doesn't result in creation of duplicate commitments for at least 60 minutes. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check to see whether the original operation was received. If it was, the server ignores the second request. This behavior prevents clients from mistakenly creating duplicate commitments. The request ID must be a valid UUID, with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"type": "string" +}, +"spokeUri": { +"description": "Required. The URI of the spoke to reject from the hub.", +"type": "string" +} +}, +"type": "object" +}, +"RejectHubSpokeResponse": { +"description": "The response for HubService.RejectHubSpoke.", +"id": "RejectHubSpokeResponse", +"properties": { +"spoke": { +"$ref": "Spoke", +"description": "The spoke that was operated on." +} +}, +"type": "object" +}, +"Route": { +"description": "A route defines a path from VM instances within a spoke to a specific destination resource. Only VPC spokes have routes.", +"id": "Route", +"properties": { +"createTime": { +"description": "Output only. The time the route was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "An optional description of the route.", +"type": "string" +}, +"ipCidrRange": { +"description": "The destination IP address range.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional labels in key-value pair format. For more information about labels, see [Requirements for labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).", +"type": "object" +}, +"location": { +"description": "Output only. The origin location of the route. Uses the following form: \"projects/{project}/locations/{location}\" Example: projects/1234/locations/us-central1", +"readOnly": true, +"type": "string" +}, +"name": { +"description": "Immutable. The name of the route. Route names must be unique. Route names use the following form: `projects/{project_number}/locations/global/hubs/{hub}/routeTables/{route_table_id}/routes/{route_id}`", +"type": "string" +}, +"nextHopInterconnectAttachment": { +"$ref": "NextHopInterconnectAttachment", +"description": "Immutable. The next-hop VLAN attachment for packets on this route." +}, +"nextHopRouterApplianceInstance": { +"$ref": "NextHopRouterApplianceInstance", +"description": "Immutable. The next-hop Router appliance instance for packets on this route." +}, +"nextHopVpcNetwork": { +"$ref": "NextHopVpcNetwork", +"description": "Immutable. The destination VPC network for packets on this route." +}, +"nextHopVpnTunnel": { +"$ref": "NextHopVPNTunnel", +"description": "Immutable. The next-hop VPN tunnel for packets on this route." +}, +"priority": { +"description": "Output only. The priority of this route. Priority is used to break ties in cases where a destination matches more than one route. In these cases the route with the lowest-numbered priority value wins.", +"format": "int64", +"readOnly": true, +"type": "string" +}, +"spoke": { +"description": "Immutable. The spoke that this route leads to. Example: projects/12345/locations/global/spokes/SPOKE", +"type": "string" +}, +"state": { +"description": "Output only. The current lifecycle state of the route.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"DELETING", +"ACCEPTING", +"REJECTING", +"UPDATING", +"INACTIVE", +"OBSOLETE" +], +"enumDescriptions": [ +"No state information available", +"The resource's create operation is in progress.", +"The resource is active", +"The resource's delete operation is in progress.", +"The resource's accept operation is in progress.", +"The resource's reject operation is in progress.", +"The resource's update operation is in progress.", +"The resource is inactive.", +"The hub associated with this spoke resource has been deleted. This state applies to spoke resources only." +], +"readOnly": true, +"type": "string" +}, +"type": { +"description": "Output only. The route's type. Its type is determined by the properties of its IP address range.", +"enum": [ +"ROUTE_TYPE_UNSPECIFIED", +"VPC_PRIMARY_SUBNET", +"VPC_SECONDARY_SUBNET", +"DYNAMIC_ROUTE" +], +"enumDescriptions": [ +"No route type information specified", +"The route leads to a destination within the primary address range of the VPC network's subnet.", +"The route leads to a destination within the secondary address range of the VPC network's subnet.", +"The route leads to a destination in a dynamic route. Dynamic routes are derived from Border Gateway Protocol (BGP) advertisements received from an NCC hybrid spoke." +], +"readOnly": true, +"type": "string" +}, +"uid": { +"description": "Output only. The Google-generated UUID for the route. This value is unique across all Network Connectivity Center route resources. If a route is deleted and another with the same name is created, the new route is assigned a different `uid`.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time the route was last updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"RouteTable": { +"id": "RouteTable", +"properties": { +"createTime": { +"description": "Output only. The time the route table was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "An optional description of the route table.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional labels in key-value pair format. For more information about labels, see [Requirements for labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).", +"type": "object" +}, +"name": { +"description": "Immutable. The name of the route table. Route table names must be unique. They use the following form: `projects/{project_number}/locations/global/hubs/{hub}/routeTables/{route_table_id}`", +"type": "string" +}, +"state": { +"description": "Output only. The current lifecycle state of this route table.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"DELETING", +"ACCEPTING", +"REJECTING", +"UPDATING", +"INACTIVE", +"OBSOLETE" +], +"enumDescriptions": [ +"No state information available", +"The resource's create operation is in progress.", +"The resource is active", +"The resource's delete operation is in progress.", +"The resource's accept operation is in progress.", +"The resource's reject operation is in progress.", +"The resource's update operation is in progress.", +"The resource is inactive.", +"The hub associated with this spoke resource has been deleted. This state applies to spoke resources only." +], +"readOnly": true, +"type": "string" +}, +"uid": { +"description": "Output only. The Google-generated UUID for the route table. This value is unique across all route table resources. If a route table is deleted and another with the same name is created, the new route table is assigned a different `uid`.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time the route table was last updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"RouterApplianceInstance": { +"description": "A router appliance instance is a Compute Engine virtual machine (VM) instance that acts as a BGP speaker. A router appliance instance is specified by the URI of the VM and the internal IP address of one of the VM's network interfaces.", +"id": "RouterApplianceInstance", +"properties": { +"ipAddress": { +"description": "The IP address on the VM to use for peering.", +"type": "string" +}, +"virtualMachine": { +"description": "The URI of the VM.", +"type": "string" +} +}, +"type": "object" +}, +"RoutingVPC": { +"description": "RoutingVPC contains information about the VPC networks associated with the spokes of a Network Connectivity Center hub.", +"id": "RoutingVPC", +"properties": { +"requiredForNewSiteToSiteDataTransferSpokes": { +"description": "Output only. If true, indicates that this VPC network is currently associated with spokes that use the data transfer feature (spokes where the site_to_site_data_transfer field is set to true). If you create new spokes that use data transfer, they must be associated with this VPC network. At most, one VPC network will have this field set to true.", +"readOnly": true, +"type": "boolean" +}, +"uri": { +"description": "The URI of the VPC network.", +"type": "string" +} +}, +"type": "object" +}, +"ServiceClass": { +"description": "The ServiceClass resource.", +"id": "ServiceClass", +"properties": { +"createTime": { +"description": "Output only. Time when the ServiceClass was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "A description of this resource.", +"type": "string" +}, +"etag": { +"description": "Optional. The etag is computed by the server, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "User-defined labels.", +"type": "object" +}, +"name": { +"description": "Immutable. The name of a ServiceClass resource. Format: projects/{project}/locations/{location}/serviceClasses/{service_class} See: https://google.aip.dev/122#fields-representing-resource-names", +"type": "string" +}, +"serviceClass": { +"description": "Output only. The generated service class name. Use this name to refer to the Service class in Service Connection Maps and Service Connection Policies.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Time when the ServiceClass was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ServiceConnectionMap": { +"description": "The ServiceConnectionMap resource.", +"id": "ServiceConnectionMap", +"properties": { +"consumerPscConfigs": { +"description": "The PSC configurations on consumer side.", +"items": { +"$ref": "ConsumerPscConfig" +}, +"type": "array" +}, +"consumerPscConnections": { +"description": "Output only. PSC connection details on consumer side.", +"items": { +"$ref": "ConsumerPscConnection" +}, +"readOnly": true, +"type": "array" +}, +"createTime": { +"description": "Output only. Time when the ServiceConnectionMap was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "A description of this resource.", +"type": "string" +}, +"etag": { +"description": "Optional. The etag is computed by the server, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"type": "string" +}, +"infrastructure": { +"description": "Output only. The infrastructure used for connections between consumers/producers.", +"enum": [ +"INFRASTRUCTURE_UNSPECIFIED", +"PSC" +], +"enumDescriptions": [ +"An invalid infrastructure as the default case.", +"Private Service Connect is used for connections." +], +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "User-defined labels.", +"type": "object" +}, +"name": { +"description": "Immutable. The name of a ServiceConnectionMap. Format: projects/{project}/locations/{location}/serviceConnectionMaps/{service_connection_map} See: https://google.aip.dev/122#fields-representing-resource-names", +"type": "string" +}, +"producerPscConfigs": { +"description": "The PSC configurations on producer side.", +"items": { +"$ref": "ProducerPscConfig" +}, +"type": "array" +}, +"serviceClass": { +"description": "The service class identifier this ServiceConnectionMap is for. The user of ServiceConnectionMap create API needs to have networkconnecitivty.serviceclasses.use iam permission for the service class.", +"type": "string" +}, +"serviceClassUri": { +"description": "Output only. The service class uri this ServiceConnectionMap is for.", +"readOnly": true, +"type": "string" +}, +"token": { +"description": "The token provided by the consumer. This token authenticates that the consumer can create a connection within the specified project and network.", +"type": "string" +}, +"updateTime": { +"description": "Output only. Time when the ServiceConnectionMap was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ServiceConnectionPolicy": { +"description": "The ServiceConnectionPolicy resource.", +"id": "ServiceConnectionPolicy", +"properties": { +"createTime": { +"description": "Output only. Time when the ServiceConnectionPolicy was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "A description of this resource.", +"type": "string" +}, +"etag": { +"description": "Optional. The etag is computed by the server, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"type": "string" +}, +"infrastructure": { +"description": "Output only. The type of underlying resources used to create the connection.", +"enum": [ +"INFRASTRUCTURE_UNSPECIFIED", +"PSC" +], +"enumDescriptions": [ +"An invalid infrastructure as the default case.", +"Private Service Connect is used for connections." +], +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "User-defined labels.", +"type": "object" +}, +"name": { +"description": "Immutable. The name of a ServiceConnectionPolicy. Format: projects/{project}/locations/{location}/serviceConnectionPolicies/{service_connection_policy} See: https://google.aip.dev/122#fields-representing-resource-names", +"type": "string" +}, +"network": { +"description": "The resource path of the consumer network. Example: - projects/{projectNumOrId}/global/networks/{resourceId}.", +"type": "string" +}, +"pscConfig": { +"$ref": "PscConfig", +"description": "Configuration used for Private Service Connect connections. Used when Infrastructure is PSC." +}, +"pscConnections": { +"description": "Output only. [Output only] Information about each Private Service Connect connection.", +"items": { +"$ref": "PscConnection" +}, +"readOnly": true, +"type": "array" +}, +"serviceClass": { +"description": "The service class identifier for which this ServiceConnectionPolicy is for. The service class identifier is a unique, symbolic representation of a ServiceClass. It is provided by the Service Producer. Google services have a prefix of gcp or google-cloud. For example, gcp-memorystore-redis or google-cloud-sql. 3rd party services do not. For example, test-service-a3dfcx.", +"type": "string" +}, +"updateTime": { +"description": "Output only. Time when the ServiceConnectionPolicy was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ServiceConnectionToken": { +"description": "The ServiceConnectionToken resource.", +"id": "ServiceConnectionToken", +"properties": { +"createTime": { +"description": "Output only. Time when the ServiceConnectionToken was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "A description of this resource.", +"type": "string" +}, +"etag": { +"description": "Optional. The etag is computed by the server, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"type": "string" +}, +"expireTime": { +"description": "Output only. The time to which this token is valid.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "User-defined labels.", +"type": "object" +}, +"name": { +"description": "Immutable. The name of a ServiceConnectionToken. Format: projects/{project}/locations/{location}/ServiceConnectionTokens/{service_connection_token} See: https://google.aip.dev/122#fields-representing-resource-names", +"type": "string" +}, +"network": { +"description": "The resource path of the network associated with this token. Example: projects/{projectNumOrId}/global/networks/{resourceId}.", +"type": "string" +}, +"token": { +"description": "Output only. The token generated by Automation.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Time when the ServiceConnectionToken was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"SetIamPolicyRequest": { +"description": "Request message for `SetIamPolicy` method.", +"id": "SetIamPolicyRequest", +"properties": { +"policy": { +"$ref": "Policy", +"description": "REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them." +}, +"updateMask": { +"description": "OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only the fields in the mask will be modified. If no mask is provided, the following default mask is used: `paths: \"bindings, etag\"`", +"format": "google-fieldmask", +"type": "string" +} +}, +"type": "object" +}, +"Spoke": { +"description": "A Network Connectivity Center spoke represents one or more network connectivity resources. When you create a spoke, you associate it with a hub. You must also identify a value for exactly one of the following fields: * linked_vpn_tunnels * linked_interconnect_attachments * linked_router_appliance_instances * linked_vpc_network", +"id": "Spoke", +"properties": { +"createTime": { +"description": "Output only. The time the spoke was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. An optional description of the spoke.", +"type": "string" +}, +"group": { +"description": "Optional. The name of the group that this spoke is associated with.", +"type": "string" +}, +"hub": { +"description": "Immutable. The name of the hub that this spoke is attached to.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional labels in key-value pair format. For more information about labels, see [Requirements for labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).", +"type": "object" +}, +"linkedInterconnectAttachments": { +"$ref": "LinkedInterconnectAttachments", +"description": "Optional. VLAN attachments that are associated with the spoke." +}, +"linkedProducerVpcNetwork": { +"$ref": "LinkedProducerVpcNetwork", +"description": "Optional. The linked producer VPC that is associated with the spoke." +}, +"linkedRouterApplianceInstances": { +"$ref": "LinkedRouterApplianceInstances", +"description": "Optional. Router appliance instances that are associated with the spoke." +}, +"linkedVpcNetwork": { +"$ref": "LinkedVpcNetwork", +"description": "Optional. VPC network that is associated with the spoke." +}, +"linkedVpnTunnels": { +"$ref": "LinkedVpnTunnels", +"description": "Optional. VPN tunnels that are associated with the spoke." +}, +"name": { +"description": "Immutable. The name of the spoke. Spoke names must be unique. They use the following form: `projects/{project_number}/locations/{region}/spokes/{spoke_id}`", +"type": "string" +}, +"reasons": { +"description": "Output only. The reasons for current state of the spoke.", +"items": { +"$ref": "StateReason" +}, +"readOnly": true, +"type": "array" +}, +"spokeType": { +"description": "Output only. The type of resource associated with the spoke.", +"enum": [ +"SPOKE_TYPE_UNSPECIFIED", +"VPN_TUNNEL", +"INTERCONNECT_ATTACHMENT", +"ROUTER_APPLIANCE", +"VPC_NETWORK", +"PRODUCER_VPC_NETWORK" +], +"enumDescriptions": [ +"Unspecified spoke type.", +"Spokes associated with VPN tunnels.", +"Spokes associated with VLAN attachments.", +"Spokes associated with router appliance instances.", +"Spokes associated with VPC networks.", +"Spokes that are backed by a producer VPC network." +], +"readOnly": true, +"type": "string" +}, +"state": { +"description": "Output only. The current lifecycle state of this spoke.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"DELETING", +"ACCEPTING", +"REJECTING", +"UPDATING", +"INACTIVE", +"OBSOLETE" +], +"enumDescriptions": [ +"No state information available", +"The resource's create operation is in progress.", +"The resource is active", +"The resource's delete operation is in progress.", +"The resource's accept operation is in progress.", +"The resource's reject operation is in progress.", +"The resource's update operation is in progress.", +"The resource is inactive.", +"The hub associated with this spoke resource has been deleted. This state applies to spoke resources only." +], +"readOnly": true, +"type": "string" +}, +"uniqueId": { +"description": "Output only. The Google-generated UUID for the spoke. This value is unique across all spoke resources. If a spoke is deleted and another with the same name is created, the new spoke is assigned a different `unique_id`.", +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time the spoke was last updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"SpokeStateCount": { +"description": "The number of spokes that are in a particular state and associated with a given hub.", +"id": "SpokeStateCount", +"properties": { +"count": { +"description": "Output only. The total number of spokes that are in this state and associated with a given hub.", +"format": "int64", +"readOnly": true, +"type": "string" +}, +"state": { +"description": "Output only. The state of the spokes.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"DELETING", +"ACCEPTING", +"REJECTING", +"UPDATING", +"INACTIVE", +"OBSOLETE" +], +"enumDescriptions": [ +"No state information available", +"The resource's create operation is in progress.", +"The resource is active", +"The resource's delete operation is in progress.", +"The resource's accept operation is in progress.", +"The resource's reject operation is in progress.", +"The resource's update operation is in progress.", +"The resource is inactive.", +"The hub associated with this spoke resource has been deleted. This state applies to spoke resources only." +], +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"SpokeStateReasonCount": { +"description": "The number of spokes in the hub that are inactive for this reason.", +"id": "SpokeStateReasonCount", +"properties": { +"count": { +"description": "Output only. The total number of spokes that are inactive for a particular reason and associated with a given hub.", +"format": "int64", +"readOnly": true, +"type": "string" +}, +"stateReasonCode": { +"description": "Output only. The reason that a spoke is inactive.", +"enum": [ +"CODE_UNSPECIFIED", +"PENDING_REVIEW", +"REJECTED", +"PAUSED", +"FAILED", +"UPDATE_PENDING_REVIEW", +"UPDATE_REJECTED", +"UPDATE_FAILED" +], +"enumDescriptions": [ +"No information available.", +"The proposed spoke is pending review.", +"The proposed spoke has been rejected by the hub administrator.", +"The spoke has been deactivated internally.", +"Network Connectivity Center encountered errors while accepting the spoke.", +"The proposed spoke update is pending review.", +"The proposed spoke update has been rejected by the hub administrator.", +"Network Connectivity Center encountered errors while accepting the spoke update." +], +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"SpokeSummary": { +"description": "Summarizes information about the spokes associated with a hub. The summary includes a count of spokes according to type and according to state. If any spokes are inactive, the summary also lists the reasons they are inactive, including a count for each reason.", +"id": "SpokeSummary", +"properties": { +"spokeStateCounts": { +"description": "Output only. Counts the number of spokes that are in each state and associated with a given hub.", +"items": { +"$ref": "SpokeStateCount" +}, +"readOnly": true, +"type": "array" +}, +"spokeStateReasonCounts": { +"description": "Output only. Counts the number of spokes that are inactive for each possible reason and associated with a given hub.", +"items": { +"$ref": "SpokeStateReasonCount" +}, +"readOnly": true, +"type": "array" +}, +"spokeTypeCounts": { +"description": "Output only. Counts the number of spokes of each type that are associated with a specific hub.", +"items": { +"$ref": "SpokeTypeCount" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"SpokeTypeCount": { +"description": "The number of spokes of a given type that are associated with a specific hub. The type indicates what kind of resource is associated with the spoke.", +"id": "SpokeTypeCount", +"properties": { +"count": { +"description": "Output only. The total number of spokes of this type that are associated with the hub.", +"format": "int64", +"readOnly": true, +"type": "string" +}, +"spokeType": { +"description": "Output only. The type of the spokes.", +"enum": [ +"SPOKE_TYPE_UNSPECIFIED", +"VPN_TUNNEL", +"INTERCONNECT_ATTACHMENT", +"ROUTER_APPLIANCE", +"VPC_NETWORK", +"PRODUCER_VPC_NETWORK" +], +"enumDescriptions": [ +"Unspecified spoke type.", +"Spokes associated with VPN tunnels.", +"Spokes associated with VLAN attachments.", +"Spokes associated with router appliance instances.", +"Spokes associated with VPC networks.", +"Spokes that are backed by a producer VPC network." +], +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"StateReason": { +"description": "The reason a spoke is inactive.", +"id": "StateReason", +"properties": { +"code": { +"description": "The code associated with this reason.", +"enum": [ +"CODE_UNSPECIFIED", +"PENDING_REVIEW", +"REJECTED", +"PAUSED", +"FAILED", +"UPDATE_PENDING_REVIEW", +"UPDATE_REJECTED", +"UPDATE_FAILED" +], +"enumDescriptions": [ +"No information available.", +"The proposed spoke is pending review.", +"The proposed spoke has been rejected by the hub administrator.", +"The spoke has been deactivated internally.", +"Network Connectivity Center encountered errors while accepting the spoke.", +"The proposed spoke update is pending review.", +"The proposed spoke update has been rejected by the hub administrator.", +"Network Connectivity Center encountered errors while accepting the spoke update." +], +"type": "string" +}, +"message": { +"description": "Human-readable details about this reason.", +"type": "string" +}, +"userDetails": { +"description": "Additional information provided by the user in the RejectSpoke call.", +"type": "string" +} +}, +"type": "object" +}, +"TestIamPermissionsRequest": { +"description": "Request message for `TestIamPermissions` method.", +"id": "TestIamPermissionsRequest", +"properties": { +"permissions": { +"description": "The set of permissions to check for the `resource`. Permissions with wildcards (such as `*` or `storage.*`) are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"TestIamPermissionsResponse": { +"description": "Response message for `TestIamPermissions` method.", +"id": "TestIamPermissionsResponse", +"properties": { +"permissions": { +"description": "A subset of `TestPermissionsRequest.permissions` that the caller is allowed.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"VirtualMachine": { +"description": "VM instances that this policy-based route applies to.", +"id": "VirtualMachine", +"properties": { +"tags": { +"description": "Optional. A list of VM instance tags that this policy-based route applies to. VM instances that have ANY of tags specified here installs this PBR.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Warnings": { +"description": "Informational warning message.", +"id": "Warnings", +"properties": { +"code": { +"description": "Output only. A warning code, if applicable.", +"enum": [ +"WARNING_UNSPECIFIED", +"RESOURCE_NOT_ACTIVE", +"RESOURCE_BEING_MODIFIED" +], +"enumDescriptions": [ +"Default value.", +"The policy-based route is not active and functioning. Common causes are that the dependent network was deleted or the resource project was turned off.", +"The policy-based route is being modified (e.g. created/deleted) at this time." +], +"readOnly": true, +"type": "string" +}, +"data": { +"additionalProperties": { +"type": "string" +}, +"description": "Output only. Metadata about this warning in key: value format. The key should provides more detail on the warning being returned. For example, for warnings where there are no results in a list request for a particular zone, this key might be scope and the key value might be the zone name. Other examples might be a key indicating a deprecated resource and a suggested replacement.", +"readOnly": true, +"type": "object" +}, +"warningMessage": { +"description": "Output only. A human-readable description of the warning code.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Network Connectivity API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/networksecurity.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/networksecurity.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..85bb0b5f76687522995eb4c2fdbcfd842313eaef --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/networksecurity.v1.json @@ -0,0 +1,5539 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +} +} +} +}, +"basePath": "", +"baseUrl": "https://networksecurity.googleapis.com/", +"batchPath": "batch", +"canonicalName": "NetworkSecurity", +"description": "", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/networking", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "networksecurity:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://networksecurity.mtls.googleapis.com/", +"name": "networksecurity", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"organizations": { +"resources": { +"locations": { +"resources": { +"addressGroups": { +"methods": { +"addItems": { +"description": "Adds items to an address group.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:addItems", +"httpMethod": "POST", +"id": "networksecurity.organizations.locations.addressGroups.addItems", +"parameterOrder": [ +"addressGroup" +], +"parameters": { +"addressGroup": { +"description": "Required. A name of the AddressGroup to add items to. Must be in the format `projects|organization/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+addressGroup}:addItems", +"request": { +"$ref": "AddAddressGroupItemsRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"cloneItems": { +"description": "Clones items from one address group to another.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:cloneItems", +"httpMethod": "POST", +"id": "networksecurity.organizations.locations.addressGroups.cloneItems", +"parameterOrder": [ +"addressGroup" +], +"parameters": { +"addressGroup": { +"description": "Required. A name of the AddressGroup to clone items to. Must be in the format `projects|organization/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+addressGroup}:cloneItems", +"request": { +"$ref": "CloneAddressGroupItemsRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"create": { +"description": "Creates a new address group in a given project and location.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups", +"httpMethod": "POST", +"id": "networksecurity.organizations.locations.addressGroups.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"addressGroupId": { +"description": "Required. Short name of the AddressGroup resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"authz_policy\".", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource of the AddressGroup. Must be in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/addressGroups", +"request": { +"$ref": "AddressGroup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes an address group.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups/{addressGroupsId}", +"httpMethod": "DELETE", +"id": "networksecurity.organizations.locations.addressGroups.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the AddressGroup to delete. Must be in the format `projects/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single address group.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups/{addressGroupsId}", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.addressGroups.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the AddressGroup to get. Must be in the format `projects/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AddressGroup" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists address groups in a given project and location.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.addressGroups.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of AddressGroups to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last `ListAddressGroupsResponse` Indicates that this is a continuation of a prior `ListAddressGroups` call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the AddressGroups should be listed, specified in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/addressGroups", +"response": { +"$ref": "ListAddressGroupsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"listReferences": { +"description": "Lists references of an address group.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:listReferences", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.addressGroups.listReferences", +"parameterOrder": [ +"addressGroup" +], +"parameters": { +"addressGroup": { +"description": "Required. A name of the AddressGroup to clone items to. Must be in the format `projects|organization/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The maximum number of references to return. If unspecified, server will pick an appropriate default. Server may return fewer items than requested. A caller should only rely on response's next_page_token to determine if there are more AddressGroupUsers left to be queried.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The next_page_token value returned from a previous List request, if any.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+addressGroup}:listReferences", +"response": { +"$ref": "ListAddressGroupReferencesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates parameters of an address group.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups/{addressGroupsId}", +"httpMethod": "PATCH", +"id": "networksecurity.organizations.locations.addressGroups.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the AddressGroup resource. It matches pattern `projects/*/locations/{location}/addressGroups/`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the AddressGroup resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "AddressGroup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"removeItems": { +"description": "Removes items from an address group.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:removeItems", +"httpMethod": "POST", +"id": "networksecurity.organizations.locations.addressGroups.removeItems", +"parameterOrder": [ +"addressGroup" +], +"parameters": { +"addressGroup": { +"description": "Required. A name of the AddressGroup to remove items from. Must be in the format `projects|organization/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+addressGroup}:removeItems", +"request": { +"$ref": "RemoveAddressGroupItemsRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"firewallEndpoints": { +"methods": { +"create": { +"description": "Creates a new FirewallEndpoint in a given project and location.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/firewallEndpoints", +"httpMethod": "POST", +"id": "networksecurity.organizations.locations.firewallEndpoints.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"firewallEndpointId": { +"description": "Required. Id of the requesting object. If auto-generating Id server-side, remove this field and firewall_endpoint_id from the method_signature of Create RPC.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. Value for parent.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/firewallEndpoints", +"request": { +"$ref": "FirewallEndpoint" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single Endpoint.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/firewallEndpoints/{firewallEndpointsId}", +"httpMethod": "DELETE", +"id": "networksecurity.organizations.locations.firewallEndpoints.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the resource", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/firewallEndpoints/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single Endpoint.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/firewallEndpoints/{firewallEndpointsId}", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.firewallEndpoints.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the resource", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/firewallEndpoints/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "FirewallEndpoint" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists FirewallEndpoints in a given project and location.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/firewallEndpoints", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.firewallEndpoints.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filtering results", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Hint for how to order the results", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying a page of results the server should return.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. Parent value for ListEndpointsRequest", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/firewallEndpoints", +"response": { +"$ref": "ListFirewallEndpointsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Update a single Endpoint.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/firewallEndpoints/{firewallEndpointsId}", +"httpMethod": "PATCH", +"id": "networksecurity.organizations.locations.firewallEndpoints.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. Identifier. name of resource", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/firewallEndpoints/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Required. Field mask is used to specify the fields to be overwritten in the Endpoint resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "FirewallEndpoint" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "networksecurity.organizations.locations.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"request": { +"$ref": "CancelOperationRequest" +}, +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "networksecurity.organizations.locations.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/operations", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}/operations", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"securityProfileGroups": { +"methods": { +"create": { +"description": "Creates a new SecurityProfileGroup in a given organization and location.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfileGroups", +"httpMethod": "POST", +"id": "networksecurity.organizations.locations.securityProfileGroups.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource of the SecurityProfileGroup. Must be in the format `projects|organizations/*/locations/{location}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"securityProfileGroupId": { +"description": "Required. Short name of the SecurityProfileGroup resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"security_profile_group1\".", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/securityProfileGroups", +"request": { +"$ref": "SecurityProfileGroup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single SecurityProfileGroup.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfileGroups/{securityProfileGroupsId}", +"httpMethod": "DELETE", +"id": "networksecurity.organizations.locations.securityProfileGroups.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"etag": { +"description": "Optional. If client provided etag is out of date, delete will return FAILED_PRECONDITION error.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. A name of the SecurityProfileGroup to delete. Must be in the format `projects|organizations/*/locations/{location}/securityProfileGroups/{security_profile_group}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/securityProfileGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single SecurityProfileGroup.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfileGroups/{securityProfileGroupsId}", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.securityProfileGroups.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the SecurityProfileGroup to get. Must be in the format `projects|organizations/*/locations/{location}/securityProfileGroups/{security_profile_group}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/securityProfileGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "SecurityProfileGroup" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists SecurityProfileGroups in a given organization and location.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfileGroups", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.securityProfileGroups.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of SecurityProfileGroups to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last `ListSecurityProfileGroupsResponse` Indicates that this is a continuation of a prior `ListSecurityProfileGroups` call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project or organization and location from which the SecurityProfileGroups should be listed, specified in the format `projects|organizations/*/locations/{location}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/securityProfileGroups", +"response": { +"$ref": "ListSecurityProfileGroupsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single SecurityProfileGroup.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfileGroups/{securityProfileGroupsId}", +"httpMethod": "PATCH", +"id": "networksecurity.organizations.locations.securityProfileGroups.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. Identifier. Name of the SecurityProfileGroup resource. It matches pattern `projects|organizations/*/locations/{location}/securityProfileGroups/{security_profile_group}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/securityProfileGroups/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Field mask is used to specify the fields to be overwritten in the SecurityProfileGroup resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "SecurityProfileGroup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"securityProfiles": { +"methods": { +"create": { +"description": "Creates a new SecurityProfile in a given organization and location.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfiles", +"httpMethod": "POST", +"id": "networksecurity.organizations.locations.securityProfiles.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource of the SecurityProfile. Must be in the format `projects|organizations/*/locations/{location}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"securityProfileId": { +"description": "Required. Short name of the SecurityProfile resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"security_profile1\".", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/securityProfiles", +"request": { +"$ref": "SecurityProfile" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single SecurityProfile.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfiles/{securityProfilesId}", +"httpMethod": "DELETE", +"id": "networksecurity.organizations.locations.securityProfiles.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"etag": { +"description": "Optional. If client provided etag is out of date, delete will return FAILED_PRECONDITION error.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. A name of the SecurityProfile to delete. Must be in the format `projects|organizations/*/locations/{location}/securityProfiles/{security_profile_id}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/securityProfiles/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single SecurityProfile.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfiles/{securityProfilesId}", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.securityProfiles.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the SecurityProfile to get. Must be in the format `projects|organizations/*/locations/{location}/securityProfiles/{security_profile_id}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/securityProfiles/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "SecurityProfile" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists SecurityProfiles in a given organization and location.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfiles", +"httpMethod": "GET", +"id": "networksecurity.organizations.locations.securityProfiles.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of SecurityProfiles to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last `ListSecurityProfilesResponse` Indicates that this is a continuation of a prior `ListSecurityProfiles` call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project or organization and location from which the SecurityProfiles should be listed, specified in the format `projects|organizations/*/locations/{location}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/securityProfiles", +"response": { +"$ref": "ListSecurityProfilesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single SecurityProfile.", +"flatPath": "v1/organizations/{organizationsId}/locations/{locationsId}/securityProfiles/{securityProfilesId}", +"httpMethod": "PATCH", +"id": "networksecurity.organizations.locations.securityProfiles.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. Identifier. Name of the SecurityProfile resource. It matches pattern `projects|organizations/*/locations/{location}/securityProfiles/{security_profile}`.", +"location": "path", +"pattern": "^organizations/[^/]+/locations/[^/]+/securityProfiles/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Field mask is used to specify the fields to be overwritten in the SecurityProfile resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "SecurityProfile" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +} +}, +"projects": { +"resources": { +"locations": { +"methods": { +"get": { +"description": "Gets information about a location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Resource name for the location.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Location" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists information about the supported locations for this service.", +"flatPath": "v1/projects/{projectsId}/locations", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "A filter to narrow down results to a preferred subset. The filtering language accepts strings like `\"displayName=tokyo\"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160).", +"location": "query", +"type": "string" +}, +"name": { +"description": "The resource that owns the locations collection, if applicable.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The maximum number of results to return. If not set, the service selects a default.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}/locations", +"response": { +"$ref": "ListLocationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"addressGroups": { +"methods": { +"addItems": { +"description": "Adds items to an address group.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:addItems", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.addressGroups.addItems", +"parameterOrder": [ +"addressGroup" +], +"parameters": { +"addressGroup": { +"description": "Required. A name of the AddressGroup to add items to. Must be in the format `projects|organization/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+addressGroup}:addItems", +"request": { +"$ref": "AddAddressGroupItemsRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"cloneItems": { +"description": "Clones items from one address group to another.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:cloneItems", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.addressGroups.cloneItems", +"parameterOrder": [ +"addressGroup" +], +"parameters": { +"addressGroup": { +"description": "Required. A name of the AddressGroup to clone items to. Must be in the format `projects|organization/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+addressGroup}:cloneItems", +"request": { +"$ref": "CloneAddressGroupItemsRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"create": { +"description": "Creates a new address group in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.addressGroups.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"addressGroupId": { +"description": "Required. Short name of the AddressGroup resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"authz_policy\".", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource of the AddressGroup. Must be in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/addressGroups", +"request": { +"$ref": "AddressGroup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single address group.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.addressGroups.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the AddressGroup to delete. Must be in the format `projects/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single address group.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.addressGroups.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the AddressGroup to get. Must be in the format `projects/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AddressGroup" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:getIamPolicy", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.addressGroups.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists address groups in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.addressGroups.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of AddressGroups to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last `ListAddressGroupsResponse` Indicates that this is a continuation of a prior `ListAddressGroups` call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the AddressGroups should be listed, specified in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/addressGroups", +"response": { +"$ref": "ListAddressGroupsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"listReferences": { +"description": "Lists references of an address group.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:listReferences", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.addressGroups.listReferences", +"parameterOrder": [ +"addressGroup" +], +"parameters": { +"addressGroup": { +"description": "Required. A name of the AddressGroup to clone items to. Must be in the format `projects|organization/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The maximum number of references to return. If unspecified, server will pick an appropriate default. Server may return fewer items than requested. A caller should only rely on response's next_page_token to determine if there are more AddressGroupUsers left to be queried.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The next_page_token value returned from a previous List request, if any.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+addressGroup}:listReferences", +"response": { +"$ref": "ListAddressGroupReferencesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single address group.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.addressGroups.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the AddressGroup resource. It matches pattern `projects/*/locations/{location}/addressGroups/`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the AddressGroup resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "AddressGroup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"removeItems": { +"description": "Removes items from an address group.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:removeItems", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.addressGroups.removeItems", +"parameterOrder": [ +"addressGroup" +], +"parameters": { +"addressGroup": { +"description": "Required. A name of the AddressGroup to remove items from. Must be in the format `projects|organization/*/locations/{location}/addressGroups/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+addressGroup}:removeItems", +"request": { +"$ref": "RemoveAddressGroupItemsRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:setIamPolicy", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.addressGroups.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "GoogleIamV1SetIamPolicyRequest" +}, +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/addressGroups/{addressGroupsId}:testIamPermissions", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.addressGroups.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/addressGroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "GoogleIamV1TestIamPermissionsRequest" +}, +"response": { +"$ref": "GoogleIamV1TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"authorizationPolicies": { +"methods": { +"create": { +"description": "Creates a new AuthorizationPolicy in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authorizationPolicies", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.authorizationPolicies.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"authorizationPolicyId": { +"description": "Required. Short name of the AuthorizationPolicy resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"authz_policy\".", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource of the AuthorizationPolicy. Must be in the format `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/authorizationPolicies", +"request": { +"$ref": "AuthorizationPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single AuthorizationPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authorizationPolicies/{authorizationPoliciesId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.authorizationPolicies.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the AuthorizationPolicy to delete. Must be in the format `projects/{project}/locations/{location}/authorizationPolicies/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authorizationPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single AuthorizationPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authorizationPolicies/{authorizationPoliciesId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.authorizationPolicies.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the AuthorizationPolicy to get. Must be in the format `projects/{project}/locations/{location}/authorizationPolicies/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authorizationPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AuthorizationPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authorizationPolicies/{authorizationPoliciesId}:getIamPolicy", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.authorizationPolicies.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authorizationPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists AuthorizationPolicies in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authorizationPolicies", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.authorizationPolicies.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of AuthorizationPolicies to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last `ListAuthorizationPoliciesResponse` Indicates that this is a continuation of a prior `ListAuthorizationPolicies` call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the AuthorizationPolicies should be listed, specified in the format `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/authorizationPolicies", +"response": { +"$ref": "ListAuthorizationPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single AuthorizationPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authorizationPolicies/{authorizationPoliciesId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.authorizationPolicies.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the AuthorizationPolicy resource. It matches pattern `projects/{project}/locations/{location}/authorizationPolicies/`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authorizationPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the AuthorizationPolicy resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "AuthorizationPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authorizationPolicies/{authorizationPoliciesId}:setIamPolicy", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.authorizationPolicies.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authorizationPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "GoogleIamV1SetIamPolicyRequest" +}, +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authorizationPolicies/{authorizationPoliciesId}:testIamPermissions", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.authorizationPolicies.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authorizationPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "GoogleIamV1TestIamPermissionsRequest" +}, +"response": { +"$ref": "GoogleIamV1TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"authzPolicies": { +"methods": { +"create": { +"description": "Creates a new AuthzPolicy in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authzPolicies", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.authzPolicies.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"authzPolicyId": { +"description": "Required. User-provided ID of the `AuthzPolicy` resource to be created.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource of the `AuthzPolicy` resource. Must be in the format `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server can ignore the request if it has already been completed. The server guarantees that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/authzPolicies", +"request": { +"$ref": "AuthzPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single AuthzPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authzPolicies/{authzPoliciesId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.authzPolicies.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the `AuthzPolicy` resource to delete. Must be in the format `projects/{project}/locations/{location}/authzPolicies/{authz_policy}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authzPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server can ignore the request if it has already been completed. The server guarantees that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single AuthzPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authzPolicies/{authzPoliciesId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.authzPolicies.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the `AuthzPolicy` resource to get. Must be in the format `projects/{project}/locations/{location}/authzPolicies/{authz_policy}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authzPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "AuthzPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authzPolicies/{authzPoliciesId}:getIamPolicy", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.authzPolicies.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authzPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists AuthzPolicies in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authzPolicies", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.authzPolicies.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filtering results.", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Optional. Hint for how to order the results.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. Requested page size. The server might return fewer items than requested. If unspecified, the server picks an appropriate default.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. A token identifying a page of results that the server returns.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the `AuthzPolicy` resources are listed, specified in the following format: `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/authzPolicies", +"response": { +"$ref": "ListAuthzPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single AuthzPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authzPolicies/{authzPoliciesId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.authzPolicies.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Identifier. Name of the `AuthzPolicy` resource in the following format: `projects/{project}/locations/{location}/authzPolicies/{authz_policy}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authzPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server can ignore the request if it has already been completed. The server guarantees that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, ignores the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Required. Used to specify the fields to be overwritten in the `AuthzPolicy` resource by the update. The fields specified in the `update_mask` are relative to the resource, not the full request. A field is overwritten if it is in the mask. If the user does not specify a mask, then all fields are overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "AuthzPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authzPolicies/{authzPoliciesId}:setIamPolicy", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.authzPolicies.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authzPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "GoogleIamV1SetIamPolicyRequest" +}, +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/authzPolicies/{authzPoliciesId}:testIamPermissions", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.authzPolicies.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/authzPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "GoogleIamV1TestIamPermissionsRequest" +}, +"response": { +"$ref": "GoogleIamV1TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"clientTlsPolicies": { +"methods": { +"create": { +"description": "Creates a new ClientTlsPolicy in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/clientTlsPolicies", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.clientTlsPolicies.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"clientTlsPolicyId": { +"description": "Required. Short name of the ClientTlsPolicy resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"client_mtls_policy\".", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource of the ClientTlsPolicy. Must be in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/clientTlsPolicies", +"request": { +"$ref": "ClientTlsPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single ClientTlsPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/clientTlsPolicies/{clientTlsPoliciesId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.clientTlsPolicies.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the ClientTlsPolicy to delete. Must be in the format `projects/*/locations/{location}/clientTlsPolicies/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/clientTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single ClientTlsPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/clientTlsPolicies/{clientTlsPoliciesId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.clientTlsPolicies.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the ClientTlsPolicy to get. Must be in the format `projects/*/locations/{location}/clientTlsPolicies/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/clientTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ClientTlsPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/clientTlsPolicies/{clientTlsPoliciesId}:getIamPolicy", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.clientTlsPolicies.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/clientTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists ClientTlsPolicies in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/clientTlsPolicies", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.clientTlsPolicies.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of ClientTlsPolicies to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last `ListClientTlsPoliciesResponse` Indicates that this is a continuation of a prior `ListClientTlsPolicies` call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the ClientTlsPolicies should be listed, specified in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/clientTlsPolicies", +"response": { +"$ref": "ListClientTlsPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single ClientTlsPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/clientTlsPolicies/{clientTlsPoliciesId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.clientTlsPolicies.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the ClientTlsPolicy resource. It matches the pattern `projects/*/locations/{location}/clientTlsPolicies/{client_tls_policy}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/clientTlsPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the ClientTlsPolicy resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "ClientTlsPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/clientTlsPolicies/{clientTlsPoliciesId}:setIamPolicy", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.clientTlsPolicies.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/clientTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "GoogleIamV1SetIamPolicyRequest" +}, +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/clientTlsPolicies/{clientTlsPoliciesId}:testIamPermissions", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.clientTlsPolicies.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/clientTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "GoogleIamV1TestIamPermissionsRequest" +}, +"response": { +"$ref": "GoogleIamV1TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"firewallEndpointAssociations": { +"methods": { +"create": { +"description": "Creates a new FirewallEndpointAssociation in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/firewallEndpointAssociations", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.firewallEndpointAssociations.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"firewallEndpointAssociationId": { +"description": "Optional. Id of the requesting object. If auto-generating Id server-side, remove this field and firewall_endpoint_association_id from the method_signature of Create RPC.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. Value for parent.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/firewallEndpointAssociations", +"request": { +"$ref": "FirewallEndpointAssociation" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single FirewallEndpointAssociation.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/firewallEndpointAssociations/{firewallEndpointAssociationsId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.firewallEndpointAssociations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the resource", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/firewallEndpointAssociations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single FirewallEndpointAssociation.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/firewallEndpointAssociations/{firewallEndpointAssociationsId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.firewallEndpointAssociations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the resource", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/firewallEndpointAssociations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "FirewallEndpointAssociation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists Associations in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/firewallEndpointAssociations", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.firewallEndpointAssociations.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. Filtering results", +"location": "query", +"type": "string" +}, +"orderBy": { +"description": "Hint for how to order the results", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying a page of results the server should return.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. Parent value for ListAssociationsRequest", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/firewallEndpointAssociations", +"response": { +"$ref": "ListFirewallEndpointAssociationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Update a single FirewallEndpointAssociation.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/firewallEndpointAssociations/{firewallEndpointAssociationsId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.firewallEndpointAssociations.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Immutable. Identifier. name of resource", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/firewallEndpointAssociations/[^/]+$", +"required": true, +"type": "string" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"location": "query", +"type": "string" +}, +"updateMask": { +"description": "Required. Field mask is used to specify the fields to be overwritten in the Association resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "FirewallEndpointAssociation" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"gatewaySecurityPolicies": { +"methods": { +"create": { +"description": "Creates a new GatewaySecurityPolicy in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"gatewaySecurityPolicyId": { +"description": "Required. Short name of the GatewaySecurityPolicy resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"gateway_security_policy1\".", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource of the GatewaySecurityPolicy. Must be in the format `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/gatewaySecurityPolicies", +"request": { +"$ref": "GatewaySecurityPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single GatewaySecurityPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies/{gatewaySecurityPoliciesId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the GatewaySecurityPolicy to delete. Must be in the format `projects/{project}/locations/{location}/gatewaySecurityPolicies/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/gatewaySecurityPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single GatewaySecurityPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies/{gatewaySecurityPoliciesId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the GatewaySecurityPolicy to get. Must be in the format `projects/{project}/locations/{location}/gatewaySecurityPolicies/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/gatewaySecurityPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GatewaySecurityPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists GatewaySecurityPolicies in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of GatewaySecurityPolicies to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last 'ListGatewaySecurityPoliciesResponse' Indicates that this is a continuation of a prior 'ListGatewaySecurityPolicies' call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the GatewaySecurityPolicies should be listed, specified in the format `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/gatewaySecurityPolicies", +"response": { +"$ref": "ListGatewaySecurityPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single GatewaySecurityPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies/{gatewaySecurityPoliciesId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the resource. Name is of the form projects/{project}/locations/{location}/gatewaySecurityPolicies/{gateway_security_policy} gateway_security_policy should match the pattern:(^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$).", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/gatewaySecurityPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the GatewaySecurityPolicy resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "GatewaySecurityPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"rules": { +"methods": { +"create": { +"description": "Creates a new GatewaySecurityPolicy in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies/{gatewaySecurityPoliciesId}/rules", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.rules.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"gatewaySecurityPolicyRuleId": { +"description": "The ID to use for the rule, which will become the final component of the rule's resource name. This value should be 4-63 characters, and valid characters are /a-z-/.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent where this rule will be created. Format : projects/{project}/location/{location}/gatewaySecurityPolicies/*", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/gatewaySecurityPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/rules", +"request": { +"$ref": "GatewaySecurityPolicyRule" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single GatewaySecurityPolicyRule.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies/{gatewaySecurityPoliciesId}/rules/{rulesId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.rules.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the GatewaySecurityPolicyRule to delete. Must be in the format `projects/{project}/locations/{location}/gatewaySecurityPolicies/{gatewaySecurityPolicy}/rules/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/gatewaySecurityPolicies/[^/]+/rules/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single GatewaySecurityPolicyRule.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies/{gatewaySecurityPoliciesId}/rules/{rulesId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.rules.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the GatewaySecurityPolicyRule to retrieve. Format: projects/{project}/location/{location}/gatewaySecurityPolicies/*/rules/*", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/gatewaySecurityPolicies/[^/]+/rules/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GatewaySecurityPolicyRule" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists GatewaySecurityPolicyRules in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies/{gatewaySecurityPoliciesId}/rules", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.rules.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of GatewaySecurityPolicyRules to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last 'ListGatewaySecurityPolicyRulesResponse' Indicates that this is a continuation of a prior 'ListGatewaySecurityPolicyRules' call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project, location and GatewaySecurityPolicy from which the GatewaySecurityPolicyRules should be listed, specified in the format `projects/{project}/locations/{location}/gatewaySecurityPolicies/{gatewaySecurityPolicy}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/gatewaySecurityPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/rules", +"response": { +"$ref": "ListGatewaySecurityPolicyRulesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single GatewaySecurityPolicyRule.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/gatewaySecurityPolicies/{gatewaySecurityPoliciesId}/rules/{rulesId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.gatewaySecurityPolicies.rules.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Immutable. Name of the resource. ame is the full resource name so projects/{project}/locations/{location}/gatewaySecurityPolicies/{gateway_security_policy}/rules/{rule} rule should match the pattern: (^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$).", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/gatewaySecurityPolicies/[^/]+/rules/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the GatewaySecurityPolicy resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "GatewaySecurityPolicyRule" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +}, +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"request": { +"$ref": "CancelOperationRequest" +}, +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/operations", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}/operations", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"serverTlsPolicies": { +"methods": { +"create": { +"description": "Creates a new ServerTlsPolicy in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serverTlsPolicies", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.serverTlsPolicies.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource of the ServerTlsPolicy. Must be in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"serverTlsPolicyId": { +"description": "Required. Short name of the ServerTlsPolicy resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"server_mtls_policy\".", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/serverTlsPolicies", +"request": { +"$ref": "ServerTlsPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single ServerTlsPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serverTlsPolicies/{serverTlsPoliciesId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.serverTlsPolicies.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the ServerTlsPolicy to delete. Must be in the format `projects/*/locations/{location}/serverTlsPolicies/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serverTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single ServerTlsPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serverTlsPolicies/{serverTlsPoliciesId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.serverTlsPolicies.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the ServerTlsPolicy to get. Must be in the format `projects/*/locations/{location}/serverTlsPolicies/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serverTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ServerTlsPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serverTlsPolicies/{serverTlsPoliciesId}:getIamPolicy", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.serverTlsPolicies.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"options.requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"location": "query", +"type": "integer" +}, +"resource": { +"description": "REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serverTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists ServerTlsPolicies in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serverTlsPolicies", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.serverTlsPolicies.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of ServerTlsPolicies to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last `ListServerTlsPoliciesResponse` Indicates that this is a continuation of a prior `ListServerTlsPolicies` call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the ServerTlsPolicies should be listed, specified in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/serverTlsPolicies", +"response": { +"$ref": "ListServerTlsPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single ServerTlsPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serverTlsPolicies/{serverTlsPoliciesId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.serverTlsPolicies.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the ServerTlsPolicy resource. It matches the pattern `projects/*/locations/{location}/serverTlsPolicies/{server_tls_policy}`", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serverTlsPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the ServerTlsPolicy resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "ServerTlsPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serverTlsPolicies/{serverTlsPoliciesId}:setIamPolicy", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.serverTlsPolicies.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serverTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "GoogleIamV1SetIamPolicyRequest" +}, +"response": { +"$ref": "GoogleIamV1Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"testIamPermissions": { +"description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/serverTlsPolicies/{serverTlsPoliciesId}:testIamPermissions", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.serverTlsPolicies.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/serverTlsPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "GoogleIamV1TestIamPermissionsRequest" +}, +"response": { +"$ref": "GoogleIamV1TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"tlsInspectionPolicies": { +"methods": { +"create": { +"description": "Creates a new TlsInspectionPolicy in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/tlsInspectionPolicies", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.tlsInspectionPolicies.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource of the TlsInspectionPolicy. Must be in the format `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"tlsInspectionPolicyId": { +"description": "Required. Short name of the TlsInspectionPolicy resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"tls_inspection_policy1\".", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/tlsInspectionPolicies", +"request": { +"$ref": "TlsInspectionPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single TlsInspectionPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/tlsInspectionPolicies/{tlsInspectionPoliciesId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.tlsInspectionPolicies.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"force": { +"description": "If set to true, any rules for this TlsInspectionPolicy will also be deleted. (Otherwise, the request will only work if the TlsInspectionPolicy has no rules.)", +"location": "query", +"type": "boolean" +}, +"name": { +"description": "Required. A name of the TlsInspectionPolicy to delete. Must be in the format `projects/{project}/locations/{location}/tlsInspectionPolicies/{tls_inspection_policy}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/tlsInspectionPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single TlsInspectionPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/tlsInspectionPolicies/{tlsInspectionPoliciesId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.tlsInspectionPolicies.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the TlsInspectionPolicy to get. Must be in the format `projects/{project}/locations/{location}/tlsInspectionPolicies/{tls_inspection_policy}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/tlsInspectionPolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "TlsInspectionPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists TlsInspectionPolicies in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/tlsInspectionPolicies", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.tlsInspectionPolicies.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of TlsInspectionPolicies to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last 'ListTlsInspectionPoliciesResponse' Indicates that this is a continuation of a prior 'ListTlsInspectionPolicies' call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the TlsInspectionPolicies should be listed, specified in the format `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/tlsInspectionPolicies", +"response": { +"$ref": "ListTlsInspectionPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single TlsInspectionPolicy.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/tlsInspectionPolicies/{tlsInspectionPoliciesId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.tlsInspectionPolicies.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the resource. Name is of the form projects/{project}/locations/{location}/tlsInspectionPolicies/{tls_inspection_policy} tls_inspection_policy should match the pattern:(^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$).", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/tlsInspectionPolicies/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the TlsInspectionPolicy resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "TlsInspectionPolicy" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"urlLists": { +"methods": { +"create": { +"description": "Creates a new UrlList in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/urlLists", +"httpMethod": "POST", +"id": "networksecurity.projects.locations.urlLists.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource of the UrlList. Must be in the format `projects/*/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +}, +"urlListId": { +"description": "Required. Short name of the UrlList resource to be created. This value should be 1-63 characters long, containing only letters, numbers, hyphens, and underscores, and should not start with a number. E.g. \"url_list\".", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}/urlLists", +"request": { +"$ref": "UrlList" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes a single UrlList.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/urlLists/{urlListsId}", +"httpMethod": "DELETE", +"id": "networksecurity.projects.locations.urlLists.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the UrlList to delete. Must be in the format `projects/*/locations/{location}/urlLists/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/urlLists/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets details of a single UrlList.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/urlLists/{urlListsId}", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.urlLists.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A name of the UrlList to get. Must be in the format `projects/*/locations/{location}/urlLists/*`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/urlLists/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "UrlList" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists UrlLists in a given project and location.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/urlLists", +"httpMethod": "GET", +"id": "networksecurity.projects.locations.urlLists.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Maximum number of UrlLists to return per call.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The value returned by the last `ListUrlListsResponse` Indicates that this is a continuation of a prior `ListUrlLists` call, and that the system should return the next page of data.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project and location from which the UrlLists should be listed, specified in the format `projects/{project}/locations/{location}`.", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/urlLists", +"response": { +"$ref": "ListUrlListsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the parameters of a single UrlList.", +"flatPath": "v1/projects/{projectsId}/locations/{locationsId}/urlLists/{urlListsId}", +"httpMethod": "PATCH", +"id": "networksecurity.projects.locations.urlLists.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the resource provided by the user. Name is of the form projects/{project}/locations/{location}/urlLists/{url_list} url_list should match the pattern:(^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$).", +"location": "path", +"pattern": "^projects/[^/]+/locations/[^/]+/urlLists/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. Field mask is used to specify the fields to be overwritten in the UrlList resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "UrlList" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +} +} +}, +"revision": "20241202", +"rootUrl": "https://networksecurity.googleapis.com/", +"schemas": { +"AddAddressGroupItemsRequest": { +"description": "Request used by the AddAddressGroupItems method.", +"id": "AddAddressGroupItemsRequest", +"properties": { +"items": { +"description": "Required. List of items to add.", +"items": { +"type": "string" +}, +"type": "array" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"type": "string" +} +}, +"type": "object" +}, +"AddressGroup": { +"description": "AddressGroup is a resource that specifies how a collection of IP/DNS used in Firewall Policy.", +"id": "AddressGroup", +"properties": { +"capacity": { +"description": "Required. Capacity of the Address Group", +"format": "int32", +"type": "integer" +}, +"createTime": { +"description": "Output only. The timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. Free-text description of the resource.", +"type": "string" +}, +"items": { +"description": "Optional. List of items.", +"items": { +"type": "string" +}, +"type": "array" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Set of label tags associated with the AddressGroup resource.", +"type": "object" +}, +"name": { +"description": "Required. Name of the AddressGroup resource. It matches pattern `projects/*/locations/{location}/addressGroups/`.", +"type": "string" +}, +"purpose": { +"description": "Optional. List of supported purposes of the Address Group.", +"items": { +"enum": [ +"PURPOSE_UNSPECIFIED", +"DEFAULT", +"CLOUD_ARMOR" +], +"enumDescriptions": [ +"Default value. Should never happen.", +"Address Group is distributed to VMC, and is usable in Firewall Policies and other systems that rely on VMC.", +"Address Group is usable in Cloud Armor." +], +"type": "string" +}, +"type": "array" +}, +"selfLink": { +"description": "Output only. Server-defined fully-qualified URL for this resource.", +"readOnly": true, +"type": "string" +}, +"type": { +"description": "Required. The type of the Address Group. Possible values are \"IPv4\" or \"IPV6\".", +"enum": [ +"TYPE_UNSPECIFIED", +"IPV4", +"IPV6" +], +"enumDescriptions": [ +"Default value.", +"IP v4 ranges.", +"IP v6 ranges." +], +"type": "string" +}, +"updateTime": { +"description": "Output only. The timestamp when the resource was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"AuthorizationPolicy": { +"description": "AuthorizationPolicy is a resource that specifies how a server should authorize incoming connections. This resource in itself does not change the configuration unless it's attached to a target https proxy or endpoint config selector resource.", +"id": "AuthorizationPolicy", +"properties": { +"action": { +"description": "Required. The action to take when a rule match is found. Possible values are \"ALLOW\" or \"DENY\".", +"enum": [ +"ACTION_UNSPECIFIED", +"ALLOW", +"DENY" +], +"enumDescriptions": [ +"Default value.", +"Grant access.", +"Deny access. Deny rules should be avoided unless they are used to provide a default \"deny all\" fallback." +], +"type": "string" +}, +"createTime": { +"description": "Output only. The timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. Free-text description of the resource.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Set of label tags associated with the AuthorizationPolicy resource.", +"type": "object" +}, +"name": { +"description": "Required. Name of the AuthorizationPolicy resource. It matches pattern `projects/{project}/locations/{location}/authorizationPolicies/`.", +"type": "string" +}, +"rules": { +"description": "Optional. List of rules to match. Note that at least one of the rules must match in order for the action specified in the 'action' field to be taken. A rule is a match if there is a matching source and destination. If left blank, the action specified in the `action` field will be applied on every request.", +"items": { +"$ref": "Rule" +}, +"type": "array" +}, +"updateTime": { +"description": "Output only. The timestamp when the resource was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"AuthzPolicy": { +"description": "`AuthzPolicy` is a resource that allows to forward traffic to a callout backend designed to scan the traffic for security purposes.", +"id": "AuthzPolicy", +"properties": { +"action": { +"description": "Required. Can be one of `ALLOW`, `DENY`, `CUSTOM`. When the action is `CUSTOM`, `customProvider` must be specified. When the action is `ALLOW`, only requests matching the policy will be allowed. When the action is `DENY`, only requests matching the policy will be denied. When a request arrives, the policies are evaluated in the following order: 1. If there is a `CUSTOM` policy that matches the request, the `CUSTOM` policy is evaluated using the custom authorization providers and the request is denied if the provider rejects the request. 2. If there are any `DENY` policies that match the request, the request is denied. 3. If there are no `ALLOW` policies for the resource or if any of the `ALLOW` policies match the request, the request is allowed. 4. Else the request is denied by default if none of the configured AuthzPolicies with `ALLOW` action match the request.", +"enum": [ +"AUTHZ_ACTION_UNSPECIFIED", +"ALLOW", +"DENY", +"CUSTOM" +], +"enumDescriptions": [ +"Unspecified action.", +"Allow request to pass through to the backend.", +"Deny the request and return a HTTP 404 to the client.", +"Delegate the authorization decision to an external authorization engine." +], +"type": "string" +}, +"createTime": { +"description": "Output only. The timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"customProvider": { +"$ref": "AuthzPolicyCustomProvider", +"description": "Optional. Required if the action is `CUSTOM`. Allows delegating authorization decisions to Cloud IAP or to Service Extensions. One of `cloudIap` or `authzExtension` must be specified." +}, +"description": { +"description": "Optional. A human-readable description of the resource.", +"type": "string" +}, +"httpRules": { +"description": "Optional. A list of authorization HTTP rules to match against the incoming request. A policy match occurs when at least one HTTP rule matches the request or when no HTTP rules are specified in the policy. At least one HTTP Rule is required for Allow or Deny Action. Limited to 5 rules.", +"items": { +"$ref": "AuthzPolicyAuthzRule" +}, +"type": "array" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Set of labels associated with the `AuthzPolicy` resource. The format must comply with [the following requirements](/compute/docs/labeling-resources#requirements).", +"type": "object" +}, +"name": { +"description": "Required. Identifier. Name of the `AuthzPolicy` resource in the following format: `projects/{project}/locations/{location}/authzPolicies/{authz_policy}`.", +"type": "string" +}, +"target": { +"$ref": "AuthzPolicyTarget", +"description": "Required. Specifies the set of resources to which this policy should be applied to." +}, +"updateTime": { +"description": "Output only. The timestamp when the resource was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRule": { +"description": "Conditions to match against the incoming request.", +"id": "AuthzPolicyAuthzRule", +"properties": { +"from": { +"$ref": "AuthzPolicyAuthzRuleFrom", +"description": "Optional. Describes properties of a source of a request." +}, +"to": { +"$ref": "AuthzPolicyAuthzRuleTo", +"description": "Optional. Describes properties of a target of a request." +}, +"when": { +"description": "Optional. CEL expression that describes the conditions to be satisfied for the action. The result of the CEL expression is ANDed with the from and to. Refer to the CEL language reference for a list of available attributes.", +"type": "string" +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleFrom": { +"description": "Describes properties of one or more sources of a request.", +"id": "AuthzPolicyAuthzRuleFrom", +"properties": { +"notSources": { +"description": "Optional. Describes the negated properties of request sources. Matches requests from sources that do not match the criteria specified in this field. At least one of sources or notSources must be specified.", +"items": { +"$ref": "AuthzPolicyAuthzRuleFromRequestSource" +}, +"type": "array" +}, +"sources": { +"description": "Optional. Describes the properties of a request's sources. At least one of sources or notSources must be specified. Limited to 1 source. A match occurs when ANY source (in sources or notSources) matches the request. Within a single source, the match follows AND semantics across fields and OR semantics within a single field, i.e. a match occurs when ANY principal matches AND ANY ipBlocks match.", +"items": { +"$ref": "AuthzPolicyAuthzRuleFromRequestSource" +}, +"type": "array" +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleFromRequestSource": { +"description": "Describes the properties of a single source.", +"id": "AuthzPolicyAuthzRuleFromRequestSource", +"properties": { +"principals": { +"description": "Optional. A list of identities derived from the client's certificate. This field will not match on a request unless mutual TLS is enabled for the Forwarding rule or Gateway. Each identity is a string whose value is matched against the URI SAN, or DNS SAN or the subject field in the client's certificate. The match can be exact, prefix, suffix or a substring match. One of exact, prefix, suffix or contains must be specified. Limited to 5 principals.", +"items": { +"$ref": "AuthzPolicyAuthzRuleStringMatch" +}, +"type": "array" +}, +"resources": { +"description": "Optional. A list of resources to match against the resource of the source VM of a request. Limited to 5 resources.", +"items": { +"$ref": "AuthzPolicyAuthzRuleRequestResource" +}, +"type": "array" +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleHeaderMatch": { +"description": "Determines how a HTTP header should be matched.", +"id": "AuthzPolicyAuthzRuleHeaderMatch", +"properties": { +"name": { +"description": "Optional. Specifies the name of the header in the request.", +"type": "string" +}, +"value": { +"$ref": "AuthzPolicyAuthzRuleStringMatch", +"description": "Optional. Specifies how the header match will be performed." +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleRequestResource": { +"description": "Describes the properties of a client VM resource accessing the internal application load balancers.", +"id": "AuthzPolicyAuthzRuleRequestResource", +"properties": { +"iamServiceAccount": { +"$ref": "AuthzPolicyAuthzRuleStringMatch", +"description": "Optional. An IAM service account to match against the source service account of the VM sending the request." +}, +"tagValueIdSet": { +"$ref": "AuthzPolicyAuthzRuleRequestResourceTagValueIdSet", +"description": "Optional. A list of resource tag value permanent IDs to match against the resource manager tags value associated with the source VM of a request." +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleRequestResourceTagValueIdSet": { +"description": "Describes a set of resource tag value permanent IDs to match against the resource manager tags value associated with the source VM of a request.", +"id": "AuthzPolicyAuthzRuleRequestResourceTagValueIdSet", +"properties": { +"ids": { +"description": "Required. A list of resource tag value permanent IDs to match against the resource manager tags value associated with the source VM of a request. The match follows AND semantics which means all the ids must match. Limited to 5 matches.", +"items": { +"format": "int64", +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleStringMatch": { +"description": "Determines how a string value should be matched.", +"id": "AuthzPolicyAuthzRuleStringMatch", +"properties": { +"contains": { +"description": "The input string must have the substring specified here. Note: empty contains match is not allowed, please use regex instead. Examples: * ``abc`` matches the value ``xyz.abc.def``", +"type": "string" +}, +"exact": { +"description": "The input string must match exactly the string specified here. Examples: * ``abc`` only matches the value ``abc``.", +"type": "string" +}, +"ignoreCase": { +"description": "If true, indicates the exact/prefix/suffix/contains matching should be case insensitive. For example, the matcher ``data`` will match both input string ``Data`` and ``data`` if set to true.", +"type": "boolean" +}, +"prefix": { +"description": "The input string must have the prefix specified here. Note: empty prefix is not allowed, please use regex instead. Examples: * ``abc`` matches the value ``abc.xyz``", +"type": "string" +}, +"suffix": { +"description": "The input string must have the suffix specified here. Note: empty prefix is not allowed, please use regex instead. Examples: * ``abc`` matches the value ``xyz.abc``", +"type": "string" +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleTo": { +"description": "Describes properties of one or more targets of a request.", +"id": "AuthzPolicyAuthzRuleTo", +"properties": { +"notOperations": { +"description": "Optional. Describes the negated properties of the targets of a request. Matches requests for operations that do not match the criteria specified in this field. At least one of operations or notOperations must be specified.", +"items": { +"$ref": "AuthzPolicyAuthzRuleToRequestOperation" +}, +"type": "array" +}, +"operations": { +"description": "Optional. Describes properties of one or more targets of a request. At least one of operations or notOperations must be specified. Limited to 1 operation. A match occurs when ANY operation (in operations or notOperations) matches. Within an operation, the match follows AND semantics across fields and OR semantics within a field, i.e. a match occurs when ANY path matches AND ANY header matches and ANY method matches.", +"items": { +"$ref": "AuthzPolicyAuthzRuleToRequestOperation" +}, +"type": "array" +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleToRequestOperation": { +"description": "Describes properties of one or more targets of a request.", +"id": "AuthzPolicyAuthzRuleToRequestOperation", +"properties": { +"headerSet": { +"$ref": "AuthzPolicyAuthzRuleToRequestOperationHeaderSet", +"description": "Optional. A list of headers to match against in http header." +}, +"hosts": { +"description": "Optional. A list of HTTP Hosts to match against. The match can be one of exact, prefix, suffix, or contains (substring match). Matches are always case sensitive unless the ignoreCase is set. Limited to 5 matches.", +"items": { +"$ref": "AuthzPolicyAuthzRuleStringMatch" +}, +"type": "array" +}, +"methods": { +"description": "Optional. A list of HTTP methods to match against. Each entry must be a valid HTTP method name (GET, PUT, POST, HEAD, PATCH, DELETE, OPTIONS). It only allows exact match and is always case sensitive.", +"items": { +"type": "string" +}, +"type": "array" +}, +"paths": { +"description": "Optional. A list of paths to match against. The match can be one of exact, prefix, suffix, or contains (substring match). Matches are always case sensitive unless the ignoreCase is set. Limited to 5 matches. Note that this path match includes the query parameters. For gRPC services, this should be a fully-qualified name of the form /package.service/method.", +"items": { +"$ref": "AuthzPolicyAuthzRuleStringMatch" +}, +"type": "array" +} +}, +"type": "object" +}, +"AuthzPolicyAuthzRuleToRequestOperationHeaderSet": { +"description": "Describes a set of HTTP headers to match against.", +"id": "AuthzPolicyAuthzRuleToRequestOperationHeaderSet", +"properties": { +"headers": { +"description": "Required. A list of headers to match against in http header. The match can be one of exact, prefix, suffix, or contains (substring match). The match follows AND semantics which means all the headers must match. Matches are always case sensitive unless the ignoreCase is set. Limited to 5 matches.", +"items": { +"$ref": "AuthzPolicyAuthzRuleHeaderMatch" +}, +"type": "array" +} +}, +"type": "object" +}, +"AuthzPolicyCustomProvider": { +"description": "Allows delegating authorization decisions to Cloud IAP or to Service Extensions.", +"id": "AuthzPolicyCustomProvider", +"properties": { +"authzExtension": { +"$ref": "AuthzPolicyCustomProviderAuthzExtension", +"description": "Optional. Delegate authorization decision to user authored Service Extension. Only one of cloudIap or authzExtension can be specified." +}, +"cloudIap": { +"$ref": "AuthzPolicyCustomProviderCloudIap", +"description": "Optional. Delegates authorization decisions to Cloud IAP. Applicable only for managed load balancers. Enabling Cloud IAP at the AuthzPolicy level is not compatible with Cloud IAP settings in the BackendService. Enabling IAP in both places will result in request failure. Ensure that IAP is enabled in either the AuthzPolicy or the BackendService but not in both places." +} +}, +"type": "object" +}, +"AuthzPolicyCustomProviderAuthzExtension": { +"description": "Optional. Delegate authorization decision to user authored extension. Only one of cloudIap or authzExtension can be specified.", +"id": "AuthzPolicyCustomProviderAuthzExtension", +"properties": { +"resources": { +"description": "Required. A list of references to authorization extensions that will be invoked for requests matching this policy. Limited to 1 custom provider.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"AuthzPolicyCustomProviderCloudIap": { +"description": "Optional. Delegates authorization decisions to Cloud IAP. Applicable only for managed load balancers. Enabling Cloud IAP at the AuthzPolicy level is not compatible with Cloud IAP settings in the BackendService. Enabling IAP in both places will result in request failure. Ensure that IAP is enabled in either the AuthzPolicy or the BackendService but not in both places.", +"id": "AuthzPolicyCustomProviderCloudIap", +"properties": {}, +"type": "object" +}, +"AuthzPolicyTarget": { +"description": "Specifies the set of targets to which this policy should be applied to.", +"id": "AuthzPolicyTarget", +"properties": { +"loadBalancingScheme": { +"description": "Required. All gateways and forwarding rules referenced by this policy and extensions must share the same load balancing scheme. Supported values: `INTERNAL_MANAGED` and `EXTERNAL_MANAGED`. For more information, refer to [Backend services overview](https://cloud.google.com/load-balancing/docs/backend-service).", +"enum": [ +"LOAD_BALANCING_SCHEME_UNSPECIFIED", +"INTERNAL_MANAGED", +"EXTERNAL_MANAGED", +"INTERNAL_SELF_MANAGED" +], +"enumDescriptions": [ +"Default value. Do not use.", +"Signifies that this is used for Regional internal or Cross-region internal Application Load Balancing.", +"Signifies that this is used for Global external or Regional external Application Load Balancing.", +"Signifies that this is used for Cloud Service Mesh. Meant for use by CSM GKE controller only." +], +"type": "string" +}, +"resources": { +"description": "Required. A list of references to the Forwarding Rules on which this policy will be applied.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"CancelOperationRequest": { +"description": "The request message for Operations.CancelOperation.", +"id": "CancelOperationRequest", +"properties": {}, +"type": "object" +}, +"CertificateProviderInstance": { +"description": "Specification of a TLS certificate provider instance. Workloads may have one or more CertificateProvider instances (plugins) and one of them is enabled and configured by specifying this message. Workloads use the values from this message to locate and load the CertificateProvider instance configuration.", +"id": "CertificateProviderInstance", +"properties": { +"pluginInstance": { +"description": "Required. Plugin instance name, used to locate and load CertificateProvider instance configuration. Set to \"google_cloud_private_spiffe\" to use Certificate Authority Service certificate provider instance.", +"type": "string" +} +}, +"type": "object" +}, +"ClientTlsPolicy": { +"description": "ClientTlsPolicy is a resource that specifies how a client should authenticate connections to backends of a service. This resource itself does not affect configuration unless it is attached to a backend service resource.", +"id": "ClientTlsPolicy", +"properties": { +"clientCertificate": { +"$ref": "GoogleCloudNetworksecurityV1CertificateProvider", +"description": "Optional. Defines a mechanism to provision client identity (public and private keys) for peer to peer authentication. The presence of this dictates mTLS." +}, +"createTime": { +"description": "Output only. The timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. Free-text description of the resource.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Set of label tags associated with the resource.", +"type": "object" +}, +"name": { +"description": "Required. Name of the ClientTlsPolicy resource. It matches the pattern `projects/*/locations/{location}/clientTlsPolicies/{client_tls_policy}`", +"type": "string" +}, +"serverValidationCa": { +"description": "Optional. Defines the mechanism to obtain the Certificate Authority certificate to validate the server certificate. If empty, client does not validate the server certificate.", +"items": { +"$ref": "ValidationCA" +}, +"type": "array" +}, +"sni": { +"description": "Optional. Server Name Indication string to present to the server during TLS handshake. E.g: \"secure.example.com\".", +"type": "string" +}, +"updateTime": { +"description": "Output only. The timestamp when the resource was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"CloneAddressGroupItemsRequest": { +"description": "Request used by the CloneAddressGroupItems method.", +"id": "CloneAddressGroupItemsRequest", +"properties": { +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"type": "string" +}, +"sourceAddressGroup": { +"description": "Required. Source address group to clone items from.", +"type": "string" +} +}, +"type": "object" +}, +"CustomInterceptProfile": { +"description": "CustomInterceptProfile defines the Packet Intercept Endpoint Group used to intercept traffic to a third-party firewall in a Firewall rule.", +"id": "CustomInterceptProfile", +"properties": { +"interceptEndpointGroup": { +"description": "Required. The InterceptEndpointGroup to which traffic associated with the SP should be mirrored.", +"type": "string" +} +}, +"type": "object" +}, +"CustomMirroringProfile": { +"description": "CustomMirroringProfile defines an action for mirroring traffic to a collector's EndpointGroup", +"id": "CustomMirroringProfile", +"properties": { +"mirroringEndpointGroup": { +"description": "Required. The MirroringEndpointGroup to which traffic associated with the SP should be mirrored.", +"type": "string" +} +}, +"type": "object" +}, +"Destination": { +"description": "Specification of traffic destination attributes.", +"id": "Destination", +"properties": { +"hosts": { +"description": "Required. List of host names to match. Matched against the \":authority\" header in http requests. At least one host should match. Each host can be an exact match, or a prefix match (example \"mydomain.*\") or a suffix match (example \"*.myorg.com\") or a presence (any) match \"*\".", +"items": { +"type": "string" +}, +"type": "array" +}, +"httpHeaderMatch": { +"$ref": "HttpHeaderMatch", +"description": "Optional. Match against key:value pair in http header. Provides a flexible match based on HTTP headers, for potentially advanced use cases. At least one header should match. Avoid using header matches to make authorization decisions unless there is a strong guarantee that requests arrive through a trusted client or proxy." +}, +"methods": { +"description": "Optional. A list of HTTP methods to match. At least one method should match. Should not be set for gRPC services.", +"items": { +"type": "string" +}, +"type": "array" +}, +"ports": { +"description": "Required. List of destination ports to match. At least one port should match.", +"items": { +"format": "uint32", +"type": "integer" +}, +"type": "array" +} +}, +"type": "object" +}, +"Empty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "Empty", +"properties": {}, +"type": "object" +}, +"Expr": { +"description": "Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() < 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != 'private' && document.type != 'internal'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"'New message received at ' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.", +"id": "Expr", +"properties": { +"description": { +"description": "Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.", +"type": "string" +}, +"expression": { +"description": "Textual representation of an expression in Common Expression Language syntax.", +"type": "string" +}, +"location": { +"description": "Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.", +"type": "string" +}, +"title": { +"description": "Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.", +"type": "string" +} +}, +"type": "object" +}, +"FirewallEndpoint": { +"description": "Message describing Endpoint object", +"id": "FirewallEndpoint", +"properties": { +"associatedNetworks": { +"deprecated": true, +"description": "Output only. List of networks that are associated with this endpoint in the local zone. This is a projection of the FirewallEndpointAssociations pointing at this endpoint. A network will only appear in this list after traffic routing is fully configured. Format: projects/{project}/global/networks/{name}.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"associations": { +"description": "Output only. List of FirewallEndpointAssociations that are associated to this endpoint. An association will only appear in this list after traffic routing is fully configured.", +"items": { +"$ref": "FirewallEndpointAssociationReference" +}, +"readOnly": true, +"type": "array" +}, +"billingProjectId": { +"description": "Required. Project to bill on endpoint uptime usage.", +"type": "string" +}, +"createTime": { +"description": "Output only. Create time stamp", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. Description of the firewall endpoint. Max length 2048 characters.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Labels as key value pairs", +"type": "object" +}, +"name": { +"description": "Immutable. Identifier. name of resource", +"type": "string" +}, +"reconciling": { +"description": "Output only. Whether reconciling is in progress, recommended per https://google.aip.dev/128.", +"readOnly": true, +"type": "boolean" +}, +"state": { +"description": "Output only. Current state of the endpoint.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"DELETING", +"INACTIVE" +], +"enumDescriptions": [ +"Not set.", +"Being created.", +"Processing configuration updates.", +"Being deleted.", +"Down or in an error state." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. Update time stamp", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"FirewallEndpointAssociation": { +"description": "Message describing Association object", +"id": "FirewallEndpointAssociation", +"properties": { +"createTime": { +"description": "Output only. Create time stamp", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"disabled": { +"description": "Optional. Whether the association is disabled. True indicates that traffic won't be intercepted", +"type": "boolean" +}, +"firewallEndpoint": { +"description": "Required. The URL of the FirewallEndpoint that is being associated.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Labels as key value pairs", +"type": "object" +}, +"name": { +"description": "Immutable. Identifier. name of resource", +"type": "string" +}, +"network": { +"description": "Required. The URL of the network that is being associated.", +"type": "string" +}, +"reconciling": { +"description": "Output only. Whether reconciling is in progress, recommended per https://google.aip.dev/128.", +"readOnly": true, +"type": "boolean" +}, +"state": { +"description": "Output only. Current state of the association.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"ACTIVE", +"DELETING", +"INACTIVE", +"ORPHAN" +], +"enumDescriptions": [ +"Not set.", +"Being created.", +"Active and ready for traffic.", +"Being deleted.", +"Down or in an error state.", +"The project that housed the association has been deleted." +], +"readOnly": true, +"type": "string" +}, +"tlsInspectionPolicy": { +"description": "Optional. The URL of the TlsInspectionPolicy that is being associated.", +"type": "string" +}, +"updateTime": { +"description": "Output only. Update time stamp", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"FirewallEndpointAssociationReference": { +"description": "This is a subset of the FirewallEndpointAssociation message, containing fields to be used by the consumer.", +"id": "FirewallEndpointAssociationReference", +"properties": { +"name": { +"description": "Output only. The resource name of the FirewallEndpointAssociation. Format: projects/{project}/locations/{location}/firewallEndpointAssociations/{id}", +"readOnly": true, +"type": "string" +}, +"network": { +"description": "Output only. The VPC network associated. Format: projects/{project}/global/networks/{name}.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GatewaySecurityPolicy": { +"description": "The GatewaySecurityPolicy resource contains a collection of GatewaySecurityPolicyRules and associated metadata.", +"id": "GatewaySecurityPolicy", +"properties": { +"createTime": { +"description": "Output only. The timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. Free-text description of the resource.", +"type": "string" +}, +"name": { +"description": "Required. Name of the resource. Name is of the form projects/{project}/locations/{location}/gatewaySecurityPolicies/{gateway_security_policy} gateway_security_policy should match the pattern:(^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$).", +"type": "string" +}, +"tlsInspectionPolicy": { +"description": "Optional. Name of a TLS Inspection Policy resource that defines how TLS inspection will be performed for any rule(s) which enables it.", +"type": "string" +}, +"updateTime": { +"description": "Output only. The timestamp when the resource was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GatewaySecurityPolicyRule": { +"description": "The GatewaySecurityPolicyRule resource is in a nested collection within a GatewaySecurityPolicy and represents a traffic matching condition and associated action to perform.", +"id": "GatewaySecurityPolicyRule", +"properties": { +"applicationMatcher": { +"description": "Optional. CEL expression for matching on L7/application level criteria.", +"type": "string" +}, +"basicProfile": { +"description": "Required. Profile which tells what the primitive action should be.", +"enum": [ +"BASIC_PROFILE_UNSPECIFIED", +"ALLOW", +"DENY" +], +"enumDescriptions": [ +"If there is not a mentioned action for the target.", +"Allow the matched traffic.", +"Deny the matched traffic." +], +"type": "string" +}, +"createTime": { +"description": "Output only. Time when the rule was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. Free-text description of the resource.", +"type": "string" +}, +"enabled": { +"description": "Required. Whether the rule is enforced.", +"type": "boolean" +}, +"name": { +"description": "Required. Immutable. Name of the resource. ame is the full resource name so projects/{project}/locations/{location}/gatewaySecurityPolicies/{gateway_security_policy}/rules/{rule} rule should match the pattern: (^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$).", +"type": "string" +}, +"priority": { +"description": "Required. Priority of the rule. Lower number corresponds to higher precedence.", +"format": "int32", +"type": "integer" +}, +"sessionMatcher": { +"description": "Required. CEL expression for matching on session criteria.", +"type": "string" +}, +"tlsInspectionEnabled": { +"description": "Optional. Flag to enable TLS inspection of traffic matching on , can only be true if the parent GatewaySecurityPolicy references a TLSInspectionConfig.", +"type": "boolean" +}, +"updateTime": { +"description": "Output only. Time when the rule was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudNetworksecurityV1CertificateProvider": { +"description": "Specification of certificate provider. Defines the mechanism to obtain the certificate and private key for peer to peer authentication.", +"id": "GoogleCloudNetworksecurityV1CertificateProvider", +"properties": { +"certificateProviderInstance": { +"$ref": "CertificateProviderInstance", +"description": "The certificate provider instance specification that will be passed to the data plane, which will be used to load necessary credential information." +}, +"grpcEndpoint": { +"$ref": "GoogleCloudNetworksecurityV1GrpcEndpoint", +"description": "gRPC specific configuration to access the gRPC server to obtain the cert and private key." +} +}, +"type": "object" +}, +"GoogleCloudNetworksecurityV1GrpcEndpoint": { +"description": "Specification of the GRPC Endpoint.", +"id": "GoogleCloudNetworksecurityV1GrpcEndpoint", +"properties": { +"targetUri": { +"description": "Required. The target URI of the gRPC endpoint. Only UDS path is supported, and should start with \"unix:\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleIamV1AuditConfig": { +"description": "Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { \"audit_configs\": [ { \"service\": \"allServices\", \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\", \"exempted_members\": [ \"user:jose@example.com\" ] }, { \"log_type\": \"DATA_WRITE\" }, { \"log_type\": \"ADMIN_READ\" } ] }, { \"service\": \"sampleservice.googleapis.com\", \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\" }, { \"log_type\": \"DATA_WRITE\", \"exempted_members\": [ \"user:aliya@example.com\" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.", +"id": "GoogleIamV1AuditConfig", +"properties": { +"auditLogConfigs": { +"description": "The configuration for logging of each type of permission.", +"items": { +"$ref": "GoogleIamV1AuditLogConfig" +}, +"type": "array" +}, +"service": { +"description": "Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleIamV1AuditLogConfig": { +"description": "Provides the configuration for logging a type of permissions. Example: { \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\", \"exempted_members\": [ \"user:jose@example.com\" ] }, { \"log_type\": \"DATA_WRITE\" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.", +"id": "GoogleIamV1AuditLogConfig", +"properties": { +"exemptedMembers": { +"description": "Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.", +"items": { +"type": "string" +}, +"type": "array" +}, +"logType": { +"description": "The log type that this config enables.", +"enum": [ +"LOG_TYPE_UNSPECIFIED", +"ADMIN_READ", +"DATA_WRITE", +"DATA_READ" +], +"enumDescriptions": [ +"Default case. Should never be this.", +"Admin reads. Example: CloudIAM getIamPolicy", +"Data writes. Example: CloudSQL Users create", +"Data reads. Example: CloudSQL Users list" +], +"type": "string" +} +}, +"type": "object" +}, +"GoogleIamV1Binding": { +"description": "Associates `members`, or principals, with a `role`.", +"id": "GoogleIamV1Binding", +"properties": { +"condition": { +"$ref": "Expr", +"description": "The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies)." +}, +"members": { +"description": "Specifies the principals requesting access for a Google Cloud resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workforce identity pool. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/group/{group_id}`: All workforce identities in a group. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All workforce identities with a specific attribute value. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/*`: All identities in a workforce identity pool. * `principal://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workload identity pool. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/group/{group_id}`: A workload identity pool group. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All identities in a workload identity pool with a certain attribute. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/*`: All identities in a workload identity pool. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: Deleted single identity in a workforce identity pool. For example, `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-pool-id/subject/my-subject-attribute-value`.", +"items": { +"type": "string" +}, +"type": "array" +}, +"role": { +"description": "Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview of the IAM roles and permissions, see the [IAM documentation](https://cloud.google.com/iam/docs/roles-overview). For a list of the available pre-defined roles, see [here](https://cloud.google.com/iam/docs/understanding-roles).", +"type": "string" +} +}, +"type": "object" +}, +"GoogleIamV1Policy": { +"description": "An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** ``` { \"bindings\": [ { \"role\": \"roles/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike@example.com\", \"group:admins@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles/resourcemanager.organizationViewer\", \"members\": [ \"user:eve@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time < timestamp('2020-10-01T00:00:00.000Z')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 } ``` **YAML example:** ``` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 ``` For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).", +"id": "GoogleIamV1Policy", +"properties": { +"auditConfigs": { +"description": "Specifies cloud audit logging configuration for this policy.", +"items": { +"$ref": "GoogleIamV1AuditConfig" +}, +"type": "array" +}, +"bindings": { +"description": "Associates a list of `members`, or principals, with a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one principal. The `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of these principals can be Google groups. Each occurrence of a principal counts towards these limits. For example, if the `bindings` grant 50 different roles to `user:alice@example.com`, and not to any other principal, then you can add another 1,450 principals to the `bindings` in the `Policy`.", +"items": { +"$ref": "GoogleIamV1Binding" +}, +"type": "array" +}, +"etag": { +"description": "`etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.", +"format": "byte", +"type": "string" +}, +"version": { +"description": "Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"GoogleIamV1SetIamPolicyRequest": { +"description": "Request message for `SetIamPolicy` method.", +"id": "GoogleIamV1SetIamPolicyRequest", +"properties": { +"policy": { +"$ref": "GoogleIamV1Policy", +"description": "REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them." +}, +"updateMask": { +"description": "OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only the fields in the mask will be modified. If no mask is provided, the following default mask is used: `paths: \"bindings, etag\"`", +"format": "google-fieldmask", +"type": "string" +} +}, +"type": "object" +}, +"GoogleIamV1TestIamPermissionsRequest": { +"description": "Request message for `TestIamPermissions` method.", +"id": "GoogleIamV1TestIamPermissionsRequest", +"properties": { +"permissions": { +"description": "The set of permissions to check for the `resource`. Permissions with wildcards (such as `*` or `storage.*`) are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleIamV1TestIamPermissionsResponse": { +"description": "Response message for `TestIamPermissions` method.", +"id": "GoogleIamV1TestIamPermissionsResponse", +"properties": { +"permissions": { +"description": "A subset of `TestPermissionsRequest.permissions` that the caller is allowed.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"HttpHeaderMatch": { +"description": "Specification of HTTP header match attributes.", +"id": "HttpHeaderMatch", +"properties": { +"headerName": { +"description": "Required. The name of the HTTP header to match. For matching against the HTTP request's authority, use a headerMatch with the header name \":authority\". For matching a request's method, use the headerName \":method\".", +"type": "string" +}, +"regexMatch": { +"description": "Required. The value of the header must match the regular expression specified in regexMatch. For regular expression grammar, please see: en.cppreference.com/w/cpp/regex/ecmascript For matching against a port specified in the HTTP request, use a headerMatch with headerName set to Host and a regular expression that satisfies the RFC2616 Host header's port specifier.", +"type": "string" +} +}, +"type": "object" +}, +"ListAddressGroupReferencesResponse": { +"description": "Response of the ListAddressGroupReferences method.", +"id": "ListAddressGroupReferencesResponse", +"properties": { +"addressGroupReferences": { +"description": "A list of references that matches the specified filter in the request.", +"items": { +"$ref": "ListAddressGroupReferencesResponseAddressGroupReference" +}, +"type": "array" +}, +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then `next_page_token` is included. To get the next set of results, call this method again using the value of `next_page_token` as `page_token`.", +"type": "string" +} +}, +"type": "object" +}, +"ListAddressGroupReferencesResponseAddressGroupReference": { +"description": "The Reference of AddressGroup.", +"id": "ListAddressGroupReferencesResponseAddressGroupReference", +"properties": { +"firewallPolicy": { +"description": "FirewallPolicy that is using the Address Group.", +"type": "string" +}, +"rulePriority": { +"description": "Rule priority of the FirewallPolicy that is using the Address Group.", +"format": "int32", +"type": "integer" +}, +"securityPolicy": { +"description": "Cloud Armor SecurityPolicy that is using the Address Group.", +"type": "string" +} +}, +"type": "object" +}, +"ListAddressGroupsResponse": { +"description": "Response returned by the ListAddressGroups method.", +"id": "ListAddressGroupsResponse", +"properties": { +"addressGroups": { +"description": "List of AddressGroups resources.", +"items": { +"$ref": "AddressGroup" +}, +"type": "array" +}, +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then `next_page_token` is included. To get the next set of results, call this method again using the value of `next_page_token` as `page_token`.", +"type": "string" +} +}, +"type": "object" +}, +"ListAuthorizationPoliciesResponse": { +"description": "Response returned by the ListAuthorizationPolicies method.", +"id": "ListAuthorizationPoliciesResponse", +"properties": { +"authorizationPolicies": { +"description": "List of AuthorizationPolicies resources.", +"items": { +"$ref": "AuthorizationPolicy" +}, +"type": "array" +}, +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then `next_page_token` is included. To get the next set of results, call this method again using the value of `next_page_token` as `page_token`.", +"type": "string" +} +}, +"type": "object" +}, +"ListAuthzPoliciesResponse": { +"description": "Message for response to listing `AuthzPolicy` resources.", +"id": "ListAuthzPoliciesResponse", +"properties": { +"authzPolicies": { +"description": "The list of `AuthzPolicy` resources.", +"items": { +"$ref": "AuthzPolicy" +}, +"type": "array" +}, +"nextPageToken": { +"description": "A token identifying a page of results that the server returns.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListClientTlsPoliciesResponse": { +"description": "Response returned by the ListClientTlsPolicies method.", +"id": "ListClientTlsPoliciesResponse", +"properties": { +"clientTlsPolicies": { +"description": "List of ClientTlsPolicy resources.", +"items": { +"$ref": "ClientTlsPolicy" +}, +"type": "array" +}, +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then `next_page_token` is included. To get the next set of results, call this method again using the value of `next_page_token` as `page_token`.", +"type": "string" +} +}, +"type": "object" +}, +"ListFirewallEndpointAssociationsResponse": { +"description": "Message for response to listing Associations", +"id": "ListFirewallEndpointAssociationsResponse", +"properties": { +"firewallEndpointAssociations": { +"description": "The list of Association", +"items": { +"$ref": "FirewallEndpointAssociation" +}, +"type": "array" +}, +"nextPageToken": { +"description": "A token identifying a page of results the server should return.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListFirewallEndpointsResponse": { +"description": "Message for response to listing Endpoints", +"id": "ListFirewallEndpointsResponse", +"properties": { +"firewallEndpoints": { +"description": "The list of Endpoint", +"items": { +"$ref": "FirewallEndpoint" +}, +"type": "array" +}, +"nextPageToken": { +"description": "A token identifying a page of results the server should return.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListGatewaySecurityPoliciesResponse": { +"description": "Response returned by the ListGatewaySecurityPolicies method.", +"id": "ListGatewaySecurityPoliciesResponse", +"properties": { +"gatewaySecurityPolicies": { +"description": "List of GatewaySecurityPolicies resources.", +"items": { +"$ref": "GatewaySecurityPolicy" +}, +"type": "array" +}, +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then 'next_page_token' is included. To get the next set of results, call this method again using the value of 'next_page_token' as 'page_token'.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListGatewaySecurityPolicyRulesResponse": { +"description": "Response returned by the ListGatewaySecurityPolicyRules method.", +"id": "ListGatewaySecurityPolicyRulesResponse", +"properties": { +"gatewaySecurityPolicyRules": { +"description": "List of GatewaySecurityPolicyRule resources.", +"items": { +"$ref": "GatewaySecurityPolicyRule" +}, +"type": "array" +}, +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then 'next_page_token' is included. To get the next set of results, call this method again using the value of 'next_page_token' as 'page_token'.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListLocationsResponse": { +"description": "The response message for Locations.ListLocations.", +"id": "ListLocationsResponse", +"properties": { +"locations": { +"description": "A list of locations that matches the specified filter in the request.", +"items": { +"$ref": "Location" +}, +"type": "array" +}, +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +} +}, +"type": "object" +}, +"ListOperationsResponse": { +"description": "The response message for Operations.ListOperations.", +"id": "ListOperationsResponse", +"properties": { +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +}, +"operations": { +"description": "A list of operations that matches the specified filter in the request.", +"items": { +"$ref": "Operation" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListSecurityProfileGroupsResponse": { +"description": "Response returned by the ListSecurityProfileGroups method.", +"id": "ListSecurityProfileGroupsResponse", +"properties": { +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then `next_page_token` is included. To get the next set of results, call this method again using the value of `next_page_token` as `page_token`.", +"type": "string" +}, +"securityProfileGroups": { +"description": "List of SecurityProfileGroups resources.", +"items": { +"$ref": "SecurityProfileGroup" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListSecurityProfilesResponse": { +"description": "Response returned by the ListSecurityProfiles method.", +"id": "ListSecurityProfilesResponse", +"properties": { +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then `next_page_token` is included. To get the next set of results, call this method again using the value of `next_page_token` as `page_token`.", +"type": "string" +}, +"securityProfiles": { +"description": "List of SecurityProfile resources.", +"items": { +"$ref": "SecurityProfile" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListServerTlsPoliciesResponse": { +"description": "Response returned by the ListServerTlsPolicies method.", +"id": "ListServerTlsPoliciesResponse", +"properties": { +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then `next_page_token` is included. To get the next set of results, call this method again using the value of `next_page_token` as `page_token`.", +"type": "string" +}, +"serverTlsPolicies": { +"description": "List of ServerTlsPolicy resources.", +"items": { +"$ref": "ServerTlsPolicy" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListTlsInspectionPoliciesResponse": { +"description": "Response returned by the ListTlsInspectionPolicies method.", +"id": "ListTlsInspectionPoliciesResponse", +"properties": { +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then 'next_page_token' is included. To get the next set of results, call this method again using the value of 'next_page_token' as 'page_token'.", +"type": "string" +}, +"tlsInspectionPolicies": { +"description": "List of TlsInspectionPolicies resources.", +"items": { +"$ref": "TlsInspectionPolicy" +}, +"type": "array" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListUrlListsResponse": { +"description": "Response returned by the ListUrlLists method.", +"id": "ListUrlListsResponse", +"properties": { +"nextPageToken": { +"description": "If there might be more results than those appearing in this response, then `next_page_token` is included. To get the next set of results, call this method again using the value of `next_page_token` as `page_token`.", +"type": "string" +}, +"unreachable": { +"description": "Locations that could not be reached.", +"items": { +"type": "string" +}, +"type": "array" +}, +"urlLists": { +"description": "List of UrlList resources.", +"items": { +"$ref": "UrlList" +}, +"type": "array" +} +}, +"type": "object" +}, +"Location": { +"description": "A resource that represents a Google Cloud location.", +"id": "Location", +"properties": { +"displayName": { +"description": "The friendly name for this location, typically a nearby city name. For example, \"Tokyo\".", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Cross-service attributes for the location. For example {\"cloud.googleapis.com/region\": \"us-east1\"}", +"type": "object" +}, +"locationId": { +"description": "The canonical id for this location. For example: `\"us-east1\"`.", +"type": "string" +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata. For example the available capacity at the given location.", +"type": "object" +}, +"name": { +"description": "Resource name for the location, which may vary between implementations. For example: `\"projects/example-project/locations/us-east1\"`", +"type": "string" +} +}, +"type": "object" +}, +"MTLSPolicy": { +"description": "Specification of the MTLSPolicy.", +"id": "MTLSPolicy", +"properties": { +"clientValidationCa": { +"description": "Required if the policy is to be used with Traffic Director. For Application Load Balancers it must be empty. Defines the mechanism to obtain the Certificate Authority certificate to validate the client certificate.", +"items": { +"$ref": "ValidationCA" +}, +"type": "array" +}, +"clientValidationMode": { +"description": "When the client presents an invalid certificate or no certificate to the load balancer, the `client_validation_mode` specifies how the client connection is handled. Required if the policy is to be used with the Application Load Balancers. For Traffic Director it must be empty.", +"enum": [ +"CLIENT_VALIDATION_MODE_UNSPECIFIED", +"ALLOW_INVALID_OR_MISSING_CLIENT_CERT", +"REJECT_INVALID" +], +"enumDescriptions": [ +"Not allowed.", +"Allow connection even if certificate chain validation of the client certificate failed or no client certificate was presented. The proof of possession of the private key is always checked if client certificate was presented. This mode requires the backend to implement processing of data extracted from a client certificate to authenticate the peer, or to reject connections if the client certificate fingerprint is missing.", +"Require a client certificate and allow connection to the backend only if validation of the client certificate passed. If set, requires a reference to non-empty TrustConfig specified in `client_validation_trust_config`." +], +"type": "string" +}, +"clientValidationTrustConfig": { +"description": "Reference to the TrustConfig from certificatemanager.googleapis.com namespace. If specified, the chain validation will be performed against certificates configured in the given TrustConfig. Allowed only if the policy is to be used with Application Load Balancers.", +"type": "string" +} +}, +"type": "object" +}, +"Operation": { +"description": "This resource represents a long-running operation that is the result of a network API call.", +"id": "Operation", +"properties": { +"done": { +"description": "If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.", +"type": "boolean" +}, +"error": { +"$ref": "Status", +"description": "The error result of the operation in case of failure or cancellation." +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.", +"type": "object" +}, +"name": { +"description": "The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.", +"type": "string" +}, +"response": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.", +"type": "object" +} +}, +"type": "object" +}, +"OperationMetadata": { +"description": "Represents the metadata of the long-running operation.", +"id": "OperationMetadata", +"properties": { +"apiVersion": { +"description": "Output only. API version used to start the operation.", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The time the operation was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"endTime": { +"description": "Output only. The time the operation finished running.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"requestedCancellation": { +"description": "Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"readOnly": true, +"type": "boolean" +}, +"statusMessage": { +"description": "Output only. Human-readable status of the operation, if any.", +"readOnly": true, +"type": "string" +}, +"target": { +"description": "Output only. Server-defined resource path for the target of the operation.", +"readOnly": true, +"type": "string" +}, +"verb": { +"description": "Output only. Name of the verb executed by the operation.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"RemoveAddressGroupItemsRequest": { +"description": "Request used by the RemoveAddressGroupItems method.", +"id": "RemoveAddressGroupItemsRequest", +"properties": { +"items": { +"description": "Required. List of items to remove.", +"items": { +"type": "string" +}, +"type": "array" +}, +"requestId": { +"description": "Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).", +"type": "string" +} +}, +"type": "object" +}, +"Rule": { +"description": "Specification of rules.", +"id": "Rule", +"properties": { +"destinations": { +"description": "Optional. List of attributes for the traffic destination. All of the destinations must match. A destination is a match if a request matches all the specified hosts, ports, methods and headers. If not set, the action specified in the 'action' field will be applied without any rule checks for the destination.", +"items": { +"$ref": "Destination" +}, +"type": "array" +}, +"sources": { +"description": "Optional. List of attributes for the traffic source. All of the sources must match. A source is a match if both principals and ip_blocks match. If not set, the action specified in the 'action' field will be applied without any rule checks for the source.", +"items": { +"$ref": "Source" +}, +"type": "array" +} +}, +"type": "object" +}, +"SecurityProfile": { +"description": "SecurityProfile is a resource that defines the behavior for one of many ProfileTypes.", +"id": "SecurityProfile", +"properties": { +"createTime": { +"description": "Output only. Resource creation timestamp.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"customInterceptProfile": { +"$ref": "CustomInterceptProfile", +"description": "The custom TPPI configuration for the SecurityProfile." +}, +"customMirroringProfile": { +"$ref": "CustomMirroringProfile", +"description": "The custom Packet Mirroring v2 configuration for the SecurityProfile." +}, +"description": { +"description": "Optional. An optional description of the profile. Max length 512 characters.", +"type": "string" +}, +"etag": { +"description": "Output only. This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Labels as key value pairs.", +"type": "object" +}, +"name": { +"description": "Immutable. Identifier. Name of the SecurityProfile resource. It matches pattern `projects|organizations/*/locations/{location}/securityProfiles/{security_profile}`.", +"type": "string" +}, +"threatPreventionProfile": { +"$ref": "ThreatPreventionProfile", +"description": "The threat prevention configuration for the SecurityProfile." +}, +"type": { +"description": "Immutable. The single ProfileType that the SecurityProfile resource configures.", +"enum": [ +"PROFILE_TYPE_UNSPECIFIED", +"THREAT_PREVENTION", +"CUSTOM_MIRRORING", +"CUSTOM_INTERCEPT" +], +"enumDescriptions": [ +"Profile type not specified.", +"Profile type for threat prevention.", +"Profile type for packet mirroring v2", +"Profile type for TPPI." +], +"type": "string" +}, +"updateTime": { +"description": "Output only. Last resource update timestamp.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"SecurityProfileGroup": { +"description": "SecurityProfileGroup is a resource that defines the behavior for various ProfileTypes.", +"id": "SecurityProfileGroup", +"properties": { +"createTime": { +"description": "Output only. Resource creation timestamp.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"customInterceptProfile": { +"description": "Optional. Reference to a SecurityProfile with the CustomIntercept configuration.", +"type": "string" +}, +"customMirroringProfile": { +"description": "Optional. Reference to a SecurityProfile with the CustomMirroring configuration.", +"type": "string" +}, +"description": { +"description": "Optional. An optional description of the profile group. Max length 2048 characters.", +"type": "string" +}, +"etag": { +"description": "Output only. This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.", +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. Labels as key value pairs.", +"type": "object" +}, +"name": { +"description": "Immutable. Identifier. Name of the SecurityProfileGroup resource. It matches pattern `projects|organizations/*/locations/{location}/securityProfileGroups/{security_profile_group}`.", +"type": "string" +}, +"threatPreventionProfile": { +"description": "Optional. Reference to a SecurityProfile with the ThreatPrevention configuration.", +"type": "string" +}, +"updateTime": { +"description": "Output only. Last resource update timestamp.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ServerTlsPolicy": { +"description": "ServerTlsPolicy is a resource that specifies how a server should authenticate incoming requests. This resource itself does not affect configuration unless it is attached to a target HTTPS proxy or endpoint config selector resource. ServerTlsPolicy in the form accepted by Application Load Balancers can be attached only to TargetHttpsProxy with an `EXTERNAL`, `EXTERNAL_MANAGED` or `INTERNAL_MANAGED` load balancing scheme. Traffic Director compatible ServerTlsPolicies can be attached to EndpointPolicy and TargetHttpsProxy with Traffic Director `INTERNAL_SELF_MANAGED` load balancing scheme.", +"id": "ServerTlsPolicy", +"properties": { +"allowOpen": { +"description": "This field applies only for Traffic Director policies. It is must be set to false for Application Load Balancer policies. Determines if server allows plaintext connections. If set to true, server allows plain text connections. By default, it is set to false. This setting is not exclusive of other encryption modes. For example, if `allow_open` and `mtls_policy` are set, server allows both plain text and mTLS connections. See documentation of other encryption modes to confirm compatibility. Consider using it if you wish to upgrade in place your deployment to TLS while having mixed TLS and non-TLS traffic reaching port :80.", +"type": "boolean" +}, +"createTime": { +"description": "Output only. The timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Free-text description of the resource.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Set of label tags associated with the resource.", +"type": "object" +}, +"mtlsPolicy": { +"$ref": "MTLSPolicy", +"description": "This field is required if the policy is used with Application Load Balancers. This field can be empty for Traffic Director. Defines a mechanism to provision peer validation certificates for peer to peer authentication (Mutual TLS - mTLS). If not specified, client certificate will not be requested. The connection is treated as TLS and not mTLS. If `allow_open` and `mtls_policy` are set, server allows both plain text and mTLS connections." +}, +"name": { +"description": "Required. Name of the ServerTlsPolicy resource. It matches the pattern `projects/*/locations/{location}/serverTlsPolicies/{server_tls_policy}`", +"type": "string" +}, +"serverCertificate": { +"$ref": "GoogleCloudNetworksecurityV1CertificateProvider", +"description": "Optional if policy is to be used with Traffic Director. For Application Load Balancers must be empty. Defines a mechanism to provision server identity (public and private keys). Cannot be combined with `allow_open` as a permissive mode that allows both plain text and TLS is not supported." +}, +"updateTime": { +"description": "Output only. The timestamp when the resource was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"SeverityOverride": { +"description": "Defines what action to take for a specific severity match.", +"id": "SeverityOverride", +"properties": { +"action": { +"description": "Required. Threat action override.", +"enum": [ +"THREAT_ACTION_UNSPECIFIED", +"DEFAULT_ACTION", +"ALLOW", +"ALERT", +"DENY" +], +"enumDescriptions": [ +"Threat action not specified.", +"The default action (as specified by the vendor) is taken.", +"The packet matching this rule will be allowed to transmit.", +"The packet matching this rule will be allowed to transmit, but a threat_log entry will be sent to the consumer project.", +"The packet matching this rule will be dropped, and a threat_log entry will be sent to the consumer project." +], +"type": "string" +}, +"severity": { +"description": "Required. Severity level to match.", +"enum": [ +"SEVERITY_UNSPECIFIED", +"INFORMATIONAL", +"LOW", +"MEDIUM", +"HIGH", +"CRITICAL" +], +"enumDescriptions": [ +"Severity level not specified.", +"Suspicious events that do not pose an immediate threat, but that are reported to call attention to deeper problems that could possibly exist.", +"Warning-level threats that have very little impact on an organization's infrastructure. They usually require local or physical system access and may often result in victim privacy issues and information leakage.", +"Minor threats in which impact is minimized, that do not compromise the target or exploits that require an attacker to reside on the same local network as the victim, affect only non-standard configurations or obscure applications, or provide very limited access.", +"Threats that have the ability to become critical but have mitigating factors; for example, they may be difficult to exploit, do not result in elevated privileges, or do not have a large victim pool.", +"Serious threats, such as those that affect default installations of widely deployed software, result in root compromise of servers, and the exploit code is widely available to attackers. The attacker usually does not need any special authentication credentials or knowledge about the individual victims and the target does not need to be manipulated into performing any special functions." +], +"type": "string" +} +}, +"type": "object" +}, +"Source": { +"description": "Specification of traffic source attributes.", +"id": "Source", +"properties": { +"ipBlocks": { +"description": "Optional. List of CIDR ranges to match based on source IP address. At least one IP block should match. Single IP (e.g., \"1.2.3.4\") and CIDR (e.g., \"1.2.3.0/24\") are supported. Authorization based on source IP alone should be avoided. The IP addresses of any load balancers or proxies should be considered untrusted.", +"items": { +"type": "string" +}, +"type": "array" +}, +"principals": { +"description": "Optional. List of peer identities to match for authorization. At least one principal should match. Each peer can be an exact match, or a prefix match (example, \"namespace/*\") or a suffix match (example, \"*/service-account\") or a presence match \"*\". Authorization based on the principal name without certificate validation (configured by ServerTlsPolicy resource) is considered insecure.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Status": { +"description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", +"id": "Status", +"properties": { +"code": { +"description": "The status code, which should be an enum value of google.rpc.Code.", +"format": "int32", +"type": "integer" +}, +"details": { +"description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", +"items": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"type": "object" +}, +"type": "array" +}, +"message": { +"description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", +"type": "string" +} +}, +"type": "object" +}, +"ThreatOverride": { +"description": "Defines what action to take for a specific threat_id match.", +"id": "ThreatOverride", +"properties": { +"action": { +"description": "Required. Threat action override. For some threat types, only a subset of actions applies.", +"enum": [ +"THREAT_ACTION_UNSPECIFIED", +"DEFAULT_ACTION", +"ALLOW", +"ALERT", +"DENY" +], +"enumDescriptions": [ +"Threat action not specified.", +"The default action (as specified by the vendor) is taken.", +"The packet matching this rule will be allowed to transmit.", +"The packet matching this rule will be allowed to transmit, but a threat_log entry will be sent to the consumer project.", +"The packet matching this rule will be dropped, and a threat_log entry will be sent to the consumer project." +], +"type": "string" +}, +"threatId": { +"description": "Required. Vendor-specific ID of a threat to override.", +"type": "string" +}, +"type": { +"description": "Output only. Type of the threat (read only).", +"enum": [ +"THREAT_TYPE_UNSPECIFIED", +"UNKNOWN", +"VULNERABILITY", +"ANTIVIRUS", +"SPYWARE", +"DNS" +], +"enumDescriptions": [ +"Type of threat not specified.", +"Type of threat is not derivable from threat ID. An override will be created for all types. Firewall will ignore overridden signature ID's that don't exist in the specific type.", +"Threats related to system flaws that an attacker might otherwise attempt to exploit.", +"Threats related to viruses and malware found in executables and file types.", +"Threats related to command-and-control (C2) activity, where spyware on an infected client is collecting data without the user's consent and/or communicating with a remote attacker.", +"Threats related to DNS." +], +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ThreatPreventionProfile": { +"description": "ThreatPreventionProfile defines an action for specific threat signatures or severity levels.", +"id": "ThreatPreventionProfile", +"properties": { +"severityOverrides": { +"description": "Optional. Configuration for overriding threats actions by severity match.", +"items": { +"$ref": "SeverityOverride" +}, +"type": "array" +}, +"threatOverrides": { +"description": "Optional. Configuration for overriding threats actions by threat_id match. If a threat is matched both by configuration provided in severity_overrides and threat_overrides, the threat_overrides action is applied.", +"items": { +"$ref": "ThreatOverride" +}, +"type": "array" +} +}, +"type": "object" +}, +"TlsInspectionPolicy": { +"description": "The TlsInspectionPolicy resource contains references to CA pools in Certificate Authority Service and associated metadata.", +"id": "TlsInspectionPolicy", +"properties": { +"caPool": { +"description": "Required. A CA pool resource used to issue interception certificates. The CA pool string has a relative resource path following the form \"projects/{project}/locations/{location}/caPools/{ca_pool}\".", +"type": "string" +}, +"createTime": { +"description": "Output only. The timestamp when the resource was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"customTlsFeatures": { +"description": "Optional. List of custom TLS cipher suites selected. This field is valid only if the selected tls_feature_profile is CUSTOM. The compute.SslPoliciesService.ListAvailableFeatures method returns the set of features that can be specified in this list. Note that Secure Web Proxy does not yet honor this field.", +"items": { +"type": "string" +}, +"type": "array" +}, +"description": { +"description": "Optional. Free-text description of the resource.", +"type": "string" +}, +"excludePublicCaSet": { +"description": "Optional. If FALSE (the default), use our default set of public CAs in addition to any CAs specified in trust_config. These public CAs are currently based on the Mozilla Root Program and are subject to change over time. If TRUE, do not accept our default set of public CAs. Only CAs specified in trust_config will be accepted. This defaults to FALSE (use public CAs in addition to trust_config) for backwards compatibility, but trusting public root CAs is *not recommended* unless the traffic in question is outbound to public web servers. When possible, prefer setting this to \"false\" and explicitly specifying trusted CAs and certificates in a TrustConfig. Note that Secure Web Proxy does not yet honor this field.", +"type": "boolean" +}, +"minTlsVersion": { +"description": "Optional. Minimum TLS version that the firewall should use when negotiating connections with both clients and servers. If this is not set, then the default value is to allow the broadest set of clients and servers (TLS 1.0 or higher). Setting this to more restrictive values may improve security, but may also prevent the firewall from connecting to some clients or servers. Note that Secure Web Proxy does not yet honor this field.", +"enum": [ +"TLS_VERSION_UNSPECIFIED", +"TLS_1_0", +"TLS_1_1", +"TLS_1_2", +"TLS_1_3" +], +"enumDescriptions": [ +"Indicates no TLS version was specified.", +"TLS 1.0", +"TLS 1.1", +"TLS 1.2", +"TLS 1.3" +], +"type": "string" +}, +"name": { +"description": "Required. Name of the resource. Name is of the form projects/{project}/locations/{location}/tlsInspectionPolicies/{tls_inspection_policy} tls_inspection_policy should match the pattern:(^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$).", +"type": "string" +}, +"tlsFeatureProfile": { +"description": "Optional. The selected Profile. If this is not set, then the default value is to allow the broadest set of clients and servers (\"PROFILE_COMPATIBLE\"). Setting this to more restrictive values may improve security, but may also prevent the TLS inspection proxy from connecting to some clients or servers. Note that Secure Web Proxy does not yet honor this field.", +"enum": [ +"PROFILE_UNSPECIFIED", +"PROFILE_COMPATIBLE", +"PROFILE_MODERN", +"PROFILE_RESTRICTED", +"PROFILE_CUSTOM" +], +"enumDescriptions": [ +"Indicates no profile was specified.", +"Compatible profile. Allows the broadest set of clients, even those which support only out-of-date SSL features to negotiate with the TLS inspection proxy.", +"Modern profile. Supports a wide set of SSL features, allowing modern clients to negotiate SSL with the TLS inspection proxy.", +"Restricted profile. Supports a reduced set of SSL features, intended to meet stricter compliance requirements.", +"Custom profile. Allow only the set of allowed SSL features specified in the custom_features field of SslPolicy." +], +"type": "string" +}, +"trustConfig": { +"description": "Optional. A TrustConfig resource used when making a connection to the TLS server. This is a relative resource path following the form \"projects/{project}/locations/{location}/trustConfigs/{trust_config}\". This is necessary to intercept TLS connections to servers with certificates signed by a private CA or self-signed certificates. Note that Secure Web Proxy does not yet honor this field.", +"type": "string" +}, +"updateTime": { +"description": "Output only. The timestamp when the resource was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"UrlList": { +"description": "UrlList proto helps users to set reusable, independently manageable lists of hosts, host patterns, URLs, URL patterns.", +"id": "UrlList", +"properties": { +"createTime": { +"description": "Output only. Time when the security policy was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"description": { +"description": "Optional. Free-text description of the resource.", +"type": "string" +}, +"name": { +"description": "Required. Name of the resource provided by the user. Name is of the form projects/{project}/locations/{location}/urlLists/{url_list} url_list should match the pattern:(^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$).", +"type": "string" +}, +"updateTime": { +"description": "Output only. Time when the security policy was updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"values": { +"description": "Required. FQDNs and URLs.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ValidationCA": { +"description": "Specification of ValidationCA. Defines the mechanism to obtain the Certificate Authority certificate to validate the peer certificate.", +"id": "ValidationCA", +"properties": { +"certificateProviderInstance": { +"$ref": "CertificateProviderInstance", +"description": "The certificate provider instance specification that will be passed to the data plane, which will be used to load necessary credential information." +}, +"grpcEndpoint": { +"$ref": "GoogleCloudNetworksecurityV1GrpcEndpoint", +"description": "gRPC specific configuration to access the gRPC server to obtain the CA certificate." +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Network Security API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/places.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/places.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..4ad608c7caf33c94424923c937796a3989fa03bc --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/places.v1.json @@ -0,0 +1,2323 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +}, +"https://www.googleapis.com/auth/maps-platform.places": { +"description": "Private Service: https://www.googleapis.com/auth/maps-platform.places" +}, +"https://www.googleapis.com/auth/maps-platform.places.autocomplete": { +"description": "Private Service: https://www.googleapis.com/auth/maps-platform.places.autocomplete" +}, +"https://www.googleapis.com/auth/maps-platform.places.details": { +"description": "Private Service: https://www.googleapis.com/auth/maps-platform.places.details" +}, +"https://www.googleapis.com/auth/maps-platform.places.getphotomedia": { +"description": "Private Service: https://www.googleapis.com/auth/maps-platform.places.getphotomedia" +}, +"https://www.googleapis.com/auth/maps-platform.places.nearbysearch": { +"description": "Private Service: https://www.googleapis.com/auth/maps-platform.places.nearbysearch" +}, +"https://www.googleapis.com/auth/maps-platform.places.textsearch": { +"description": "Private Service: https://www.googleapis.com/auth/maps-platform.places.textsearch" +} +} +} +}, +"basePath": "", +"baseUrl": "https://places.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Maps Places", +"description": "", +"discoveryVersion": "v1", +"documentationLink": "https://mapsplatform.google.com/maps-products/#places-section", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "places:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://places.mtls.googleapis.com/", +"name": "places", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"places": { +"methods": { +"autocomplete": { +"description": "Returns predictions for the given input.", +"flatPath": "v1/places:autocomplete", +"httpMethod": "POST", +"id": "places.places.autocomplete", +"parameterOrder": [], +"parameters": {}, +"path": "v1/places:autocomplete", +"request": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesRequest" +}, +"response": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/maps-platform.places", +"https://www.googleapis.com/auth/maps-platform.places.autocomplete" +] +}, +"get": { +"description": "Get the details of a place based on its resource name, which is a string in the `places/{place_id}` format.", +"flatPath": "v1/places/{placesId}", +"httpMethod": "GET", +"id": "places.places.get", +"parameterOrder": [ +"name" +], +"parameters": { +"languageCode": { +"description": "Optional. Place details will be displayed with the preferred language if available. Current list of supported languages: https://developers.google.com/maps/faq#languagesupport.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The resource name of a place, in the `places/{place_id}` format.", +"location": "path", +"pattern": "^places/[^/]+$", +"required": true, +"type": "string" +}, +"regionCode": { +"description": "Optional. The Unicode country/region code (CLDR) of the location where the request is coming from. This parameter is used to display the place details, like region-specific place name, if available. The parameter can affect results based on applicable law. For more information, see https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html. Note that 3-digit region codes are not currently supported.", +"location": "query", +"type": "string" +}, +"sessionToken": { +"description": "Optional. A string which identifies an Autocomplete session for billing purposes. Must be a URL and filename safe base64 string with at most 36 ASCII characters in length. Otherwise an INVALID_ARGUMENT error is returned. The session begins when the user starts typing a query, and concludes when they select a place and a call to Place Details or Address Validation is made. Each session can have multiple queries, followed by one Place Details or Address Validation request. The credentials used for each request within a session must belong to the same Google Cloud Console project. Once a session has concluded, the token is no longer valid; your app must generate a fresh token for each session. If the `session_token` parameter is omitted, or if you reuse a session token, the session is charged as if no session token was provided (each request is billed separately). We recommend the following guidelines: * Use session tokens for all Place Autocomplete calls. * Generate a fresh token for each session. Using a version 4 UUID is recommended. * Ensure that the credentials used for all Place Autocomplete, Place Details, and Address Validation requests within a session belong to the same Cloud Console project. * Be sure to pass a unique session token for each new session. Using the same token for more than one session will result in each request being billed individually.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleMapsPlacesV1Place" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/maps-platform.places", +"https://www.googleapis.com/auth/maps-platform.places.details" +] +}, +"searchNearby": { +"description": "Search for places near locations.", +"flatPath": "v1/places:searchNearby", +"httpMethod": "POST", +"id": "places.places.searchNearby", +"parameterOrder": [], +"parameters": {}, +"path": "v1/places:searchNearby", +"request": { +"$ref": "GoogleMapsPlacesV1SearchNearbyRequest" +}, +"response": { +"$ref": "GoogleMapsPlacesV1SearchNearbyResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/maps-platform.places", +"https://www.googleapis.com/auth/maps-platform.places.nearbysearch" +] +}, +"searchText": { +"description": "Text query based place search.", +"flatPath": "v1/places:searchText", +"httpMethod": "POST", +"id": "places.places.searchText", +"parameterOrder": [], +"parameters": {}, +"path": "v1/places:searchText", +"request": { +"$ref": "GoogleMapsPlacesV1SearchTextRequest" +}, +"response": { +"$ref": "GoogleMapsPlacesV1SearchTextResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/maps-platform.places", +"https://www.googleapis.com/auth/maps-platform.places.textsearch" +] +} +}, +"resources": { +"photos": { +"methods": { +"getMedia": { +"description": "Get a photo media with a photo reference string.", +"flatPath": "v1/places/{placesId}/photos/{photosId}/media", +"httpMethod": "GET", +"id": "places.places.photos.getMedia", +"parameterOrder": [ +"name" +], +"parameters": { +"maxHeightPx": { +"description": "Optional. Specifies the maximum desired height, in pixels, of the image. If the image is smaller than the values specified, the original image will be returned. If the image is larger in either dimension, it will be scaled to match the smaller of the two dimensions, restricted to its original aspect ratio. Both the max_height_px and max_width_px properties accept an integer between 1 and 4800, inclusively. If the value is not within the allowed range, an INVALID_ARGUMENT error will be returned. At least one of max_height_px or max_width_px needs to be specified. If neither max_height_px nor max_width_px is specified, an INVALID_ARGUMENT error will be returned.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"maxWidthPx": { +"description": "Optional. Specifies the maximum desired width, in pixels, of the image. If the image is smaller than the values specified, the original image will be returned. If the image is larger in either dimension, it will be scaled to match the smaller of the two dimensions, restricted to its original aspect ratio. Both the max_height_px and max_width_px properties accept an integer between 1 and 4800, inclusively. If the value is not within the allowed range, an INVALID_ARGUMENT error will be returned. At least one of max_height_px or max_width_px needs to be specified. If neither max_height_px nor max_width_px is specified, an INVALID_ARGUMENT error will be returned.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"name": { +"description": "Required. The resource name of a photo media in the format: `places/{place_id}/photos/{photo_reference}/media`. The resource name of a photo as returned in a Place object's `photos.name` field comes with the format `places/{place_id}/photos/{photo_reference}`. You need to append `/media` at the end of the photo resource to get the photo media resource name.", +"location": "path", +"pattern": "^places/[^/]+/photos/[^/]+/media$", +"required": true, +"type": "string" +}, +"skipHttpRedirect": { +"description": "Optional. If set, skip the default HTTP redirect behavior and render a text format (for example, in JSON format for HTTP use case) response. If not set, an HTTP redirect will be issued to redirect the call to the image media. This option is ignored for non-HTTP requests.", +"location": "query", +"type": "boolean" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleMapsPlacesV1PhotoMedia" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/maps-platform.places", +"https://www.googleapis.com/auth/maps-platform.places.getphotomedia" +] +} +} +} +} +} +}, +"revision": "20241231", +"rootUrl": "https://places.googleapis.com/", +"schemas": { +"GoogleGeoTypeViewport": { +"description": "A latitude-longitude viewport, represented as two diagonally opposite `low` and `high` points. A viewport is considered a closed region, i.e. it includes its boundary. The latitude bounds must range between -90 to 90 degrees inclusive, and the longitude bounds must range between -180 to 180 degrees inclusive. Various cases include: - If `low` = `high`, the viewport consists of that single point. - If `low.longitude` > `high.longitude`, the longitude range is inverted (the viewport crosses the 180 degree longitude line). - If `low.longitude` = -180 degrees and `high.longitude` = 180 degrees, the viewport includes all longitudes. - If `low.longitude` = 180 degrees and `high.longitude` = -180 degrees, the longitude range is empty. - If `low.latitude` > `high.latitude`, the latitude range is empty. Both `low` and `high` must be populated, and the represented box cannot be empty (as specified by the definitions above). An empty viewport will result in an error. For example, this viewport fully encloses New York City: { \"low\": { \"latitude\": 40.477398, \"longitude\": -74.259087 }, \"high\": { \"latitude\": 40.91618, \"longitude\": -73.70018 } }", +"id": "GoogleGeoTypeViewport", +"properties": { +"high": { +"$ref": "GoogleTypeLatLng", +"description": "Required. The high point of the viewport." +}, +"low": { +"$ref": "GoogleTypeLatLng", +"description": "Required. The low point of the viewport." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AddressDescriptor": { +"description": "A relational description of a location. Includes a ranked set of nearby landmarks and precise containing areas and their relationship to the target location.", +"id": "GoogleMapsPlacesV1AddressDescriptor", +"properties": { +"areas": { +"description": "A ranked list of containing or adjacent areas. The most recognizable and precise areas are ranked first.", +"items": { +"$ref": "GoogleMapsPlacesV1AddressDescriptorArea" +}, +"type": "array" +}, +"landmarks": { +"description": "A ranked list of nearby landmarks. The most recognizable and nearby landmarks are ranked first.", +"items": { +"$ref": "GoogleMapsPlacesV1AddressDescriptorLandmark" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AddressDescriptorArea": { +"description": "Area information and the area's relationship with the target location. Areas includes precise sublocality, neighborhoods, and large compounds that are useful for describing a location.", +"id": "GoogleMapsPlacesV1AddressDescriptorArea", +"properties": { +"containment": { +"description": "Defines the spatial relationship between the target location and the area.", +"enum": [ +"CONTAINMENT_UNSPECIFIED", +"WITHIN", +"OUTSKIRTS", +"NEAR" +], +"enumDescriptions": [ +"The containment is unspecified.", +"The target location is within the area region, close to the center.", +"The target location is within the area region, close to the edge.", +"The target location is outside the area region, but close by." +], +"type": "string" +}, +"displayName": { +"$ref": "GoogleTypeLocalizedText", +"description": "The area's display name." +}, +"name": { +"description": "The area's resource name.", +"type": "string" +}, +"placeId": { +"description": "The area's place id.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AddressDescriptorLandmark": { +"description": "Basic landmark information and the landmark's relationship with the target location. Landmarks are prominent places that can be used to describe a location.", +"id": "GoogleMapsPlacesV1AddressDescriptorLandmark", +"properties": { +"displayName": { +"$ref": "GoogleTypeLocalizedText", +"description": "The landmark's display name." +}, +"name": { +"description": "The landmark's resource name.", +"type": "string" +}, +"placeId": { +"description": "The landmark's place id.", +"type": "string" +}, +"spatialRelationship": { +"description": "Defines the spatial relationship between the target location and the landmark.", +"enum": [ +"NEAR", +"WITHIN", +"BESIDE", +"ACROSS_THE_ROAD", +"DOWN_THE_ROAD", +"AROUND_THE_CORNER", +"BEHIND" +], +"enumDescriptions": [ +"This is the default relationship when nothing more specific below applies.", +"The landmark has a spatial geometry and the target is within its bounds.", +"The target is directly adjacent to the landmark.", +"The target is directly opposite the landmark on the other side of the road.", +"On the same route as the landmark but not besides or across.", +"Not on the same route as the landmark but a single turn away.", +"Close to the landmark's structure but further away from its street entrances." +], +"type": "string" +}, +"straightLineDistanceMeters": { +"description": "The straight line distance, in meters, between the center point of the target and the center point of the landmark. In some situations, this value can be longer than `travel_distance_meters`.", +"format": "float", +"type": "number" +}, +"travelDistanceMeters": { +"description": "The travel distance, in meters, along the road network from the target to the landmark, if known. This value does not take into account the mode of transportation, such as walking, driving, or biking.", +"format": "float", +"type": "number" +}, +"types": { +"description": "A set of type tags for this landmark. For a complete list of possible values, see https://developers.google.com/maps/documentation/places/web-service/place-types.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AuthorAttribution": { +"description": "Information about the author of the UGC data. Used in Photo, and Review.", +"id": "GoogleMapsPlacesV1AuthorAttribution", +"properties": { +"displayName": { +"description": "Name of the author of the Photo or Review.", +"type": "string" +}, +"photoUri": { +"description": "Profile photo URI of the author of the Photo or Review.", +"type": "string" +}, +"uri": { +"description": "URI of the author of the Photo or Review.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesRequest": { +"description": "Request proto for AutocompletePlaces.", +"id": "GoogleMapsPlacesV1AutocompletePlacesRequest", +"properties": { +"includePureServiceAreaBusinesses": { +"description": "Optional. Include pure service area businesses if the field is set to true. Pure service area business is a business that visits or delivers to customers directly but does not serve customers at their business address. For example, businesses like cleaning services or plumbers. Those businesses do not have a physical address or location on Google Maps. Places will not return fields including `location`, `plus_code`, and other location related fields for these businesses.", +"type": "boolean" +}, +"includeQueryPredictions": { +"description": "Optional. If true, the response will include both Place and query predictions. Otherwise the response will only return Place predictions.", +"type": "boolean" +}, +"includedPrimaryTypes": { +"description": "Optional. Included primary Place type (for example, \"restaurant\" or \"gas_station\") in Place Types (https://developers.google.com/maps/documentation/places/web-service/place-types), or only `(regions)`, or only `(cities)`. A Place is only returned if its primary type is included in this list. Up to 5 values can be specified. If no types are specified, all Place types are returned.", +"items": { +"type": "string" +}, +"type": "array" +}, +"includedRegionCodes": { +"description": "Optional. Only include results in the specified regions, specified as up to 15 CLDR two-character region codes. An empty set will not restrict the results. If both `location_restriction` and `included_region_codes` are set, the results will be located in the area of intersection.", +"items": { +"type": "string" +}, +"type": "array" +}, +"input": { +"description": "Required. The text string on which to search.", +"type": "string" +}, +"inputOffset": { +"description": "Optional. A zero-based Unicode character offset of `input` indicating the cursor position in `input`. The cursor position may influence what predictions are returned. If empty, defaults to the length of `input`.", +"format": "int32", +"type": "integer" +}, +"languageCode": { +"description": "Optional. The language in which to return results. Defaults to en-US. The results may be in mixed languages if the language used in `input` is different from `language_code` or if the returned Place does not have a translation from the local language to `language_code`.", +"type": "string" +}, +"locationBias": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesRequestLocationBias", +"description": "Optional. Bias results to a specified location. At most one of `location_bias` or `location_restriction` should be set. If neither are set, the results will be biased by IP address, meaning the IP address will be mapped to an imprecise location and used as a biasing signal." +}, +"locationRestriction": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesRequestLocationRestriction", +"description": "Optional. Restrict results to a specified location. At most one of `location_bias` or `location_restriction` should be set. If neither are set, the results will be biased by IP address, meaning the IP address will be mapped to an imprecise location and used as a biasing signal." +}, +"origin": { +"$ref": "GoogleTypeLatLng", +"description": "Optional. The origin point from which to calculate geodesic distance to the destination (returned as `distance_meters`). If this value is omitted, geodesic distance will not be returned." +}, +"regionCode": { +"description": "Optional. The region code, specified as a CLDR two-character region code. This affects address formatting, result ranking, and may influence what results are returned. This does not restrict results to the specified region. To restrict results to a region, use `region_code_restriction`.", +"type": "string" +}, +"sessionToken": { +"description": "Optional. A string which identifies an Autocomplete session for billing purposes. Must be a URL and filename safe base64 string with at most 36 ASCII characters in length. Otherwise an INVALID_ARGUMENT error is returned. The session begins when the user starts typing a query, and concludes when they select a place and a call to Place Details or Address Validation is made. Each session can have multiple queries, followed by one Place Details or Address Validation request. The credentials used for each request within a session must belong to the same Google Cloud Console project. Once a session has concluded, the token is no longer valid; your app must generate a fresh token for each session. If the `session_token` parameter is omitted, or if you reuse a session token, the session is charged as if no session token was provided (each request is billed separately). We recommend the following guidelines: * Use session tokens for all Place Autocomplete calls. * Generate a fresh token for each session. Using a version 4 UUID is recommended. * Ensure that the credentials used for all Place Autocomplete, Place Details, and Address Validation requests within a session belong to the same Cloud Console project. * Be sure to pass a unique session token for each new session. Using the same token for more than one session will result in each request being billed individually.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesRequestLocationBias": { +"description": "The region to search. The results may be biased around the specified region.", +"id": "GoogleMapsPlacesV1AutocompletePlacesRequestLocationBias", +"properties": { +"circle": { +"$ref": "GoogleMapsPlacesV1Circle", +"description": "A circle defined by a center point and radius." +}, +"rectangle": { +"$ref": "GoogleGeoTypeViewport", +"description": "A viewport defined by a northeast and a southwest corner." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesRequestLocationRestriction": { +"description": "The region to search. The results will be restricted to the specified region.", +"id": "GoogleMapsPlacesV1AutocompletePlacesRequestLocationRestriction", +"properties": { +"circle": { +"$ref": "GoogleMapsPlacesV1Circle", +"description": "A circle defined by a center point and radius." +}, +"rectangle": { +"$ref": "GoogleGeoTypeViewport", +"description": "A viewport defined by a northeast and a southwest corner." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesResponse": { +"description": "Response proto for AutocompletePlaces.", +"id": "GoogleMapsPlacesV1AutocompletePlacesResponse", +"properties": { +"suggestions": { +"description": "Contains a list of suggestions, ordered in descending order of relevance.", +"items": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestion" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesResponseSuggestion": { +"description": "An Autocomplete suggestion result.", +"id": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestion", +"properties": { +"placePrediction": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionPlacePrediction", +"description": "A prediction for a Place." +}, +"queryPrediction": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionQueryPrediction", +"description": "A prediction for a query." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText": { +"description": "Text representing a Place or query prediction. The text may be used as is or formatted.", +"id": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText", +"properties": { +"matches": { +"description": "A list of string ranges identifying where the input request matched in `text`. The ranges can be used to format specific parts of `text`. The substrings may not be exact matches of `input` if the matching was determined by criteria other than string matching (for example, spell corrections or transliterations). These values are Unicode character offsets of `text`. The ranges are guaranteed to be ordered in increasing offset values.", +"items": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStringRange" +}, +"type": "array" +}, +"text": { +"description": "Text that may be used as is or formatted with `matches`.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionPlacePrediction": { +"description": "Prediction results for a Place Autocomplete prediction.", +"id": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionPlacePrediction", +"properties": { +"distanceMeters": { +"description": "The length of the geodesic in meters from `origin` if `origin` is specified. Certain predictions such as routes may not populate this field.", +"format": "int32", +"type": "integer" +}, +"place": { +"description": "The resource name of the suggested Place. This name can be used in other APIs that accept Place names.", +"type": "string" +}, +"placeId": { +"description": "The unique identifier of the suggested Place. This identifier can be used in other APIs that accept Place IDs.", +"type": "string" +}, +"structuredFormat": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStructuredFormat", +"description": "A breakdown of the Place prediction into main text containing the name of the Place and secondary text containing additional disambiguating features (such as a city or region). `structured_format` is recommended for developers who wish to show two separate, but related, UI elements. Developers who wish to show a single UI element may want to use `text` instead. They are two different ways to represent a Place prediction. Users should not try to parse `structured_format` into `text` or vice versa." +}, +"text": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText", +"description": "Contains the human-readable name for the returned result. For establishment results, this is usually the business name and address. `text` is recommended for developers who wish to show a single UI element. Developers who wish to show two separate, but related, UI elements may want to use `structured_format` instead. They are two different ways to represent a Place prediction. Users should not try to parse `structured_format` into `text` or vice versa. This text may be different from the `display_name` returned by GetPlace. May be in mixed languages if the request `input` and `language_code` are in different languages or if the Place does not have a translation from the local language to `language_code`." +}, +"types": { +"description": "List of types that apply to this Place from Table A or Table B in https://developers.google.com/maps/documentation/places/web-service/place-types. A type is a categorization of a Place. Places with shared types will share similar characteristics.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionQueryPrediction": { +"description": "Prediction results for a Query Autocomplete prediction.", +"id": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionQueryPrediction", +"properties": { +"structuredFormat": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStructuredFormat", +"description": "A breakdown of the query prediction into main text containing the query and secondary text containing additional disambiguating features (such as a city or region). `structured_format` is recommended for developers who wish to show two separate, but related, UI elements. Developers who wish to show a single UI element may want to use `text` instead. They are two different ways to represent a query prediction. Users should not try to parse `structured_format` into `text` or vice versa." +}, +"text": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText", +"description": "The predicted text. This text does not represent a Place, but rather a text query that could be used in a search endpoint (for example, Text Search). `text` is recommended for developers who wish to show a single UI element. Developers who wish to show two separate, but related, UI elements may want to use `structured_format` instead. They are two different ways to represent a query prediction. Users should not try to parse `structured_format` into `text` or vice versa. May be in mixed languages if the request `input` and `language_code` are in different languages or if part of the query does not have a translation from the local language to `language_code`." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStringRange": { +"description": "Identifies a substring within a given text.", +"id": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStringRange", +"properties": { +"endOffset": { +"description": "Zero-based offset of the last Unicode character (exclusive).", +"format": "int32", +"type": "integer" +}, +"startOffset": { +"description": "Zero-based offset of the first Unicode character of the string (inclusive).", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStructuredFormat": { +"description": "Contains a breakdown of a Place or query prediction into main text and secondary text. For Place predictions, the main text contains the specific name of the Place. For query predictions, the main text contains the query. The secondary text contains additional disambiguating features (such as a city or region) to further identify the Place or refine the query.", +"id": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStructuredFormat", +"properties": { +"mainText": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText", +"description": "Represents the name of the Place or query." +}, +"secondaryText": { +"$ref": "GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText", +"description": "Represents additional disambiguating features (such as a city or region) to further identify the Place or refine the query." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1Circle": { +"description": "Circle with a LatLng as center and radius.", +"id": "GoogleMapsPlacesV1Circle", +"properties": { +"center": { +"$ref": "GoogleTypeLatLng", +"description": "Required. Center latitude and longitude. The range of latitude must be within [-90.0, 90.0]. The range of the longitude must be within [-180.0, 180.0]." +}, +"radius": { +"description": "Required. Radius measured in meters. The radius must be within [0.0, 50000.0].", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1ContentBlock": { +"description": "A block of content that can be served individually.", +"id": "GoogleMapsPlacesV1ContentBlock", +"properties": { +"content": { +"$ref": "GoogleTypeLocalizedText", +"description": "Content related to the topic." +}, +"references": { +"$ref": "GoogleMapsPlacesV1References", +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. References that are related to this block of content." +}, +"topic": { +"description": "The topic of the content, for example \"overview\" or \"restaurant\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1ContextualContent": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. Content that is contextual to the place query.", +"id": "GoogleMapsPlacesV1ContextualContent", +"properties": { +"justifications": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. Justifications for the place.", +"items": { +"$ref": "GoogleMapsPlacesV1ContextualContentJustification" +}, +"type": "array" +}, +"photos": { +"description": "Information (including references) about photos of this place, contexual to the place query.", +"items": { +"$ref": "GoogleMapsPlacesV1Photo" +}, +"type": "array" +}, +"reviews": { +"description": "List of reviews about this place, contexual to the place query.", +"items": { +"$ref": "GoogleMapsPlacesV1Review" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1ContextualContentJustification": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. Justifications for the place. Justifications answers the question of why a place could interest an end user.", +"id": "GoogleMapsPlacesV1ContextualContentJustification", +"properties": { +"businessAvailabilityAttributesJustification": { +"$ref": "GoogleMapsPlacesV1ContextualContentJustificationBusinessAvailabilityAttributesJustification", +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details." +}, +"reviewJustification": { +"$ref": "GoogleMapsPlacesV1ContextualContentJustificationReviewJustification", +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1ContextualContentJustificationBusinessAvailabilityAttributesJustification": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. BusinessAvailabilityAttributes justifications. This shows some attributes a business has that could interest an end user.", +"id": "GoogleMapsPlacesV1ContextualContentJustificationBusinessAvailabilityAttributesJustification", +"properties": { +"delivery": { +"description": "If a place provides delivery.", +"type": "boolean" +}, +"dineIn": { +"description": "If a place provides dine-in.", +"type": "boolean" +}, +"takeout": { +"description": "If a place provides takeout.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1ContextualContentJustificationReviewJustification": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. User review justifications. This highlights a section of the user review that would interest an end user. For instance, if the search query is \"firewood pizza\", the review justification highlights the text relevant to the search query.", +"id": "GoogleMapsPlacesV1ContextualContentJustificationReviewJustification", +"properties": { +"highlightedText": { +"$ref": "GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedText" +}, +"review": { +"$ref": "GoogleMapsPlacesV1Review", +"description": "The review that the highlighted text is generated from." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedText": { +"description": "The text highlighted by the justification. This is a subset of the review itself. The exact word to highlight is marked by the HighlightedTextRange. There could be several words in the text being highlighted.", +"id": "GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedText", +"properties": { +"highlightedTextRanges": { +"description": "The list of the ranges of the highlighted text.", +"items": { +"$ref": "GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedTextHighlightedTextRange" +}, +"type": "array" +}, +"text": { +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedTextHighlightedTextRange": { +"description": "The range of highlighted text.", +"id": "GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedTextHighlightedTextRange", +"properties": { +"endIndex": { +"format": "int32", +"type": "integer" +}, +"startIndex": { +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1EVChargeOptions": { +"description": "Information about the EV Charge Station hosted in Place. Terminology follows https://afdc.energy.gov/fuels/electricity_infrastructure.html One port could charge one car at a time. One port has one or more connectors. One station has one or more ports.", +"id": "GoogleMapsPlacesV1EVChargeOptions", +"properties": { +"connectorAggregation": { +"description": "A list of EV charging connector aggregations that contain connectors of the same type and same charge rate.", +"items": { +"$ref": "GoogleMapsPlacesV1EVChargeOptionsConnectorAggregation" +}, +"type": "array" +}, +"connectorCount": { +"description": "Number of connectors at this station. However, because some ports can have multiple connectors but only be able to charge one car at a time (e.g.) the number of connectors may be greater than the total number of cars which can charge simultaneously.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1EVChargeOptionsConnectorAggregation": { +"description": "EV charging information grouped by [type, max_charge_rate_kw]. Shows EV charge aggregation of connectors that have the same type and max charge rate in kw.", +"id": "GoogleMapsPlacesV1EVChargeOptionsConnectorAggregation", +"properties": { +"availabilityLastUpdateTime": { +"description": "The timestamp when the connector availability information in this aggregation was last updated.", +"format": "google-datetime", +"type": "string" +}, +"availableCount": { +"description": "Number of connectors in this aggregation that are currently available.", +"format": "int32", +"type": "integer" +}, +"count": { +"description": "Number of connectors in this aggregation.", +"format": "int32", +"type": "integer" +}, +"maxChargeRateKw": { +"description": "The static max charging rate in kw of each connector in the aggregation.", +"format": "double", +"type": "number" +}, +"outOfServiceCount": { +"description": "Number of connectors in this aggregation that are currently out of service.", +"format": "int32", +"type": "integer" +}, +"type": { +"description": "The connector type of this aggregation.", +"enum": [ +"EV_CONNECTOR_TYPE_UNSPECIFIED", +"EV_CONNECTOR_TYPE_OTHER", +"EV_CONNECTOR_TYPE_J1772", +"EV_CONNECTOR_TYPE_TYPE_2", +"EV_CONNECTOR_TYPE_CHADEMO", +"EV_CONNECTOR_TYPE_CCS_COMBO_1", +"EV_CONNECTOR_TYPE_CCS_COMBO_2", +"EV_CONNECTOR_TYPE_TESLA", +"EV_CONNECTOR_TYPE_UNSPECIFIED_GB_T", +"EV_CONNECTOR_TYPE_UNSPECIFIED_WALL_OUTLET" +], +"enumDescriptions": [ +"Unspecified connector.", +"Other connector types.", +"J1772 type 1 connector.", +"IEC 62196 type 2 connector. Often referred to as MENNEKES.", +"CHAdeMO type connector.", +"Combined Charging System (AC and DC). Based on SAE. Type-1 J-1772 connector", +"Combined Charging System (AC and DC). Based on Type-2 Mennekes connector", +"The generic TESLA connector. This is NACS in the North America but can be non-NACS in other parts of the world (e.g. CCS Combo 2 (CCS2) or GB/T). This value is less representative of an actual connector type, and more represents the ability to charge a Tesla brand vehicle at a Tesla owned charging station.", +"GB/T type corresponds to the GB/T standard in China. This type covers all GB_T types.", +"Unspecified wall outlet." +], +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1FuelOptions": { +"description": "The most recent information about fuel options in a gas station. This information is updated regularly.", +"id": "GoogleMapsPlacesV1FuelOptions", +"properties": { +"fuelPrices": { +"description": "The last known fuel price for each type of fuel this station has. There is one entry per fuel type this station has. Order is not important.", +"items": { +"$ref": "GoogleMapsPlacesV1FuelOptionsFuelPrice" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1FuelOptionsFuelPrice": { +"description": "Fuel price information for a given type.", +"id": "GoogleMapsPlacesV1FuelOptionsFuelPrice", +"properties": { +"price": { +"$ref": "GoogleTypeMoney", +"description": "The price of the fuel." +}, +"type": { +"description": "The type of fuel.", +"enum": [ +"FUEL_TYPE_UNSPECIFIED", +"DIESEL", +"REGULAR_UNLEADED", +"MIDGRADE", +"PREMIUM", +"SP91", +"SP91_E10", +"SP92", +"SP95", +"SP95_E10", +"SP98", +"SP99", +"SP100", +"LPG", +"E80", +"E85", +"METHANE", +"BIO_DIESEL", +"TRUCK_DIESEL" +], +"enumDescriptions": [ +"Unspecified fuel type.", +"Diesel fuel.", +"Regular unleaded.", +"Midgrade.", +"Premium.", +"SP 91.", +"SP 91 E10.", +"SP 92.", +"SP 95.", +"SP95 E10.", +"SP 98.", +"SP 99.", +"SP 100.", +"LPG.", +"E 80.", +"E 85.", +"Methane.", +"Bio-diesel.", +"Truck diesel." +], +"type": "string" +}, +"updateTime": { +"description": "The time the fuel price was last updated.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1Photo": { +"description": "Information about a photo of a place.", +"id": "GoogleMapsPlacesV1Photo", +"properties": { +"authorAttributions": { +"description": "This photo's authors.", +"items": { +"$ref": "GoogleMapsPlacesV1AuthorAttribution" +}, +"type": "array" +}, +"flagContentUri": { +"description": "A link where users can flag a problem with the photo.", +"type": "string" +}, +"googleMapsUri": { +"description": "A link to show the photo on Google Maps.", +"type": "string" +}, +"heightPx": { +"description": "The maximum available height, in pixels.", +"format": "int32", +"type": "integer" +}, +"name": { +"description": "Identifier. A reference representing this place photo which may be used to look up this place photo again (also called the API \"resource\" name: `places/{place_id}/photos/{photo}`).", +"type": "string" +}, +"widthPx": { +"description": "The maximum available width, in pixels.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PhotoMedia": { +"description": "A photo media from Places API.", +"id": "GoogleMapsPlacesV1PhotoMedia", +"properties": { +"name": { +"description": "The resource name of a photo media in the format: `places/{place_id}/photos/{photo_reference}/media`.", +"type": "string" +}, +"photoUri": { +"description": "A short-lived uri that can be used to render the photo.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1Place": { +"description": "All the information representing a Place.", +"id": "GoogleMapsPlacesV1Place", +"properties": { +"accessibilityOptions": { +"$ref": "GoogleMapsPlacesV1PlaceAccessibilityOptions", +"description": "Information about the accessibility options a place offers." +}, +"addressComponents": { +"description": "Repeated components for each locality level. Note the following facts about the address_components[] array: - The array of address components may contain more components than the formatted_address. - The array does not necessarily include all the political entities that contain an address, apart from those included in the formatted_address. To retrieve all the political entities that contain a specific address, you should use reverse geocoding, passing the latitude/longitude of the address as a parameter to the request. - The format of the response is not guaranteed to remain the same between requests. In particular, the number of address_components varies based on the address requested and can change over time for the same address. A component can change position in the array. The type of the component can change. A particular component may be missing in a later response.", +"items": { +"$ref": "GoogleMapsPlacesV1PlaceAddressComponent" +}, +"type": "array" +}, +"addressDescriptor": { +"$ref": "GoogleMapsPlacesV1AddressDescriptor", +"description": "The address descriptor of the place. Address descriptors include additional information that help describe a location using landmarks and areas. See address descriptor regional coverage in https://developers.google.com/maps/documentation/geocoding/address-descriptors/coverage." +}, +"adrFormatAddress": { +"description": "The place's address in adr microformat: http://microformats.org/wiki/adr.", +"type": "string" +}, +"allowsDogs": { +"description": "Place allows dogs.", +"type": "boolean" +}, +"areaSummary": { +"$ref": "GoogleMapsPlacesV1PlaceAreaSummary", +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. AI-generated summary of the area that the place is in." +}, +"attributions": { +"description": "A set of data provider that must be shown with this result.", +"items": { +"$ref": "GoogleMapsPlacesV1PlaceAttribution" +}, +"type": "array" +}, +"businessStatus": { +"description": "The business status for the place.", +"enum": [ +"BUSINESS_STATUS_UNSPECIFIED", +"OPERATIONAL", +"CLOSED_TEMPORARILY", +"CLOSED_PERMANENTLY" +], +"enumDescriptions": [ +"Default value. This value is unused.", +"The establishment is operational, not necessarily open now.", +"The establishment is temporarily closed.", +"The establishment is permanently closed." +], +"type": "string" +}, +"containingPlaces": { +"description": "List of places in which the current place is located.", +"items": { +"$ref": "GoogleMapsPlacesV1PlaceContainingPlace" +}, +"type": "array" +}, +"curbsidePickup": { +"description": "Specifies if the business supports curbside pickup.", +"type": "boolean" +}, +"currentOpeningHours": { +"$ref": "GoogleMapsPlacesV1PlaceOpeningHours", +"description": "The hours of operation for the next seven days (including today). The time period starts at midnight on the date of the request and ends at 11:59 pm six days later. This field includes the special_days subfield of all hours, set for dates that have exceptional hours." +}, +"currentSecondaryOpeningHours": { +"description": "Contains an array of entries for the next seven days including information about secondary hours of a business. Secondary hours are different from a business's main hours. For example, a restaurant can specify drive through hours or delivery hours as its secondary hours. This field populates the type subfield, which draws from a predefined list of opening hours types (such as DRIVE_THROUGH, PICKUP, or TAKEOUT) based on the types of the place. This field includes the special_days subfield of all hours, set for dates that have exceptional hours.", +"items": { +"$ref": "GoogleMapsPlacesV1PlaceOpeningHours" +}, +"type": "array" +}, +"delivery": { +"description": "Specifies if the business supports delivery.", +"type": "boolean" +}, +"dineIn": { +"description": "Specifies if the business supports indoor or outdoor seating options.", +"type": "boolean" +}, +"displayName": { +"$ref": "GoogleTypeLocalizedText", +"description": "The localized name of the place, suitable as a short human-readable description. For example, \"Google Sydney\", \"Starbucks\", \"Pyrmont\", etc." +}, +"editorialSummary": { +"$ref": "GoogleTypeLocalizedText", +"description": "Contains a summary of the place. A summary is comprised of a textual overview, and also includes the language code for these if applicable. Summary text must be presented as-is and can not be modified or altered." +}, +"evChargeOptions": { +"$ref": "GoogleMapsPlacesV1EVChargeOptions", +"description": "Information of ev charging options." +}, +"formattedAddress": { +"description": "A full, human-readable address for this place.", +"type": "string" +}, +"fuelOptions": { +"$ref": "GoogleMapsPlacesV1FuelOptions", +"description": "The most recent information about fuel options in a gas station. This information is updated regularly." +}, +"generativeSummary": { +"$ref": "GoogleMapsPlacesV1PlaceGenerativeSummary", +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. AI-generated summary of the place." +}, +"goodForChildren": { +"description": "Place is good for children.", +"type": "boolean" +}, +"goodForGroups": { +"description": "Place accommodates groups.", +"type": "boolean" +}, +"goodForWatchingSports": { +"description": "Place is suitable for watching sports.", +"type": "boolean" +}, +"googleMapsLinks": { +"$ref": "GoogleMapsPlacesV1PlaceGoogleMapsLinks", +"description": "Links to trigger different Google Maps actions." +}, +"googleMapsUri": { +"description": "A URL providing more information about this place.", +"type": "string" +}, +"iconBackgroundColor": { +"description": "Background color for icon_mask in hex format, e.g. #909CE1.", +"type": "string" +}, +"iconMaskBaseUri": { +"description": "A truncated URL to an icon mask. User can access different icon type by appending type suffix to the end (eg, \".svg\" or \".png\").", +"type": "string" +}, +"id": { +"description": "The unique identifier of a place.", +"type": "string" +}, +"internationalPhoneNumber": { +"description": "A human-readable phone number for the place, in international format.", +"type": "string" +}, +"liveMusic": { +"description": "Place provides live music.", +"type": "boolean" +}, +"location": { +"$ref": "GoogleTypeLatLng", +"description": "The position of this place." +}, +"menuForChildren": { +"description": "Place has a children's menu.", +"type": "boolean" +}, +"name": { +"description": "This Place's resource name, in `places/{place_id}` format. Can be used to look up the Place.", +"type": "string" +}, +"nationalPhoneNumber": { +"description": "A human-readable phone number for the place, in national format.", +"type": "string" +}, +"outdoorSeating": { +"description": "Place provides outdoor seating.", +"type": "boolean" +}, +"parkingOptions": { +"$ref": "GoogleMapsPlacesV1PlaceParkingOptions", +"description": "Options of parking provided by the place." +}, +"paymentOptions": { +"$ref": "GoogleMapsPlacesV1PlacePaymentOptions", +"description": "Payment options the place accepts. If a payment option data is not available, the payment option field will be unset." +}, +"photos": { +"description": "Information (including references) about photos of this place. A maximum of 10 photos can be returned.", +"items": { +"$ref": "GoogleMapsPlacesV1Photo" +}, +"type": "array" +}, +"plusCode": { +"$ref": "GoogleMapsPlacesV1PlacePlusCode", +"description": "Plus code of the place location lat/long." +}, +"priceLevel": { +"description": "Price level of the place.", +"enum": [ +"PRICE_LEVEL_UNSPECIFIED", +"PRICE_LEVEL_FREE", +"PRICE_LEVEL_INEXPENSIVE", +"PRICE_LEVEL_MODERATE", +"PRICE_LEVEL_EXPENSIVE", +"PRICE_LEVEL_VERY_EXPENSIVE" +], +"enumDescriptions": [ +"Place price level is unspecified or unknown.", +"Place provides free services.", +"Place provides inexpensive services.", +"Place provides moderately priced services.", +"Place provides expensive services.", +"Place provides very expensive services." +], +"type": "string" +}, +"priceRange": { +"$ref": "GoogleMapsPlacesV1PriceRange", +"description": "The price range associated with a Place." +}, +"primaryType": { +"description": "The primary type of the given result. This type must one of the Places API supported types. For example, \"restaurant\", \"cafe\", \"airport\", etc. A place can only have a single primary type. For the complete list of possible values, see Table A and Table B at https://developers.google.com/maps/documentation/places/web-service/place-types", +"type": "string" +}, +"primaryTypeDisplayName": { +"$ref": "GoogleTypeLocalizedText", +"description": "The display name of the primary type, localized to the request language if applicable. For the complete list of possible values, see Table A and Table B at https://developers.google.com/maps/documentation/places/web-service/place-types" +}, +"pureServiceAreaBusiness": { +"description": "Indicates whether the place is a pure service area business. Pure service area business is a business that visits or delivers to customers directly but does not serve customers at their business address. For example, businesses like cleaning services or plumbers. Those businesses may not have a physical address or location on Google Maps.", +"type": "boolean" +}, +"rating": { +"description": "A rating between 1.0 and 5.0, based on user reviews of this place.", +"format": "double", +"type": "number" +}, +"regularOpeningHours": { +"$ref": "GoogleMapsPlacesV1PlaceOpeningHours", +"description": "The regular hours of operation. Note that if a place is always open (24 hours), the `close` field will not be set. Clients can rely on always open (24 hours) being represented as an `open` period containing `day` with value `0`, `hour` with value `0`, and `minute` with value `0`." +}, +"regularSecondaryOpeningHours": { +"description": "Contains an array of entries for information about regular secondary hours of a business. Secondary hours are different from a business's main hours. For example, a restaurant can specify drive through hours or delivery hours as its secondary hours. This field populates the type subfield, which draws from a predefined list of opening hours types (such as DRIVE_THROUGH, PICKUP, or TAKEOUT) based on the types of the place.", +"items": { +"$ref": "GoogleMapsPlacesV1PlaceOpeningHours" +}, +"type": "array" +}, +"reservable": { +"description": "Specifies if the place supports reservations.", +"type": "boolean" +}, +"restroom": { +"description": "Place has restroom.", +"type": "boolean" +}, +"reviews": { +"description": "List of reviews about this place, sorted by relevance. A maximum of 5 reviews can be returned.", +"items": { +"$ref": "GoogleMapsPlacesV1Review" +}, +"type": "array" +}, +"servesBeer": { +"description": "Specifies if the place serves beer.", +"type": "boolean" +}, +"servesBreakfast": { +"description": "Specifies if the place serves breakfast.", +"type": "boolean" +}, +"servesBrunch": { +"description": "Specifies if the place serves brunch.", +"type": "boolean" +}, +"servesCocktails": { +"description": "Place serves cocktails.", +"type": "boolean" +}, +"servesCoffee": { +"description": "Place serves coffee.", +"type": "boolean" +}, +"servesDessert": { +"description": "Place serves dessert.", +"type": "boolean" +}, +"servesDinner": { +"description": "Specifies if the place serves dinner.", +"type": "boolean" +}, +"servesLunch": { +"description": "Specifies if the place serves lunch.", +"type": "boolean" +}, +"servesVegetarianFood": { +"description": "Specifies if the place serves vegetarian food.", +"type": "boolean" +}, +"servesWine": { +"description": "Specifies if the place serves wine.", +"type": "boolean" +}, +"shortFormattedAddress": { +"description": "A short, human-readable address for this place.", +"type": "string" +}, +"subDestinations": { +"description": "A list of sub destinations related to the place.", +"items": { +"$ref": "GoogleMapsPlacesV1PlaceSubDestination" +}, +"type": "array" +}, +"takeout": { +"description": "Specifies if the business supports takeout.", +"type": "boolean" +}, +"types": { +"description": "A set of type tags for this result. For example, \"political\" and \"locality\". For the complete list of possible values, see Table A and Table B at https://developers.google.com/maps/documentation/places/web-service/place-types", +"items": { +"type": "string" +}, +"type": "array" +}, +"userRatingCount": { +"description": "The total number of reviews (with or without text) for this place.", +"format": "int32", +"type": "integer" +}, +"utcOffsetMinutes": { +"description": "Number of minutes this place's timezone is currently offset from UTC. This is expressed in minutes to support timezones that are offset by fractions of an hour, e.g. X hours and 15 minutes.", +"format": "int32", +"type": "integer" +}, +"viewport": { +"$ref": "GoogleGeoTypeViewport", +"description": "A viewport suitable for displaying the place on an average-sized map. This viewport should not be used as the physical boundary or the service area of the business." +}, +"websiteUri": { +"description": "The authoritative website for this place, e.g. a business' homepage. Note that for places that are part of a chain (e.g. an IKEA store), this will usually be the website for the individual store, not the overall chain.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceAccessibilityOptions": { +"description": "Information about the accessibility options a place offers.", +"id": "GoogleMapsPlacesV1PlaceAccessibilityOptions", +"properties": { +"wheelchairAccessibleEntrance": { +"description": "Places has wheelchair accessible entrance.", +"type": "boolean" +}, +"wheelchairAccessibleParking": { +"description": "Place offers wheelchair accessible parking.", +"type": "boolean" +}, +"wheelchairAccessibleRestroom": { +"description": "Place has wheelchair accessible restroom.", +"type": "boolean" +}, +"wheelchairAccessibleSeating": { +"description": "Place has wheelchair accessible seating.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceAddressComponent": { +"description": "The structured components that form the formatted address, if this information is available.", +"id": "GoogleMapsPlacesV1PlaceAddressComponent", +"properties": { +"languageCode": { +"description": "The language used to format this components, in CLDR notation.", +"type": "string" +}, +"longText": { +"description": "The full text description or name of the address component. For example, an address component for the country Australia may have a long_name of \"Australia\".", +"type": "string" +}, +"shortText": { +"description": "An abbreviated textual name for the address component, if available. For example, an address component for the country of Australia may have a short_name of \"AU\".", +"type": "string" +}, +"types": { +"description": "An array indicating the type(s) of the address component.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceAreaSummary": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. AI-generated summary of the area that the place is in.", +"id": "GoogleMapsPlacesV1PlaceAreaSummary", +"properties": { +"contentBlocks": { +"description": "Content blocks that compose the area summary. Each block has a separate topic about the area.", +"items": { +"$ref": "GoogleMapsPlacesV1ContentBlock" +}, +"type": "array" +}, +"flagContentUri": { +"description": "A link where users can flag a problem with the summary.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceAttribution": { +"description": "Information about data providers of this place.", +"id": "GoogleMapsPlacesV1PlaceAttribution", +"properties": { +"provider": { +"description": "Name of the Place's data provider.", +"type": "string" +}, +"providerUri": { +"description": "URI to the Place's data provider.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceContainingPlace": { +"description": "Info about the place in which this place is located.", +"id": "GoogleMapsPlacesV1PlaceContainingPlace", +"properties": { +"id": { +"description": "The place id of the place in which this place is located.", +"type": "string" +}, +"name": { +"description": "The resource name of the place in which this place is located.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceGenerativeSummary": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. AI-generated summary of the place.", +"id": "GoogleMapsPlacesV1PlaceGenerativeSummary", +"properties": { +"description": { +"$ref": "GoogleTypeLocalizedText", +"description": "The detailed description of the place." +}, +"descriptionFlagContentUri": { +"description": "A link where users can flag a problem with the description summary.", +"type": "string" +}, +"overview": { +"$ref": "GoogleTypeLocalizedText", +"description": "The overview of the place." +}, +"overviewFlagContentUri": { +"description": "A link where users can flag a problem with the overview summary.", +"type": "string" +}, +"references": { +"$ref": "GoogleMapsPlacesV1References", +"description": "References that are used to generate the summary description." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceGoogleMapsLinks": { +"description": "Links to trigger different Google Maps actions.", +"id": "GoogleMapsPlacesV1PlaceGoogleMapsLinks", +"properties": { +"directionsUri": { +"description": "A link to show the directions to the place. The link only populates the destination location and uses the default travel mode `DRIVE`.", +"type": "string" +}, +"photosUri": { +"description": "A link to show photos of this place. This link is currently not supported on Google Maps Mobile and only works on the web version of Google Maps.", +"type": "string" +}, +"placeUri": { +"description": "A link to show this place.", +"type": "string" +}, +"reviewsUri": { +"description": "A link to show reviews of this place. This link is currently not supported on Google Maps Mobile and only works on the web version of Google Maps.", +"type": "string" +}, +"writeAReviewUri": { +"description": "A link to write a review for this place. This link is currently not supported on Google Maps Mobile and only works on the web version of Google Maps.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceOpeningHours": { +"description": "Information about business hour of the place.", +"id": "GoogleMapsPlacesV1PlaceOpeningHours", +"properties": { +"nextCloseTime": { +"description": "The next time the current opening hours period ends up to 7 days in the future. This field is only populated if the opening hours period is active at the time of serving the request.", +"format": "google-datetime", +"type": "string" +}, +"nextOpenTime": { +"description": "The next time the current opening hours period starts up to 7 days in the future. This field is only populated if the opening hours period is not active at the time of serving the request.", +"format": "google-datetime", +"type": "string" +}, +"openNow": { +"description": "Whether the opening hours period is currently active. For regular opening hours and current opening hours, this field means whether the place is open. For secondary opening hours and current secondary opening hours, this field means whether the secondary hours of this place is active.", +"type": "boolean" +}, +"periods": { +"description": "The periods that this place is open during the week. The periods are in chronological order, starting with Sunday in the place-local timezone. An empty (but not absent) value indicates a place that is never open, e.g. because it is closed temporarily for renovations.", +"items": { +"$ref": "GoogleMapsPlacesV1PlaceOpeningHoursPeriod" +}, +"type": "array" +}, +"secondaryHoursType": { +"description": "A type string used to identify the type of secondary hours.", +"enum": [ +"SECONDARY_HOURS_TYPE_UNSPECIFIED", +"DRIVE_THROUGH", +"HAPPY_HOUR", +"DELIVERY", +"TAKEOUT", +"KITCHEN", +"BREAKFAST", +"LUNCH", +"DINNER", +"BRUNCH", +"PICKUP", +"ACCESS", +"SENIOR_HOURS", +"ONLINE_SERVICE_HOURS" +], +"enumDescriptions": [ +"Default value when secondary hour type is not specified.", +"The drive-through hour for banks, restaurants, or pharmacies.", +"The happy hour.", +"The delivery hour.", +"The takeout hour.", +"The kitchen hour.", +"The breakfast hour.", +"The lunch hour.", +"The dinner hour.", +"The brunch hour.", +"The pickup hour.", +"The access hours for storage places.", +"The special hours for seniors.", +"The online service hours." +], +"type": "string" +}, +"specialDays": { +"description": "Structured information for special days that fall within the period that the returned opening hours cover. Special days are days that could impact the business hours of a place, e.g. Christmas day. Set for current_opening_hours and current_secondary_opening_hours if there are exceptional hours.", +"items": { +"$ref": "GoogleMapsPlacesV1PlaceOpeningHoursSpecialDay" +}, +"type": "array" +}, +"weekdayDescriptions": { +"description": "Localized strings describing the opening hours of this place, one string for each day of the week. Will be empty if the hours are unknown or could not be converted to localized text. Example: \"Sun: 18:00\u201306:00\"", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceOpeningHoursPeriod": { +"description": "A period the place remains in open_now status.", +"id": "GoogleMapsPlacesV1PlaceOpeningHoursPeriod", +"properties": { +"close": { +"$ref": "GoogleMapsPlacesV1PlaceOpeningHoursPeriodPoint", +"description": "The time that the place starts to be closed." +}, +"open": { +"$ref": "GoogleMapsPlacesV1PlaceOpeningHoursPeriodPoint", +"description": "The time that the place starts to be open." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceOpeningHoursPeriodPoint": { +"description": "Status changing points.", +"id": "GoogleMapsPlacesV1PlaceOpeningHoursPeriodPoint", +"properties": { +"date": { +"$ref": "GoogleTypeDate", +"description": "Date in the local timezone for the place." +}, +"day": { +"description": "A day of the week, as an integer in the range 0-6. 0 is Sunday, 1 is Monday, etc.", +"format": "int32", +"type": "integer" +}, +"hour": { +"description": "The hour in 24 hour format. Ranges from 0 to 23.", +"format": "int32", +"type": "integer" +}, +"minute": { +"description": "The minute. Ranges from 0 to 59.", +"format": "int32", +"type": "integer" +}, +"truncated": { +"description": "Whether or not this endpoint was truncated. Truncation occurs when the real hours are outside the times we are willing to return hours between, so we truncate the hours back to these boundaries. This ensures that at most 24 * 7 hours from midnight of the day of the request are returned.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceOpeningHoursSpecialDay": { +"description": "Structured information for special days that fall within the period that the returned opening hours cover. Special days are days that could impact the business hours of a place, e.g. Christmas day.", +"id": "GoogleMapsPlacesV1PlaceOpeningHoursSpecialDay", +"properties": { +"date": { +"$ref": "GoogleTypeDate", +"description": "The date of this special day." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceParkingOptions": { +"description": "Information about parking options for the place. A parking lot could support more than one option at the same time.", +"id": "GoogleMapsPlacesV1PlaceParkingOptions", +"properties": { +"freeGarageParking": { +"description": "Place offers free garage parking.", +"type": "boolean" +}, +"freeParkingLot": { +"description": "Place offers free parking lots.", +"type": "boolean" +}, +"freeStreetParking": { +"description": "Place offers free street parking.", +"type": "boolean" +}, +"paidGarageParking": { +"description": "Place offers paid garage parking.", +"type": "boolean" +}, +"paidParkingLot": { +"description": "Place offers paid parking lots.", +"type": "boolean" +}, +"paidStreetParking": { +"description": "Place offers paid street parking.", +"type": "boolean" +}, +"valetParking": { +"description": "Place offers valet parking.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlacePaymentOptions": { +"description": "Payment options the place accepts.", +"id": "GoogleMapsPlacesV1PlacePaymentOptions", +"properties": { +"acceptsCashOnly": { +"description": "Place accepts cash only as payment. Places with this attribute may still accept other payment methods.", +"type": "boolean" +}, +"acceptsCreditCards": { +"description": "Place accepts credit cards as payment.", +"type": "boolean" +}, +"acceptsDebitCards": { +"description": "Place accepts debit cards as payment.", +"type": "boolean" +}, +"acceptsNfc": { +"description": "Place accepts NFC payments.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlacePlusCode": { +"description": "Plus code (http://plus.codes) is a location reference with two formats: global code defining a 14mx14m (1/8000th of a degree) or smaller rectangle, and compound code, replacing the prefix with a reference location.", +"id": "GoogleMapsPlacesV1PlacePlusCode", +"properties": { +"compoundCode": { +"description": "Place's compound code, such as \"33GV+HQ, Ramberg, Norway\", containing the suffix of the global code and replacing the prefix with a formatted name of a reference entity.", +"type": "string" +}, +"globalCode": { +"description": "Place's global (full) code, such as \"9FWM33GV+HQ\", representing an 1/8000 by 1/8000 degree area (~14 by 14 meters).", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PlaceSubDestination": { +"description": "Place resource name and id of sub destinations that relate to the place. For example, different terminals are different destinations of an airport.", +"id": "GoogleMapsPlacesV1PlaceSubDestination", +"properties": { +"id": { +"description": "The place id of the sub destination.", +"type": "string" +}, +"name": { +"description": "The resource name of the sub destination.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1Polyline": { +"description": "A route polyline. Only supports an [encoded polyline](https://developers.google.com/maps/documentation/utilities/polylinealgorithm), which can be passed as a string and includes compression with minimal lossiness. This is the Routes API default output.", +"id": "GoogleMapsPlacesV1Polyline", +"properties": { +"encodedPolyline": { +"description": "An [encoded polyline](https://developers.google.com/maps/documentation/utilities/polylinealgorithm), as returned by the [Routes API by default](https://developers.google.com/maps/documentation/routes/reference/rest/v2/TopLevel/computeRoutes#polylineencoding). See the [encoder](https://developers.google.com/maps/documentation/utilities/polylineutility) and [decoder](https://developers.google.com/maps/documentation/routes/polylinedecoder) tools.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1PriceRange": { +"description": "The price range associated with a Place. `end_price` could be unset, which indicates a range without upper bound (e.g. \"More than $100\").", +"id": "GoogleMapsPlacesV1PriceRange", +"properties": { +"endPrice": { +"$ref": "GoogleTypeMoney", +"description": "The high end of the price range (exclusive). Price should be lower than this amount." +}, +"startPrice": { +"$ref": "GoogleTypeMoney", +"description": "The low end of the price range (inclusive). Price should be at or above this amount." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1References": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. Reference that the generative content is related to.", +"id": "GoogleMapsPlacesV1References", +"properties": { +"places": { +"description": "The list of resource names of the referenced places. This name can be used in other APIs that accept Place resource names.", +"items": { +"type": "string" +}, +"type": "array" +}, +"reviews": { +"description": "Reviews that serve as references.", +"items": { +"$ref": "GoogleMapsPlacesV1Review" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1Review": { +"description": "Information about a review of a place.", +"id": "GoogleMapsPlacesV1Review", +"properties": { +"authorAttribution": { +"$ref": "GoogleMapsPlacesV1AuthorAttribution", +"description": "This review's author." +}, +"flagContentUri": { +"description": "A link where users can flag a problem with the review.", +"type": "string" +}, +"googleMapsUri": { +"description": "A link to show the review on Google Maps.", +"type": "string" +}, +"name": { +"description": "A reference representing this place review which may be used to look up this place review again (also called the API \"resource\" name: `places/{place_id}/reviews/{review}`).", +"type": "string" +}, +"originalText": { +"$ref": "GoogleTypeLocalizedText", +"description": "The review text in its original language." +}, +"publishTime": { +"description": "Timestamp for the review.", +"format": "google-datetime", +"type": "string" +}, +"rating": { +"description": "A number between 1.0 and 5.0, also called the number of stars.", +"format": "double", +"type": "number" +}, +"relativePublishTimeDescription": { +"description": "A string of formatted recent time, expressing the review time relative to the current time in a form appropriate for the language and country.", +"type": "string" +}, +"text": { +"$ref": "GoogleTypeLocalizedText", +"description": "The localized text of the review." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1RouteModifiers": { +"description": "Encapsulates a set of optional conditions to satisfy when calculating the routes.", +"id": "GoogleMapsPlacesV1RouteModifiers", +"properties": { +"avoidFerries": { +"description": "Optional. When set to true, avoids ferries where reasonable, giving preference to routes not containing ferries. Applies only to the `DRIVE` and `TWO_WHEELER` `TravelMode`.", +"type": "boolean" +}, +"avoidHighways": { +"description": "Optional. When set to true, avoids highways where reasonable, giving preference to routes not containing highways. Applies only to the `DRIVE` and `TWO_WHEELER` `TravelMode`.", +"type": "boolean" +}, +"avoidIndoor": { +"description": "Optional. When set to true, avoids navigating indoors where reasonable, giving preference to routes not containing indoor navigation. Applies only to the `WALK` `TravelMode`.", +"type": "boolean" +}, +"avoidTolls": { +"description": "Optional. When set to true, avoids toll roads where reasonable, giving preference to routes not containing toll roads. Applies only to the `DRIVE` and `TWO_WHEELER` `TravelMode`.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1RoutingParameters": { +"description": "Parameters to configure the routing calculations to the places in the response, both along a route (where result ranking will be influenced) and for calculating travel times on results.", +"id": "GoogleMapsPlacesV1RoutingParameters", +"properties": { +"origin": { +"$ref": "GoogleTypeLatLng", +"description": "Optional. An explicit routing origin that overrides the origin defined in the polyline. By default, the polyline origin is used." +}, +"routeModifiers": { +"$ref": "GoogleMapsPlacesV1RouteModifiers", +"description": "Optional. The route modifiers." +}, +"routingPreference": { +"description": "Optional. Specifies how to compute the routing summaries. The server attempts to use the selected routing preference to compute the route. The traffic aware routing preference is only available for the `DRIVE` or `TWO_WHEELER` `travelMode`.", +"enum": [ +"ROUTING_PREFERENCE_UNSPECIFIED", +"TRAFFIC_UNAWARE", +"TRAFFIC_AWARE", +"TRAFFIC_AWARE_OPTIMAL" +], +"enumDescriptions": [ +"No routing preference specified. Default to `TRAFFIC_UNAWARE`.", +"Computes routes without taking live traffic conditions into consideration. Suitable when traffic conditions don't matter or are not applicable. Using this value produces the lowest latency. Note: For `TravelMode` `DRIVE` and `TWO_WHEELER`, the route and duration chosen are based on road network and average time-independent traffic conditions, not current road conditions. Consequently, routes may include roads that are temporarily closed. Results for a given request may vary over time due to changes in the road network, updated average traffic conditions, and the distributed nature of the service. Results may also vary between nearly-equivalent routes at any time or frequency.", +"Calculates routes taking live traffic conditions into consideration. In contrast to `TRAFFIC_AWARE_OPTIMAL`, some optimizations are applied to significantly reduce latency.", +"Calculates the routes taking live traffic conditions into consideration, without applying most performance optimizations. Using this value produces the highest latency." +], +"type": "string" +}, +"travelMode": { +"description": "Optional. The travel mode.", +"enum": [ +"TRAVEL_MODE_UNSPECIFIED", +"DRIVE", +"BICYCLE", +"WALK", +"TWO_WHEELER" +], +"enumDescriptions": [ +"No travel mode specified. Defaults to `DRIVE`.", +"Travel by passenger car.", +"Travel by bicycle. Not supported with `search_along_route_parameters`.", +"Travel by walking. Not supported with `search_along_route_parameters`.", +"Motorized two wheeled vehicles of all kinds such as scooters and motorcycles. Note that this is distinct from the `BICYCLE` travel mode which covers human-powered transport. Not supported with `search_along_route_parameters`. Only supported in those countries listed at [Countries and regions supported for two-wheeled vehicles](https://developers.google.com/maps/documentation/routes/coverage-two-wheeled)." +], +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1RoutingSummary": { +"description": "The duration and distance from the routing origin to a place in the response, and a second leg from that place to the destination, if requested. **Note:** Adding `routingSummaries` in the field mask without also including either the `routingParameters.origin` parameter or the `searchAlongRouteParameters.polyline.encodedPolyline` parameter in the request causes an error.", +"id": "GoogleMapsPlacesV1RoutingSummary", +"properties": { +"directionsUri": { +"description": "A link to show directions on Google Maps using the waypoints from the given routing summary. The route generated by this link is not guaranteed to be the same as the route used to generate the routing summary. The link uses information provided in the request, from fields including `routingParameters` and `searchAlongRouteParameters` when applicable, to generate the directions link.", +"type": "string" +}, +"legs": { +"description": "The legs of the trip. When you calculate travel duration and distance from a set origin, `legs` contains a single leg containing the duration and distance from the origin to the destination. When you do a search along route, `legs` contains two legs: one from the origin to place, and one from the place to the destination.", +"items": { +"$ref": "GoogleMapsPlacesV1RoutingSummaryLeg" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1RoutingSummaryLeg": { +"description": "A leg is a single portion of a journey from one location to another.", +"id": "GoogleMapsPlacesV1RoutingSummaryLeg", +"properties": { +"distanceMeters": { +"description": "The distance of this leg of the trip.", +"format": "int32", +"type": "integer" +}, +"duration": { +"description": "The time it takes to complete this leg of the trip.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchNearbyRequest": { +"description": "Request proto for Search Nearby. ", +"id": "GoogleMapsPlacesV1SearchNearbyRequest", +"properties": { +"excludedPrimaryTypes": { +"description": "Excluded primary Place type (e.g. \"restaurant\" or \"gas_station\") from https://developers.google.com/maps/documentation/places/web-service/place-types. Up to 50 types from [Table A](https://developers.google.com/maps/documentation/places/web-service/place-types#table-a) may be specified. If there are any conflicting primary types, i.e. a type appears in both included_primary_types and excluded_primary_types, an INVALID_ARGUMENT error is returned. If a Place type is specified with multiple type restrictions, only places that satisfy all of the restrictions are returned. For example, if we have {included_types = [\"restaurant\"], excluded_primary_types = [\"restaurant\"]}, the returned places provide \"restaurant\" related services but do not operate primarily as \"restaurants\".", +"items": { +"type": "string" +}, +"type": "array" +}, +"excludedTypes": { +"description": "Excluded Place type (eg, \"restaurant\" or \"gas_station\") from https://developers.google.com/maps/documentation/places/web-service/place-types. Up to 50 types from [Table A](https://developers.google.com/maps/documentation/places/web-service/place-types#table-a) may be specified. If the client provides both included_types (e.g. restaurant) and excluded_types (e.g. cafe), then the response should include places that are restaurant but not cafe. The response includes places that match at least one of the included_types and none of the excluded_types. If there are any conflicting types, i.e. a type appears in both included_types and excluded_types, an INVALID_ARGUMENT error is returned. If a Place type is specified with multiple type restrictions, only places that satisfy all of the restrictions are returned. For example, if we have {included_types = [\"restaurant\"], excluded_primary_types = [\"restaurant\"]}, the returned places provide \"restaurant\" related services but do not operate primarily as \"restaurants\".", +"items": { +"type": "string" +}, +"type": "array" +}, +"includedPrimaryTypes": { +"description": "Included primary Place type (e.g. \"restaurant\" or \"gas_station\") from https://developers.google.com/maps/documentation/places/web-service/place-types. A place can only have a single primary type from the supported types table associated with it. Up to 50 types from [Table A](https://developers.google.com/maps/documentation/places/web-service/place-types#table-a) may be specified. If there are any conflicting primary types, i.e. a type appears in both included_primary_types and excluded_primary_types, an INVALID_ARGUMENT error is returned. If a Place type is specified with multiple type restrictions, only places that satisfy all of the restrictions are returned. For example, if we have {included_types = [\"restaurant\"], excluded_primary_types = [\"restaurant\"]}, the returned places provide \"restaurant\" related services but do not operate primarily as \"restaurants\".", +"items": { +"type": "string" +}, +"type": "array" +}, +"includedTypes": { +"description": "Included Place type (eg, \"restaurant\" or \"gas_station\") from https://developers.google.com/maps/documentation/places/web-service/place-types. Up to 50 types from [Table A](https://developers.google.com/maps/documentation/places/web-service/place-types#table-a) may be specified. If there are any conflicting types, i.e. a type appears in both included_types and excluded_types, an INVALID_ARGUMENT error is returned. If a Place type is specified with multiple type restrictions, only places that satisfy all of the restrictions are returned. For example, if we have {included_types = [\"restaurant\"], excluded_primary_types = [\"restaurant\"]}, the returned places provide \"restaurant\" related services but do not operate primarily as \"restaurants\".", +"items": { +"type": "string" +}, +"type": "array" +}, +"languageCode": { +"description": "Place details will be displayed with the preferred language if available. If the language code is unspecified or unrecognized, place details of any language may be returned, with a preference for English if such details exist. Current list of supported languages: https://developers.google.com/maps/faq#languagesupport.", +"type": "string" +}, +"locationRestriction": { +"$ref": "GoogleMapsPlacesV1SearchNearbyRequestLocationRestriction", +"description": "Required. The region to search." +}, +"maxResultCount": { +"description": "Maximum number of results to return. It must be between 1 and 20 (default), inclusively. If the number is unset, it falls back to the upper limit. If the number is set to negative or exceeds the upper limit, an INVALID_ARGUMENT error is returned.", +"format": "int32", +"type": "integer" +}, +"rankPreference": { +"description": "How results will be ranked in the response.", +"enum": [ +"RANK_PREFERENCE_UNSPECIFIED", +"DISTANCE", +"POPULARITY" +], +"enumDescriptions": [ +"RankPreference value not set. Will use rank by POPULARITY by default.", +"Ranks results by distance.", +"Ranks results by popularity." +], +"type": "string" +}, +"regionCode": { +"description": "The Unicode country/region code (CLDR) of the location where the request is coming from. This parameter is used to display the place details, like region-specific place name, if available. The parameter can affect results based on applicable law. For more information, see https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html. Note that 3-digit region codes are not currently supported.", +"type": "string" +}, +"routingParameters": { +"$ref": "GoogleMapsPlacesV1RoutingParameters", +"description": "Optional. Parameters that affect the routing to the search results." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchNearbyRequestLocationRestriction": { +"description": "The region to search.", +"id": "GoogleMapsPlacesV1SearchNearbyRequestLocationRestriction", +"properties": { +"circle": { +"$ref": "GoogleMapsPlacesV1Circle", +"description": "A circle defined by center point and radius." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchNearbyResponse": { +"description": "Response proto for Search Nearby. ", +"id": "GoogleMapsPlacesV1SearchNearbyResponse", +"properties": { +"places": { +"description": "A list of places that meets user's requirements like places types, number of places and specific location restriction.", +"items": { +"$ref": "GoogleMapsPlacesV1Place" +}, +"type": "array" +}, +"routingSummaries": { +"description": "A list of routing summaries where each entry associates to the corresponding place in the same index in the `places` field. If the routing summary is not available for one of the places, it will contain an empty entry. This list should have as many entries as the list of places if requested.", +"items": { +"$ref": "GoogleMapsPlacesV1RoutingSummary" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchTextRequest": { +"description": "Request proto for SearchText. ", +"id": "GoogleMapsPlacesV1SearchTextRequest", +"properties": { +"evOptions": { +"$ref": "GoogleMapsPlacesV1SearchTextRequestEVOptions", +"description": "Optional. Set the searchable EV options of a place search request." +}, +"includePureServiceAreaBusinesses": { +"description": "Optional. Include pure service area businesses if the field is set to true. Pure service area business is a business that visits or delivers to customers directly but does not serve customers at their business address. For example, businesses like cleaning services or plumbers. Those businesses do not have a physical address or location on Google Maps. Places will not return fields including `location`, `plus_code`, and other location related fields for these businesses.", +"type": "boolean" +}, +"includedType": { +"description": "The requested place type. Full list of types supported: https://developers.google.com/maps/documentation/places/web-service/place-types. Only support one included type.", +"type": "string" +}, +"languageCode": { +"description": "Place details will be displayed with the preferred language if available. If the language code is unspecified or unrecognized, place details of any language may be returned, with a preference for English if such details exist. Current list of supported languages: https://developers.google.com/maps/faq#languagesupport.", +"type": "string" +}, +"locationBias": { +"$ref": "GoogleMapsPlacesV1SearchTextRequestLocationBias", +"description": "The region to search. This location serves as a bias which means results around given location might be returned. Cannot be set along with location_restriction." +}, +"locationRestriction": { +"$ref": "GoogleMapsPlacesV1SearchTextRequestLocationRestriction", +"description": "The region to search. This location serves as a restriction which means results outside given location will not be returned. Cannot be set along with location_bias." +}, +"maxResultCount": { +"deprecated": true, +"description": "Deprecated: Use `page_size` instead. The maximum number of results per page that can be returned. If the number of available results is larger than `max_result_count`, a `next_page_token` is returned which can be passed to `page_token` to get the next page of results in subsequent requests. If 0 or no value is provided, a default of 20 is used. The maximum value is 20; values above 20 will be coerced to 20. Negative values will return an INVALID_ARGUMENT error. If both `max_result_count` and `page_size` are specified, `max_result_count` will be ignored.", +"format": "int32", +"type": "integer" +}, +"minRating": { +"description": "Filter out results whose average user rating is strictly less than this limit. A valid value must be a float between 0 and 5 (inclusively) at a 0.5 cadence i.e. [0, 0.5, 1.0, ... , 5.0] inclusively. The input rating will round up to the nearest 0.5(ceiling). For instance, a rating of 0.6 will eliminate all results with a less than 1.0 rating.", +"format": "double", +"type": "number" +}, +"openNow": { +"description": "Used to restrict the search to places that are currently open. The default is false.", +"type": "boolean" +}, +"pageSize": { +"description": "Optional. The maximum number of results per page that can be returned. If the number of available results is larger than `page_size`, a `next_page_token` is returned which can be passed to `page_token` to get the next page of results in subsequent requests. If 0 or no value is provided, a default of 20 is used. The maximum value is 20; values above 20 will be set to 20. Negative values will return an INVALID_ARGUMENT error. If both `max_result_count` and `page_size` are specified, `max_result_count` will be ignored.", +"format": "int32", +"type": "integer" +}, +"pageToken": { +"description": "Optional. A page token, received from a previous TextSearch call. Provide this to retrieve the subsequent page. When paginating, all parameters other than `page_token`, `page_size`, and `max_result_count` provided to TextSearch must match the initial call that provided the page token. Otherwise an INVALID_ARGUMENT error is returned.", +"type": "string" +}, +"priceLevels": { +"description": "Used to restrict the search to places that are marked as certain price levels. Users can choose any combinations of price levels. Default to select all price levels.", +"items": { +"enum": [ +"PRICE_LEVEL_UNSPECIFIED", +"PRICE_LEVEL_FREE", +"PRICE_LEVEL_INEXPENSIVE", +"PRICE_LEVEL_MODERATE", +"PRICE_LEVEL_EXPENSIVE", +"PRICE_LEVEL_VERY_EXPENSIVE" +], +"enumDescriptions": [ +"Place price level is unspecified or unknown.", +"Place provides free services.", +"Place provides inexpensive services.", +"Place provides moderately priced services.", +"Place provides expensive services.", +"Place provides very expensive services." +], +"type": "string" +}, +"type": "array" +}, +"rankPreference": { +"description": "How results will be ranked in the response.", +"enum": [ +"RANK_PREFERENCE_UNSPECIFIED", +"DISTANCE", +"RELEVANCE" +], +"enumDescriptions": [ +"For a categorical query such as \"Restaurants in New York City\", RELEVANCE is the default. For non-categorical queries such as \"Mountain View, CA\" we recommend that you leave rankPreference unset.", +"Ranks results by distance.", +"Ranks results by relevance. Sort order determined by normal ranking stack." +], +"type": "string" +}, +"regionCode": { +"description": "The Unicode country/region code (CLDR) of the location where the request is coming from. This parameter is used to display the place details, like region-specific place name, if available. The parameter can affect results based on applicable law. For more information, see https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html. Note that 3-digit region codes are not currently supported.", +"type": "string" +}, +"routingParameters": { +"$ref": "GoogleMapsPlacesV1RoutingParameters", +"description": "Optional. Additional parameters for routing to results." +}, +"searchAlongRouteParameters": { +"$ref": "GoogleMapsPlacesV1SearchTextRequestSearchAlongRouteParameters", +"description": "Optional. Additional parameters proto for searching along a route." +}, +"strictTypeFiltering": { +"description": "Used to set strict type filtering for included_type. If set to true, only results of the same type will be returned. Default to false.", +"type": "boolean" +}, +"textQuery": { +"description": "Required. The text query for textual search.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchTextRequestEVOptions": { +"description": "Searchable EV options of a place search request.", +"id": "GoogleMapsPlacesV1SearchTextRequestEVOptions", +"properties": { +"connectorTypes": { +"description": "Optional. The list of preferred EV connector types. A place that does not support any of the listed connector types is filtered out.", +"items": { +"enum": [ +"EV_CONNECTOR_TYPE_UNSPECIFIED", +"EV_CONNECTOR_TYPE_OTHER", +"EV_CONNECTOR_TYPE_J1772", +"EV_CONNECTOR_TYPE_TYPE_2", +"EV_CONNECTOR_TYPE_CHADEMO", +"EV_CONNECTOR_TYPE_CCS_COMBO_1", +"EV_CONNECTOR_TYPE_CCS_COMBO_2", +"EV_CONNECTOR_TYPE_TESLA", +"EV_CONNECTOR_TYPE_UNSPECIFIED_GB_T", +"EV_CONNECTOR_TYPE_UNSPECIFIED_WALL_OUTLET" +], +"enumDescriptions": [ +"Unspecified connector.", +"Other connector types.", +"J1772 type 1 connector.", +"IEC 62196 type 2 connector. Often referred to as MENNEKES.", +"CHAdeMO type connector.", +"Combined Charging System (AC and DC). Based on SAE. Type-1 J-1772 connector", +"Combined Charging System (AC and DC). Based on Type-2 Mennekes connector", +"The generic TESLA connector. This is NACS in the North America but can be non-NACS in other parts of the world (e.g. CCS Combo 2 (CCS2) or GB/T). This value is less representative of an actual connector type, and more represents the ability to charge a Tesla brand vehicle at a Tesla owned charging station.", +"GB/T type corresponds to the GB/T standard in China. This type covers all GB_T types.", +"Unspecified wall outlet." +], +"type": "string" +}, +"type": "array" +}, +"minimumChargingRateKw": { +"description": "Optional. Minimum required charging rate in kilowatts. A place with a charging rate less than the specified rate is filtered out.", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchTextRequestLocationBias": { +"description": "The region to search. This location serves as a bias which means results around given location might be returned.", +"id": "GoogleMapsPlacesV1SearchTextRequestLocationBias", +"properties": { +"circle": { +"$ref": "GoogleMapsPlacesV1Circle", +"description": "A circle defined by center point and radius." +}, +"rectangle": { +"$ref": "GoogleGeoTypeViewport", +"description": "A rectangle box defined by northeast and southwest corner. `rectangle.high()` must be the northeast point of the rectangle viewport. `rectangle.low()` must be the southwest point of the rectangle viewport. `rectangle.low().latitude()` cannot be greater than `rectangle.high().latitude()`. This will result in an empty latitude range. A rectangle viewport cannot be wider than 180 degrees." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchTextRequestLocationRestriction": { +"description": "The region to search. This location serves as a restriction which means results outside given location will not be returned.", +"id": "GoogleMapsPlacesV1SearchTextRequestLocationRestriction", +"properties": { +"rectangle": { +"$ref": "GoogleGeoTypeViewport", +"description": "A rectangle box defined by northeast and southwest corner. `rectangle.high()` must be the northeast point of the rectangle viewport. `rectangle.low()` must be the southwest point of the rectangle viewport. `rectangle.low().latitude()` cannot be greater than `rectangle.high().latitude()`. This will result in an empty latitude range. A rectangle viewport cannot be wider than 180 degrees." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchTextRequestSearchAlongRouteParameters": { +"description": "Specifies a precalculated polyline from the [Routes API](https://developers.google.com/maps/documentation/routes) defining the route to search. Searching along a route is similar to using the `locationBias` or `locationRestriction` request option to bias the search results. However, while the `locationBias` and `locationRestriction` options let you specify a region to bias the search results, this option lets you bias the results along a trip route. Results are not guaranteed to be along the route provided, but rather are ranked within the search area defined by the polyline and, optionally, by the `locationBias` or `locationRestriction` based on minimal detour times from origin to destination. The results might be along an alternate route, especially if the provided polyline does not define an optimal route from origin to destination.", +"id": "GoogleMapsPlacesV1SearchTextRequestSearchAlongRouteParameters", +"properties": { +"polyline": { +"$ref": "GoogleMapsPlacesV1Polyline", +"description": "Required. The route polyline." +} +}, +"type": "object" +}, +"GoogleMapsPlacesV1SearchTextResponse": { +"description": "Response proto for SearchText. ", +"id": "GoogleMapsPlacesV1SearchTextResponse", +"properties": { +"contextualContents": { +"description": "Experimental: See https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative for more details. A list of contextual contents where each entry associates to the corresponding place in the same index in the places field. The contents that are relevant to the `text_query` in the request are preferred. If the contextual content is not available for one of the places, it will return non-contextual content. It will be empty only when the content is unavailable for this place. This list will have as many entries as the list of places if requested.", +"items": { +"$ref": "GoogleMapsPlacesV1ContextualContent" +}, +"type": "array" +}, +"nextPageToken": { +"description": "A token that can be sent as `page_token` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.", +"type": "string" +}, +"places": { +"description": "A list of places that meet the user's text search criteria.", +"items": { +"$ref": "GoogleMapsPlacesV1Place" +}, +"type": "array" +}, +"routingSummaries": { +"description": "A list of routing summaries where each entry associates to the corresponding place in the same index in the `places` field. If the routing summary is not available for one of the places, it will contain an empty entry. This list will have as many entries as the list of places if requested.", +"items": { +"$ref": "GoogleMapsPlacesV1RoutingSummary" +}, +"type": "array" +}, +"searchUri": { +"description": "A link allows the user to search with the same text query as specified in the request on Google Maps.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleTypeDate": { +"description": "Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp", +"id": "GoogleTypeDate", +"properties": { +"day": { +"description": "Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.", +"format": "int32", +"type": "integer" +}, +"month": { +"description": "Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.", +"format": "int32", +"type": "integer" +}, +"year": { +"description": "Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"GoogleTypeLatLng": { +"description": "An object that represents a latitude/longitude pair. This is expressed as a pair of doubles to represent degrees latitude and degrees longitude. Unless specified otherwise, this object must conform to the WGS84 standard. Values must be within normalized ranges.", +"id": "GoogleTypeLatLng", +"properties": { +"latitude": { +"description": "The latitude in degrees. It must be in the range [-90.0, +90.0].", +"format": "double", +"type": "number" +}, +"longitude": { +"description": "The longitude in degrees. It must be in the range [-180.0, +180.0].", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"GoogleTypeLocalizedText": { +"description": "Localized variant of a text in a particular language.", +"id": "GoogleTypeLocalizedText", +"properties": { +"languageCode": { +"description": "The text's BCP-47 language code, such as \"en-US\" or \"sr-Latn\". For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.", +"type": "string" +}, +"text": { +"description": "Localized string in the language corresponding to language_code below.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleTypeMoney": { +"description": "Represents an amount of money with its currency type.", +"id": "GoogleTypeMoney", +"properties": { +"currencyCode": { +"description": "The three-letter currency code defined in ISO 4217.", +"type": "string" +}, +"nanos": { +"description": "Number of nano (10^-9) units of the amount. The value must be between -999,999,999 and +999,999,999 inclusive. If `units` is positive, `nanos` must be positive or zero. If `units` is zero, `nanos` can be positive, zero, or negative. If `units` is negative, `nanos` must be negative or zero. For example $-1.75 is represented as `units`=-1 and `nanos`=-750,000,000.", +"format": "int32", +"type": "integer" +}, +"units": { +"description": "The whole units of the amount. For example if `currencyCode` is `\"USD\"`, then 1 unit is one US dollar.", +"format": "int64", +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Places API (New)", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/recaptchaenterprise.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/recaptchaenterprise.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..be5c8d6471b740e95340554a177e4ba009a8a76c --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/recaptchaenterprise.v1.json @@ -0,0 +1,2537 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +} +} +} +}, +"basePath": "", +"baseUrl": "https://recaptchaenterprise.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Recaptcha Enterprise", +"description": "Help protect your website from fraudulent activity, spam, and abuse without creating friction.", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/recaptcha-enterprise/", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "recaptchaenterprise:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://recaptchaenterprise.mtls.googleapis.com/", +"name": "recaptchaenterprise", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"projects": { +"resources": { +"assessments": { +"methods": { +"annotate": { +"description": "Annotates a previously created Assessment to provide additional information on whether the event turned out to be authentic or fraudulent.", +"flatPath": "v1/projects/{projectsId}/assessments/{assessmentsId}:annotate", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.assessments.annotate", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource name of the Assessment, in the format `projects/{project}/assessments/{assessment}`.", +"location": "path", +"pattern": "^projects/[^/]+/assessments/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:annotate", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AnnotateAssessmentRequest" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AnnotateAssessmentResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"create": { +"description": "Creates an Assessment of the likelihood an event is legitimate.", +"flatPath": "v1/projects/{projectsId}/assessments", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.assessments.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the project in which the assessment is created, in the format `projects/{project}`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/assessments", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Assessment" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Assessment" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"firewallpolicies": { +"methods": { +"create": { +"description": "Creates a new FirewallPolicy, specifying conditions at which reCAPTCHA Enterprise actions can be executed. A project may have a maximum of 1000 policies.", +"flatPath": "v1/projects/{projectsId}/firewallpolicies", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.firewallpolicies.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the project this policy applies to, in the format `projects/{project}`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/firewallpolicies", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallPolicy" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes the specified firewall policy.", +"flatPath": "v1/projects/{projectsId}/firewallpolicies/{firewallpoliciesId}", +"httpMethod": "DELETE", +"id": "recaptchaenterprise.projects.firewallpolicies.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the policy to be deleted, in the format `projects/{project}/firewallpolicies/{firewallpolicy}`.", +"location": "path", +"pattern": "^projects/[^/]+/firewallpolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleProtobufEmpty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Returns the specified firewall policy.", +"flatPath": "v1/projects/{projectsId}/firewallpolicies/{firewallpoliciesId}", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.firewallpolicies.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the requested policy, in the format `projects/{project}/firewallpolicies/{firewallpolicy}`.", +"location": "path", +"pattern": "^projects/[^/]+/firewallpolicies/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Returns the list of all firewall policies that belong to a project.", +"flatPath": "v1/projects/{projectsId}/firewallpolicies", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.firewallpolicies.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Optional. The maximum number of policies to return. Default is 10. Max limit is 1000.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The next_page_token value returned from a previous. ListFirewallPoliciesRequest, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The name of the project to list the policies for, in the format `projects/{project}`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/firewallpolicies", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ListFirewallPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the specified firewall policy.", +"flatPath": "v1/projects/{projectsId}/firewallpolicies/{firewallpoliciesId}", +"httpMethod": "PATCH", +"id": "recaptchaenterprise.projects.firewallpolicies.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Identifier. The resource name for the FirewallPolicy in the format `projects/{project}/firewallpolicies/{firewallpolicy}`.", +"location": "path", +"pattern": "^projects/[^/]+/firewallpolicies/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. The mask to control which fields of the policy get updated. If the mask is not present, all fields are updated.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallPolicy" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallPolicy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"reorder": { +"description": "Reorders all firewall policies.", +"flatPath": "v1/projects/{projectsId}/firewallpolicies:reorder", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.firewallpolicies.reorder", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the project to list the policies for, in the format `projects/{project}`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/firewallpolicies:reorder", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ReorderFirewallPoliciesRequest" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ReorderFirewallPoliciesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"keys": { +"methods": { +"addIpOverride": { +"description": "Adds an IP override to a key. The following restrictions hold: * The maximum number of IP overrides per key is 100. * For any conflict (such as IP already exists or IP part of an existing IP range), an error is returned.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}:addIpOverride", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.keys.addIpOverride", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the key to which the IP override is added, in the format `projects/{project}/keys/{key}`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:addIpOverride", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AddIpOverrideRequest" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AddIpOverrideResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"create": { +"description": "Creates a new reCAPTCHA Enterprise key.", +"flatPath": "v1/projects/{projectsId}/keys", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.keys.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the project in which the key is created, in the format `projects/{project}`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/keys", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Key" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Key" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes the specified key.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}", +"httpMethod": "DELETE", +"id": "recaptchaenterprise.projects.keys.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the key to be deleted, in the format `projects/{project}/keys/{key}`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleProtobufEmpty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Returns the specified key.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.keys.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the requested key, in the format `projects/{project}/keys/{key}`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Key" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"getMetrics": { +"description": "Get some aggregated metrics for a Key. This data can be used to build dashboards.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}/metrics", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.keys.getMetrics", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the requested metrics, in the format `projects/{project}/keys/{key}/metrics`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+/metrics$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Metrics" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Returns the list of all keys that belong to a project.", +"flatPath": "v1/projects/{projectsId}/keys", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.keys.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Optional. The maximum number of keys to return. Default is 10. Max limit is 1000.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The next_page_token value returned from a previous. ListKeysRequest, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The name of the project that contains the keys that is listed, in the format `projects/{project}`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/keys", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ListKeysResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"listIpOverrides": { +"description": "Lists all IP overrides for a key.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}:listIpOverrides", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.keys.listIpOverrides", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Optional. The maximum number of overrides to return. Default is 10. Max limit is 100. If the number of overrides is less than the page_size, all overrides are returned. If the page size is more than 100, it is coerced to 100.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The next_page_token value returned from a previous ListIpOverridesRequest, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent key for which the IP overrides are listed, in the format `projects/{project}/keys/{key}`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}:listIpOverrides", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ListIpOverridesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"migrate": { +"description": "Migrates an existing key from reCAPTCHA to reCAPTCHA Enterprise. Once a key is migrated, it can be used from either product. SiteVerify requests are billed as CreateAssessment calls. You must be authenticated as one of the current owners of the reCAPTCHA Key, and your user must have the reCAPTCHA Enterprise Admin IAM role in the destination project.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}:migrate", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.keys.migrate", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the key to be migrated, in the format `projects/{project}/keys/{key}`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:migrate", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1MigrateKeyRequest" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Key" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates the specified key.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}", +"httpMethod": "PATCH", +"id": "recaptchaenterprise.projects.keys.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Identifier. The resource name for the Key in the format `projects/{project}/keys/{key}`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Optional. The mask to control which fields of the key get updated. If the mask is not present, all fields are updated.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Key" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Key" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"removeIpOverride": { +"description": "Removes an IP override from a key. The following restrictions hold: * If the IP isn't found in an existing IP override, a `NOT_FOUND` error is returned. * If the IP is found in an existing IP override, but the override type does not match, a `NOT_FOUND` error is returned.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}:removeIpOverride", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.keys.removeIpOverride", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the key from which the IP override is removed, in the format `projects/{project}/keys/{key}`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:removeIpOverride", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1RemoveIpOverrideRequest" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1RemoveIpOverrideResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"retrieveLegacySecretKey": { +"description": "Returns the secret key related to the specified public key. You must use the legacy secret key only in a 3rd party integration with legacy reCAPTCHA.", +"flatPath": "v1/projects/{projectsId}/keys/{keysId}:retrieveLegacySecretKey", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.keys.retrieveLegacySecretKey", +"parameterOrder": [ +"key" +], +"parameters": { +"key": { +"description": "Required. The public key name linked to the requested secret key in the format `projects/{project}/keys/{key}`.", +"location": "path", +"pattern": "^projects/[^/]+/keys/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+key}:retrieveLegacySecretKey", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1RetrieveLegacySecretKeyResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"relatedaccountgroupmemberships": { +"methods": { +"search": { +"description": "Search group memberships related to a given account.", +"flatPath": "v1/projects/{projectsId}/relatedaccountgroupmemberships:search", +"httpMethod": "POST", +"id": "recaptchaenterprise.projects.relatedaccountgroupmemberships.search", +"parameterOrder": [ +"project" +], +"parameters": { +"project": { +"description": "Required. The name of the project to search related account group memberships from. Specify the project name in the following format: `projects/{project}`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+project}/relatedaccountgroupmemberships:search", +"request": { +"$ref": "GoogleCloudRecaptchaenterpriseV1SearchRelatedAccountGroupMembershipsRequest" +}, +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1SearchRelatedAccountGroupMembershipsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"relatedaccountgroups": { +"methods": { +"list": { +"description": "List groups of related accounts.", +"flatPath": "v1/projects/{projectsId}/relatedaccountgroups", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.relatedaccountgroups.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Optional. The maximum number of groups to return. The service might return fewer than this value. If unspecified, at most 50 groups are returned. The maximum value is 1000; values above 1000 are coerced to 1000.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. A page token, received from a previous `ListRelatedAccountGroups` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListRelatedAccountGroups` must match the call that provided the page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The name of the project to list related account groups from, in the format `projects/{project}`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/relatedaccountgroups", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ListRelatedAccountGroupsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"memberships": { +"methods": { +"list": { +"description": "Get memberships in a group of related accounts.", +"flatPath": "v1/projects/{projectsId}/relatedaccountgroups/{relatedaccountgroupsId}/memberships", +"httpMethod": "GET", +"id": "recaptchaenterprise.projects.relatedaccountgroups.memberships.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Optional. The maximum number of accounts to return. The service might return fewer than this value. If unspecified, at most 50 accounts are returned. The maximum value is 1000; values above 1000 are coerced to 1000.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. A page token, received from a previous `ListRelatedAccountGroupMemberships` call. When paginating, all other parameters provided to `ListRelatedAccountGroupMemberships` must match the call that provided the page token.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The resource name for the related account group in the format `projects/{project}/relatedaccountgroups/{relatedaccountgroup}`.", +"location": "path", +"pattern": "^projects/[^/]+/relatedaccountgroups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/memberships", +"response": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ListRelatedAccountGroupMembershipsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +} +} +}, +"revision": "20241208", +"rootUrl": "https://recaptchaenterprise.googleapis.com/", +"schemas": { +"GoogleCloudRecaptchaenterpriseV1AccountDefenderAssessment": { +"description": "Account defender risk assessment.", +"id": "GoogleCloudRecaptchaenterpriseV1AccountDefenderAssessment", +"properties": { +"labels": { +"description": "Output only. Labels for this request.", +"items": { +"enum": [ +"ACCOUNT_DEFENDER_LABEL_UNSPECIFIED", +"PROFILE_MATCH", +"SUSPICIOUS_LOGIN_ACTIVITY", +"SUSPICIOUS_ACCOUNT_CREATION", +"RELATED_ACCOUNTS_NUMBER_HIGH" +], +"enumDescriptions": [ +"Default unspecified type.", +"The request matches a known good profile for the user.", +"The request is potentially a suspicious login event and must be further verified either through multi-factor authentication or another system.", +"The request matched a profile that previously had suspicious account creation behavior. This can mean that this is a fake account.", +"The account in the request has a high number of related accounts. It does not necessarily imply that the account is bad but can require further investigation." +], +"type": "string" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1AccountVerificationInfo": { +"description": "Information about account verification, used for identity verification.", +"id": "GoogleCloudRecaptchaenterpriseV1AccountVerificationInfo", +"properties": { +"endpoints": { +"description": "Optional. Endpoints that can be used for identity verification.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1EndpointVerificationInfo" +}, +"type": "array" +}, +"languageCode": { +"description": "Optional. Language code preference for the verification message, set as a IETF BCP 47 language code.", +"type": "string" +}, +"latestVerificationResult": { +"description": "Output only. Result of the latest account verification challenge.", +"enum": [ +"RESULT_UNSPECIFIED", +"SUCCESS_USER_VERIFIED", +"ERROR_USER_NOT_VERIFIED", +"ERROR_SITE_ONBOARDING_INCOMPLETE", +"ERROR_RECIPIENT_NOT_ALLOWED", +"ERROR_RECIPIENT_ABUSE_LIMIT_EXHAUSTED", +"ERROR_CRITICAL_INTERNAL", +"ERROR_CUSTOMER_QUOTA_EXHAUSTED", +"ERROR_VERIFICATION_BYPASSED", +"ERROR_VERDICT_MISMATCH" +], +"enumDescriptions": [ +"No information about the latest account verification.", +"The user was successfully verified. This means the account verification challenge was successfully completed.", +"The user failed the verification challenge.", +"The site is not properly onboarded to use the account verification feature.", +"The recipient is not allowed for account verification. This can occur during integration but should not occur in production.", +"The recipient has already been sent too many verification codes in a short amount of time.", +"The verification flow could not be completed due to a critical internal error.", +"The client has exceeded their two factor request quota for this period of time.", +"The request cannot be processed at the time because of an incident. This bypass can be restricted to a problematic destination email domain, a customer, or could affect the entire service.", +"The request parameters do not match with the token provided and cannot be processed." +], +"readOnly": true, +"type": "string" +}, +"username": { +"deprecated": true, +"description": "Username of the account that is being verified. Deprecated. Customers should now provide the `account_id` field in `event.user_info`.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1AddIpOverrideRequest": { +"description": "The AddIpOverride request message.", +"id": "GoogleCloudRecaptchaenterpriseV1AddIpOverrideRequest", +"properties": { +"ipOverrideData": { +"$ref": "GoogleCloudRecaptchaenterpriseV1IpOverrideData", +"description": "Required. IP override added to the key." +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1AddIpOverrideResponse": { +"description": "Response for AddIpOverride.", +"id": "GoogleCloudRecaptchaenterpriseV1AddIpOverrideResponse", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1AndroidKeySettings": { +"description": "Settings specific to keys that can be used by Android apps.", +"id": "GoogleCloudRecaptchaenterpriseV1AndroidKeySettings", +"properties": { +"allowAllPackageNames": { +"description": "Optional. If set to true, allowed_package_names are not enforced.", +"type": "boolean" +}, +"allowedPackageNames": { +"description": "Optional. Android package names of apps allowed to use the key. Example: 'com.companyname.appname'", +"items": { +"type": "string" +}, +"type": "array" +}, +"supportNonGoogleAppStoreDistribution": { +"description": "Optional. Set to true for keys that are used in an Android application that is available for download in app stores in addition to the Google Play Store.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1AnnotateAssessmentRequest": { +"description": "The request message to annotate an Assessment.", +"id": "GoogleCloudRecaptchaenterpriseV1AnnotateAssessmentRequest", +"properties": { +"accountId": { +"description": "Optional. A stable account identifier to apply to the assessment. This is an alternative to setting `account_id` in `CreateAssessment`, for example when a stable account identifier is not yet known in the initial request.", +"type": "string" +}, +"annotation": { +"description": "Optional. The annotation that is assigned to the Event. This field can be left empty to provide reasons that apply to an event without concluding whether the event is legitimate or fraudulent.", +"enum": [ +"ANNOTATION_UNSPECIFIED", +"LEGITIMATE", +"FRAUDULENT", +"PASSWORD_CORRECT", +"PASSWORD_INCORRECT" +], +"enumDeprecated": [ +false, +false, +false, +true, +true +], +"enumDescriptions": [ +"Default unspecified type.", +"Provides information that the event turned out to be legitimate.", +"Provides information that the event turned out to be fraudulent.", +"Provides information that the event was related to a login event in which the user typed the correct password. Deprecated, prefer indicating CORRECT_PASSWORD through the reasons field instead.", +"Provides information that the event was related to a login event in which the user typed the incorrect password. Deprecated, prefer indicating INCORRECT_PASSWORD through the reasons field instead." +], +"type": "string" +}, +"hashedAccountId": { +"description": "Optional. A stable hashed account identifier to apply to the assessment. This is an alternative to setting `hashed_account_id` in `CreateAssessment`, for example when a stable account identifier is not yet known in the initial request.", +"format": "byte", +"type": "string" +}, +"reasons": { +"description": "Optional. Reasons for the annotation that are assigned to the event.", +"items": { +"enum": [ +"REASON_UNSPECIFIED", +"CHARGEBACK", +"CHARGEBACK_FRAUD", +"CHARGEBACK_DISPUTE", +"REFUND", +"REFUND_FRAUD", +"TRANSACTION_ACCEPTED", +"TRANSACTION_DECLINED", +"PAYMENT_HEURISTICS", +"INITIATED_TWO_FACTOR", +"PASSED_TWO_FACTOR", +"FAILED_TWO_FACTOR", +"CORRECT_PASSWORD", +"INCORRECT_PASSWORD", +"SOCIAL_SPAM" +], +"enumDescriptions": [ +"Default unspecified reason.", +"Indicates that the transaction had a chargeback issued with no other details. When possible, specify the type by using CHARGEBACK_FRAUD or CHARGEBACK_DISPUTE instead.", +"Indicates that the transaction had a chargeback issued related to an alleged unauthorized transaction from the cardholder's perspective (for example, the card number was stolen).", +"Indicates that the transaction had a chargeback issued related to the cardholder having provided their card details but allegedly not being satisfied with the purchase (for example, misrepresentation, attempted cancellation).", +"Indicates that the completed payment transaction was refunded by the seller.", +"Indicates that the completed payment transaction was determined to be fraudulent by the seller, and was cancelled and refunded as a result.", +"Indicates that the payment transaction was accepted, and the user was charged.", +"Indicates that the payment transaction was declined, for example due to invalid card details.", +"Indicates the transaction associated with the assessment is suspected of being fraudulent based on the payment method, billing details, shipping address or other transaction information.", +"Indicates that the user was served a 2FA challenge. An old assessment with `ENUM_VALUES.INITIATED_TWO_FACTOR` reason that has not been overwritten with `PASSED_TWO_FACTOR` is treated as an abandoned 2FA flow. This is equivalent to `FAILED_TWO_FACTOR`.", +"Indicates that the user passed a 2FA challenge.", +"Indicates that the user failed a 2FA challenge.", +"Indicates the user provided the correct password.", +"Indicates the user provided an incorrect password.", +"Indicates that the user sent unwanted and abusive messages to other users of the platform, such as spam, scams, phishing, or social engineering." +], +"type": "string" +}, +"type": "array" +}, +"transactionEvent": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TransactionEvent", +"description": "Optional. If the assessment is part of a payment transaction, provide details on payment lifecycle events that occur in the transaction." +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1AnnotateAssessmentResponse": { +"description": "Empty response for AnnotateAssessment.", +"id": "GoogleCloudRecaptchaenterpriseV1AnnotateAssessmentResponse", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1AppleDeveloperId": { +"description": "Contains fields that are required to perform Apple-specific integrity checks.", +"id": "GoogleCloudRecaptchaenterpriseV1AppleDeveloperId", +"properties": { +"keyId": { +"description": "Required. The Apple developer key ID (10-character string).", +"type": "string" +}, +"privateKey": { +"description": "Required. Input only. A private key (downloaded as a text file with a .p8 file extension) generated for your Apple Developer account. Ensure that Apple DeviceCheck is enabled for the private key.", +"type": "string" +}, +"teamId": { +"description": "Required. The Apple team ID (10-character string) owning the provisioning profile used to build your application.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1Assessment": { +"description": "A reCAPTCHA Enterprise assessment resource.", +"id": "GoogleCloudRecaptchaenterpriseV1Assessment", +"properties": { +"accountDefenderAssessment": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AccountDefenderAssessment", +"description": "Output only. Assessment returned by account defender when an account identifier is provided.", +"readOnly": true +}, +"accountVerification": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AccountVerificationInfo", +"description": "Optional. Account verification information for identity verification. The assessment event must include a token and site key to use this feature." +}, +"assessmentEnvironment": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AssessmentEnvironment", +"description": "Optional. The environment creating the assessment. This describes your environment (the system invoking CreateAssessment), NOT the environment of your user." +}, +"event": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Event", +"description": "Optional. The event being assessed." +}, +"firewallPolicyAssessment": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallPolicyAssessment", +"description": "Output only. Assessment returned when firewall policies belonging to the project are evaluated using the field firewall_policy_evaluation.", +"readOnly": true +}, +"fraudPreventionAssessment": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessment", +"description": "Output only. Assessment returned by Fraud Prevention when TransactionData is provided.", +"readOnly": true +}, +"fraudSignals": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FraudSignals", +"description": "Output only. Fraud Signals specific to the users involved in a payment transaction.", +"readOnly": true +}, +"name": { +"description": "Output only. Identifier. The resource name for the Assessment in the format `projects/{project}/assessments/{assessment}`.", +"readOnly": true, +"type": "string" +}, +"phoneFraudAssessment": { +"$ref": "GoogleCloudRecaptchaenterpriseV1PhoneFraudAssessment", +"description": "Output only. Assessment returned when a site key, a token, and a phone number as `user_id` are provided. Account defender and SMS toll fraud protection need to be enabled.", +"readOnly": true +}, +"privatePasswordLeakVerification": { +"$ref": "GoogleCloudRecaptchaenterpriseV1PrivatePasswordLeakVerification", +"description": "Optional. The private password leak verification field contains the parameters that are used to to check for leaks privately without sharing user credentials." +}, +"riskAnalysis": { +"$ref": "GoogleCloudRecaptchaenterpriseV1RiskAnalysis", +"description": "Output only. The risk analysis result for the event being assessed.", +"readOnly": true +}, +"tokenProperties": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TokenProperties", +"description": "Output only. Properties of the provided event token.", +"readOnly": true +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1AssessmentEnvironment": { +"description": "The environment creating the assessment. This describes your environment (the system invoking CreateAssessment), NOT the environment of your user.", +"id": "GoogleCloudRecaptchaenterpriseV1AssessmentEnvironment", +"properties": { +"client": { +"description": "Optional. Identifies the client module initiating the CreateAssessment request. This can be the link to the client module's project. Examples include: - \"github.com/GoogleCloudPlatform/recaptcha-enterprise-google-tag-manager\" - \"cloud.google.com/recaptcha/docs/implement-waf-akamai\" - \"cloud.google.com/recaptcha/docs/implement-waf-cloudflare\" - \"wordpress.org/plugins/recaptcha-something\"", +"type": "string" +}, +"version": { +"description": "Optional. The version of the client module. For example, \"1.0.0\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ChallengeMetrics": { +"description": "Metrics related to challenges.", +"id": "GoogleCloudRecaptchaenterpriseV1ChallengeMetrics", +"properties": { +"failedCount": { +"description": "Count of submitted challenge solutions that were incorrect or otherwise deemed suspicious such that a subsequent challenge was triggered.", +"format": "int64", +"type": "string" +}, +"nocaptchaCount": { +"description": "Count of nocaptchas (successful verification without a challenge) issued.", +"format": "int64", +"type": "string" +}, +"pageloadCount": { +"description": "Count of reCAPTCHA checkboxes or badges rendered. This is mostly equivalent to a count of pageloads for pages that include reCAPTCHA.", +"format": "int64", +"type": "string" +}, +"passedCount": { +"description": "Count of nocaptchas (successful verification without a challenge) plus submitted challenge solutions that were correct and resulted in verification.", +"format": "int64", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1EndpointVerificationInfo": { +"description": "Information about a verification endpoint that can be used for 2FA.", +"id": "GoogleCloudRecaptchaenterpriseV1EndpointVerificationInfo", +"properties": { +"emailAddress": { +"description": "Email address for which to trigger a verification request.", +"type": "string" +}, +"lastVerificationTime": { +"description": "Output only. Timestamp of the last successful verification for the endpoint, if any.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"phoneNumber": { +"description": "Phone number for which to trigger a verification request. Should be given in E.164 format.", +"type": "string" +}, +"requestToken": { +"description": "Output only. Token to provide to the client to trigger endpoint verification. It must be used within 15 minutes.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1Event": { +"description": "The event being assessed.", +"id": "GoogleCloudRecaptchaenterpriseV1Event", +"properties": { +"expectedAction": { +"description": "Optional. The expected action for this type of event. This should be the same action provided at token generation time on client-side platforms already integrated with recaptcha enterprise.", +"type": "string" +}, +"express": { +"description": "Optional. Flag for a reCAPTCHA express request for an assessment without a token. If enabled, `site_key` must reference an Express site key.", +"type": "boolean" +}, +"firewallPolicyEvaluation": { +"description": "Optional. Flag for enabling firewall policy config assessment. If this flag is enabled, the firewall policy is evaluated and a suggested firewall action is returned in the response.", +"type": "boolean" +}, +"fraudPrevention": { +"description": "Optional. The Fraud Prevention setting for this assessment.", +"enum": [ +"FRAUD_PREVENTION_UNSPECIFIED", +"ENABLED", +"DISABLED" +], +"enumDescriptions": [ +"Default, unspecified setting. `fraud_prevention_assessment` is returned if `transaction_data` is present in `Event` and Fraud Prevention is enabled in the Google Cloud console.", +"Enable Fraud Prevention for this assessment, if Fraud Prevention is enabled in the Google Cloud console.", +"Disable Fraud Prevention for this assessment, regardless of Google Cloud console settings." +], +"type": "string" +}, +"hashedAccountId": { +"deprecated": true, +"description": "Optional. Deprecated: use `user_info.account_id` instead. Unique stable hashed user identifier for the request. The identifier must be hashed using hmac-sha256 with stable secret.", +"format": "byte", +"type": "string" +}, +"headers": { +"description": "Optional. HTTP header information about the request.", +"items": { +"type": "string" +}, +"type": "array" +}, +"ja3": { +"description": "Optional. JA3 fingerprint for SSL clients.", +"type": "string" +}, +"requestedUri": { +"description": "Optional. The URI resource the user requested that triggered an assessment.", +"type": "string" +}, +"siteKey": { +"description": "Optional. The site key that was used to invoke reCAPTCHA Enterprise on your site and generate the token.", +"type": "string" +}, +"token": { +"description": "Optional. The user response token provided by the reCAPTCHA Enterprise client-side integration on your site.", +"type": "string" +}, +"transactionData": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TransactionData", +"description": "Optional. Data describing a payment transaction to be assessed. Sending this data enables reCAPTCHA Enterprise Fraud Prevention and the FraudPreventionAssessment component in the response." +}, +"userAgent": { +"description": "Optional. The user agent present in the request from the user's device related to this event.", +"type": "string" +}, +"userInfo": { +"$ref": "GoogleCloudRecaptchaenterpriseV1UserInfo", +"description": "Optional. Information about the user that generates this event, when they can be identified. They are often identified through the use of an account for logged-in requests or login/registration requests, or by providing user identifiers for guest actions like checkout." +}, +"userIpAddress": { +"description": "Optional. The IP address in the request from the user's device related to this event.", +"type": "string" +}, +"wafTokenAssessment": { +"description": "Optional. Flag for running WAF token assessment. If enabled, the token must be specified, and have been created by a WAF-enabled key.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ExpressKeySettings": { +"description": "Settings specific to keys that can be used for reCAPTCHA Express.", +"id": "GoogleCloudRecaptchaenterpriseV1ExpressKeySettings", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallAction": { +"description": "An individual action. Each action represents what to do if a policy matches.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallAction", +"properties": { +"allow": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallActionAllowAction", +"description": "The user request did not match any policy and should be allowed access to the requested resource." +}, +"block": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallActionBlockAction", +"description": "This action denies access to a given page. The user gets an HTTP error code." +}, +"includeRecaptchaScript": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallActionIncludeRecaptchaScriptAction", +"description": "This action injects reCAPTCHA JavaScript code into the HTML page returned by the site backend." +}, +"redirect": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallActionRedirectAction", +"description": "This action redirects the request to a reCAPTCHA interstitial to attach a token." +}, +"setHeader": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallActionSetHeaderAction", +"description": "This action sets a custom header but allow the request to continue to the customer backend." +}, +"substitute": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallActionSubstituteAction", +"description": "This action transparently serves a different page to an offending user." +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallActionAllowAction": { +"description": "An allow action continues processing a request unimpeded.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallActionAllowAction", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallActionBlockAction": { +"description": "A block action serves an HTTP error code a prevents the request from hitting the backend.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallActionBlockAction", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallActionIncludeRecaptchaScriptAction": { +"description": "An include reCAPTCHA script action involves injecting reCAPTCHA JavaScript code into the HTML returned by the site backend. This reCAPTCHA script is tasked with collecting user signals on the requested web page, issuing tokens as a cookie within the site domain, and enabling their utilization in subsequent page requests.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallActionIncludeRecaptchaScriptAction", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallActionRedirectAction": { +"description": "A redirect action returns a 307 (temporary redirect) response, pointing the user to a reCAPTCHA interstitial page to attach a token.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallActionRedirectAction", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallActionSetHeaderAction": { +"description": "A set header action sets a header and forwards the request to the backend. This can be used to trigger custom protection implemented on the backend.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallActionSetHeaderAction", +"properties": { +"key": { +"description": "Optional. The header key to set in the request to the backend server.", +"type": "string" +}, +"value": { +"description": "Optional. The header value to set in the request to the backend server.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallActionSubstituteAction": { +"description": "A substitute action transparently serves a different page than the one requested.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallActionSubstituteAction", +"properties": { +"path": { +"description": "Optional. The address to redirect to. The target is a relative path in the current host. Example: \"/blog/404.html\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallPolicy": { +"description": "A FirewallPolicy represents a single matching pattern and resulting actions to take.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallPolicy", +"properties": { +"actions": { +"description": "Optional. The actions that the caller should take regarding user access. There should be at most one terminal action. A terminal action is any action that forces a response, such as `AllowAction`, `BlockAction` or `SubstituteAction`. Zero or more non-terminal actions such as `SetHeader` might be specified. A single policy can contain up to 16 actions.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallAction" +}, +"type": "array" +}, +"condition": { +"description": "Optional. A CEL (Common Expression Language) conditional expression that specifies if this policy applies to an incoming user request. If this condition evaluates to true and the requested path matched the path pattern, the associated actions should be executed by the caller. The condition string is checked for CEL syntax correctness on creation. For more information, see the [CEL spec](https://github.com/google/cel-spec) and its [language definition](https://github.com/google/cel-spec/blob/master/doc/langdef.md). A condition has a max length of 500 characters.", +"type": "string" +}, +"description": { +"description": "Optional. A description of what this policy aims to achieve, for convenience purposes. The description can at most include 256 UTF-8 characters.", +"type": "string" +}, +"name": { +"description": "Identifier. The resource name for the FirewallPolicy in the format `projects/{project}/firewallpolicies/{firewallpolicy}`.", +"type": "string" +}, +"path": { +"description": "Optional. The path for which this policy applies, specified as a glob pattern. For more information on glob, see the [manual page](https://man7.org/linux/man-pages/man7/glob.7.html). A path has a max length of 200 characters.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FirewallPolicyAssessment": { +"description": "Policy config assessment.", +"id": "GoogleCloudRecaptchaenterpriseV1FirewallPolicyAssessment", +"properties": { +"error": { +"$ref": "GoogleRpcStatus", +"description": "Output only. If the processing of a policy config fails, an error is populated and the firewall_policy is left empty.", +"readOnly": true +}, +"firewallPolicy": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallPolicy", +"description": "Output only. The policy that matched the request. If more than one policy may match, this is the first match. If no policy matches the incoming request, the policy field is left empty.", +"readOnly": true +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessment": { +"description": "Assessment for Fraud Prevention.", +"id": "GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessment", +"properties": { +"behavioralTrustVerdict": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentBehavioralTrustVerdict", +"description": "Output only. Assessment of this transaction for behavioral trust.", +"readOnly": true +}, +"cardTestingVerdict": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentCardTestingVerdict", +"description": "Output only. Assessment of this transaction for risk of being part of a card testing attack.", +"readOnly": true +}, +"stolenInstrumentVerdict": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentStolenInstrumentVerdict", +"description": "Output only. Assessment of this transaction for risk of a stolen instrument.", +"readOnly": true +}, +"transactionRisk": { +"description": "Output only. Probability of this transaction being fraudulent. Summarizes the combined risk of attack vectors below. Values are from 0.0 (lowest) to 1.0 (highest).", +"format": "float", +"readOnly": true, +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentBehavioralTrustVerdict": { +"description": "Information about behavioral trust of the transaction.", +"id": "GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentBehavioralTrustVerdict", +"properties": { +"trust": { +"description": "Output only. Probability of this transaction attempt being executed in a behaviorally trustworthy way. Values are from 0.0 (lowest) to 1.0 (highest).", +"format": "float", +"readOnly": true, +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentCardTestingVerdict": { +"description": "Information about card testing fraud, where an adversary is testing fraudulently obtained cards or brute forcing their details.", +"id": "GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentCardTestingVerdict", +"properties": { +"risk": { +"description": "Output only. Probability of this transaction attempt being part of a card testing attack. Values are from 0.0 (lowest) to 1.0 (highest).", +"format": "float", +"readOnly": true, +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentStolenInstrumentVerdict": { +"description": "Information about stolen instrument fraud, where the user is not the legitimate owner of the instrument being used for the purchase.", +"id": "GoogleCloudRecaptchaenterpriseV1FraudPreventionAssessmentStolenInstrumentVerdict", +"properties": { +"risk": { +"description": "Output only. Probability of this transaction being executed with a stolen instrument. Values are from 0.0 (lowest) to 1.0 (highest).", +"format": "float", +"readOnly": true, +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FraudSignals": { +"description": "Fraud signals describing users and cards involved in the transaction.", +"id": "GoogleCloudRecaptchaenterpriseV1FraudSignals", +"properties": { +"cardSignals": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FraudSignalsCardSignals", +"description": "Output only. Signals describing the payment card or cards used in this transaction.", +"readOnly": true +}, +"userSignals": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FraudSignalsUserSignals", +"description": "Output only. Signals describing the end user in this transaction.", +"readOnly": true +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FraudSignalsCardSignals": { +"description": "Signals describing the payment card used in this transaction.", +"id": "GoogleCloudRecaptchaenterpriseV1FraudSignalsCardSignals", +"properties": { +"cardLabels": { +"description": "Output only. The labels for the payment card in this transaction.", +"items": { +"enum": [ +"CARD_LABEL_UNSPECIFIED", +"PREPAID", +"VIRTUAL", +"UNEXPECTED_LOCATION" +], +"enumDescriptions": [ +"No label specified.", +"This card has been detected as prepaid.", +"This card has been detected as virtual, such as a card number generated for a single transaction or merchant.", +"This card has been detected as being used in an unexpected geographic location." +], +"type": "string" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1FraudSignalsUserSignals": { +"description": "Signals describing the user involved in this transaction.", +"id": "GoogleCloudRecaptchaenterpriseV1FraudSignalsUserSignals", +"properties": { +"activeDaysLowerBound": { +"description": "Output only. This user (based on email, phone, and other identifiers) has been seen on the internet for at least this number of days.", +"format": "int32", +"readOnly": true, +"type": "integer" +}, +"syntheticRisk": { +"description": "Output only. Likelihood (from 0.0 to 1.0) this user includes synthetic components in their identity, such as a randomly generated email address, temporary phone number, or fake shipping address.", +"format": "float", +"readOnly": true, +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1IOSKeySettings": { +"description": "Settings specific to keys that can be used by iOS apps.", +"id": "GoogleCloudRecaptchaenterpriseV1IOSKeySettings", +"properties": { +"allowAllBundleIds": { +"description": "Optional. If set to true, allowed_bundle_ids are not enforced.", +"type": "boolean" +}, +"allowedBundleIds": { +"description": "Optional. iOS bundle ids of apps allowed to use the key. Example: 'com.companyname.productname.appname'", +"items": { +"type": "string" +}, +"type": "array" +}, +"appleDeveloperId": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AppleDeveloperId", +"description": "Optional. Apple Developer account details for the app that is protected by the reCAPTCHA Key. reCAPTCHA leverages platform-specific checks like Apple App Attest and Apple DeviceCheck to protect your app from abuse. Providing these fields allows reCAPTCHA to get a better assessment of the integrity of your app." +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1IpOverrideData": { +"description": "Information about the IP or IP range override.", +"id": "GoogleCloudRecaptchaenterpriseV1IpOverrideData", +"properties": { +"ip": { +"description": "Required. The IP address to override (can be IPv4, IPv6 or CIDR). The IP override must be a valid IPv4 or IPv6 address, or a CIDR range. The IP override must be a public IP address. Example of IPv4: 168.192.5.6 Example of IPv6: 2001:0000:130F:0000:0000:09C0:876A:130B Example of IPv4 with CIDR: 168.192.5.0/24 Example of IPv6 with CIDR: 2001:0DB8:1234::/48", +"type": "string" +}, +"overrideType": { +"description": "Required. Describes the type of IP override.", +"enum": [ +"OVERRIDE_TYPE_UNSPECIFIED", +"ALLOW" +], +"enumDescriptions": [ +"Default override type that indicates this enum hasn't been specified.", +"Allowlist the IP address; i.e. give a `risk_analysis.score` of 0.9 for all valid assessments." +], +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1Key": { +"description": "A key used to identify and configure applications (web and/or mobile) that use reCAPTCHA Enterprise.", +"id": "GoogleCloudRecaptchaenterpriseV1Key", +"properties": { +"androidSettings": { +"$ref": "GoogleCloudRecaptchaenterpriseV1AndroidKeySettings", +"description": "Settings for keys that can be used by Android apps." +}, +"createTime": { +"description": "Output only. The timestamp corresponding to the creation of this key.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"displayName": { +"description": "Required. Human-readable display name of this key. Modifiable by user.", +"type": "string" +}, +"expressSettings": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ExpressKeySettings", +"description": "Settings for keys that can be used by reCAPTCHA Express." +}, +"iosSettings": { +"$ref": "GoogleCloudRecaptchaenterpriseV1IOSKeySettings", +"description": "Settings for keys that can be used by iOS apps." +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Optional. See [Creating and managing labels] (https://cloud.google.com/recaptcha/docs/labels).", +"type": "object" +}, +"name": { +"description": "Identifier. The resource name for the Key in the format `projects/{project}/keys/{key}`.", +"type": "string" +}, +"testingOptions": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TestingOptions", +"description": "Optional. Options for user acceptance testing." +}, +"wafSettings": { +"$ref": "GoogleCloudRecaptchaenterpriseV1WafSettings", +"description": "Optional. Settings for WAF" +}, +"webSettings": { +"$ref": "GoogleCloudRecaptchaenterpriseV1WebKeySettings", +"description": "Settings for keys that can be used by websites." +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ListFirewallPoliciesResponse": { +"description": "Response to request to list firewall policies belonging to a project.", +"id": "GoogleCloudRecaptchaenterpriseV1ListFirewallPoliciesResponse", +"properties": { +"firewallPolicies": { +"description": "Policy details.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1FirewallPolicy" +}, +"type": "array" +}, +"nextPageToken": { +"description": "Token to retrieve the next page of results. It is set to empty if no policies remain in results.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ListIpOverridesResponse": { +"description": "Response for ListIpOverrides.", +"id": "GoogleCloudRecaptchaenterpriseV1ListIpOverridesResponse", +"properties": { +"ipOverrides": { +"description": "IP Overrides details.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1IpOverrideData" +}, +"type": "array" +}, +"nextPageToken": { +"description": "Token to retrieve the next page of results. If this field is empty, no keys remain in the results.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ListKeysResponse": { +"description": "Response to request to list keys in a project.", +"id": "GoogleCloudRecaptchaenterpriseV1ListKeysResponse", +"properties": { +"keys": { +"description": "Key details.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1Key" +}, +"type": "array" +}, +"nextPageToken": { +"description": "Token to retrieve the next page of results. It is set to empty if no keys remain in results.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ListRelatedAccountGroupMembershipsResponse": { +"description": "The response to a `ListRelatedAccountGroupMemberships` call.", +"id": "GoogleCloudRecaptchaenterpriseV1ListRelatedAccountGroupMembershipsResponse", +"properties": { +"nextPageToken": { +"description": "A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.", +"type": "string" +}, +"relatedAccountGroupMemberships": { +"description": "The memberships listed by the query.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1RelatedAccountGroupMembership" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ListRelatedAccountGroupsResponse": { +"description": "The response to a `ListRelatedAccountGroups` call.", +"id": "GoogleCloudRecaptchaenterpriseV1ListRelatedAccountGroupsResponse", +"properties": { +"nextPageToken": { +"description": "A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.", +"type": "string" +}, +"relatedAccountGroups": { +"description": "The groups of related accounts listed by the query.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1RelatedAccountGroup" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1Metrics": { +"description": "Metrics for a single Key.", +"id": "GoogleCloudRecaptchaenterpriseV1Metrics", +"properties": { +"challengeMetrics": { +"description": "Metrics are continuous and in order by dates, and in the granularity of day. Only challenge-based keys (CHECKBOX, INVISIBLE) have challenge-based data.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ChallengeMetrics" +}, +"type": "array" +}, +"name": { +"description": "Output only. Identifier. The name of the metrics, in the format `projects/{project}/keys/{key}/metrics`.", +"readOnly": true, +"type": "string" +}, +"scoreMetrics": { +"description": "Metrics are continuous and in order by dates, and in the granularity of day. All Key types should have score-based data.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ScoreMetrics" +}, +"type": "array" +}, +"startTime": { +"description": "Inclusive start time aligned to a day (UTC).", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1MigrateKeyRequest": { +"description": "The migrate key request message.", +"id": "GoogleCloudRecaptchaenterpriseV1MigrateKeyRequest", +"properties": { +"skipBillingCheck": { +"description": "Optional. If true, skips the billing check. A reCAPTCHA Enterprise key or migrated key behaves differently than a reCAPTCHA (non-Enterprise version) key when you reach a quota limit (see https://cloud.google.com/recaptcha/quotas#quota_limit). To avoid any disruption of your usage, we check that a billing account is present. If your usage of reCAPTCHA is under the free quota, you can safely skip the billing check and proceed with the migration. See https://cloud.google.com/recaptcha/docs/billing-information.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1PhoneFraudAssessment": { +"description": "Assessment for Phone Fraud", +"id": "GoogleCloudRecaptchaenterpriseV1PhoneFraudAssessment", +"properties": { +"smsTollFraudVerdict": { +"$ref": "GoogleCloudRecaptchaenterpriseV1SmsTollFraudVerdict", +"description": "Output only. Assessment of this phone event for risk of SMS toll fraud.", +"readOnly": true +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1PrivatePasswordLeakVerification": { +"description": "Private password leak verification info.", +"id": "GoogleCloudRecaptchaenterpriseV1PrivatePasswordLeakVerification", +"properties": { +"encryptedLeakMatchPrefixes": { +"description": "Output only. List of prefixes of the encrypted potential password leaks that matched the given parameters. They must be compared with the client-side decryption prefix of `reencrypted_user_credentials_hash`", +"items": { +"format": "byte", +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"encryptedUserCredentialsHash": { +"description": "Optional. Encrypted Scrypt hash of the canonicalized username+password. It is re-encrypted by the server and returned through `reencrypted_user_credentials_hash`.", +"format": "byte", +"type": "string" +}, +"lookupHashPrefix": { +"description": "Required. Exactly 26-bit prefix of the SHA-256 hash of the canonicalized username. It is used to look up password leaks associated with that hash prefix.", +"format": "byte", +"type": "string" +}, +"reencryptedUserCredentialsHash": { +"description": "Output only. Corresponds to the re-encryption of the `encrypted_user_credentials_hash` field. It is used to match potential password leaks within `encrypted_leak_match_prefixes`.", +"format": "byte", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1RelatedAccountGroup": { +"description": "A group of related accounts.", +"id": "GoogleCloudRecaptchaenterpriseV1RelatedAccountGroup", +"properties": { +"name": { +"description": "Required. Identifier. The resource name for the related account group in the format `projects/{project}/relatedaccountgroups/{related_account_group}`.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1RelatedAccountGroupMembership": { +"description": "A membership in a group of related accounts.", +"id": "GoogleCloudRecaptchaenterpriseV1RelatedAccountGroupMembership", +"properties": { +"accountId": { +"description": "The unique stable account identifier of the member. The identifier corresponds to an `account_id` provided in a previous `CreateAssessment` or `AnnotateAssessment` call.", +"type": "string" +}, +"hashedAccountId": { +"deprecated": true, +"description": "Deprecated: use `account_id` instead. The unique stable hashed account identifier of the member. The identifier corresponds to a `hashed_account_id` provided in a previous `CreateAssessment` or `AnnotateAssessment` call.", +"format": "byte", +"type": "string" +}, +"name": { +"description": "Required. Identifier. The resource name for this membership in the format `projects/{project}/relatedaccountgroups/{relatedaccountgroup}/memberships/{membership}`.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1RemoveIpOverrideRequest": { +"description": "The RemoveIpOverride request message.", +"id": "GoogleCloudRecaptchaenterpriseV1RemoveIpOverrideRequest", +"properties": { +"ipOverrideData": { +"$ref": "GoogleCloudRecaptchaenterpriseV1IpOverrideData", +"description": "Required. IP override to be removed from the key." +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1RemoveIpOverrideResponse": { +"description": "Response for RemoveIpOverride.", +"id": "GoogleCloudRecaptchaenterpriseV1RemoveIpOverrideResponse", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ReorderFirewallPoliciesRequest": { +"description": "The reorder firewall policies request message.", +"id": "GoogleCloudRecaptchaenterpriseV1ReorderFirewallPoliciesRequest", +"properties": { +"names": { +"description": "Required. A list containing all policy names, in the new order. Each name is in the format `projects/{project}/firewallpolicies/{firewallpolicy}`.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ReorderFirewallPoliciesResponse": { +"description": "The reorder firewall policies response message.", +"id": "GoogleCloudRecaptchaenterpriseV1ReorderFirewallPoliciesResponse", +"properties": {}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1RetrieveLegacySecretKeyResponse": { +"description": "Secret key is used only in legacy reCAPTCHA. It must be used in a 3rd party integration with legacy reCAPTCHA.", +"id": "GoogleCloudRecaptchaenterpriseV1RetrieveLegacySecretKeyResponse", +"properties": { +"legacySecretKey": { +"description": "The secret key (also known as shared secret) authorizes communication between your application backend and the reCAPTCHA Enterprise server to create an assessment. The secret key needs to be kept safe for security purposes.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1RiskAnalysis": { +"description": "Risk analysis result for an event.", +"id": "GoogleCloudRecaptchaenterpriseV1RiskAnalysis", +"properties": { +"challenge": { +"description": "Output only. Challenge information for SCORE_AND_CHALLENGE and INVISIBLE keys", +"enum": [ +"CHALLENGE_UNSPECIFIED", +"NOCAPTCHA", +"PASSED", +"FAILED" +], +"enumDescriptions": [ +"Default unspecified type.", +"No challenge was presented for solving.", +"A solution was submitted that was correct.", +"A solution was submitted that was incorrect or otherwise deemed suspicious." +], +"readOnly": true, +"type": "string" +}, +"extendedVerdictReasons": { +"description": "Output only. Extended verdict reasons to be used for experimentation only. The set of possible reasons is subject to change.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"reasons": { +"description": "Output only. Reasons contributing to the risk analysis verdict.", +"items": { +"enum": [ +"CLASSIFICATION_REASON_UNSPECIFIED", +"AUTOMATION", +"UNEXPECTED_ENVIRONMENT", +"TOO_MUCH_TRAFFIC", +"UNEXPECTED_USAGE_PATTERNS", +"LOW_CONFIDENCE_SCORE", +"SUSPECTED_CARDING", +"SUSPECTED_CHARGEBACK" +], +"enumDescriptions": [ +"Default unspecified type.", +"Interactions matched the behavior of an automated agent.", +"The event originated from an illegitimate environment.", +"Traffic volume from the event source is higher than normal.", +"Interactions with the site were significantly different than expected patterns.", +"Too little traffic has been received from this site thus far to generate quality risk analysis.", +"The request matches behavioral characteristics of a carding attack.", +"The request matches behavioral characteristics of chargebacks for fraud." +], +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"score": { +"description": "Output only. Legitimate event score from 0.0 to 1.0. (1.0 means very likely legitimate traffic while 0.0 means very likely non-legitimate traffic).", +"format": "float", +"readOnly": true, +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ScoreDistribution": { +"description": "Score distribution.", +"id": "GoogleCloudRecaptchaenterpriseV1ScoreDistribution", +"properties": { +"scoreBuckets": { +"additionalProperties": { +"format": "int64", +"type": "string" +}, +"description": "Map key is score value multiplied by 100. The scores are discrete values between [0, 1]. The maximum number of buckets is on order of a few dozen, but typically much lower (ie. 10).", +"type": "object" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1ScoreMetrics": { +"description": "Metrics related to scoring.", +"id": "GoogleCloudRecaptchaenterpriseV1ScoreMetrics", +"properties": { +"actionMetrics": { +"additionalProperties": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ScoreDistribution" +}, +"description": "Action-based metrics. The map key is the action name which specified by the site owners at time of the \"execute\" client-side call.", +"type": "object" +}, +"overallMetrics": { +"$ref": "GoogleCloudRecaptchaenterpriseV1ScoreDistribution", +"description": "Aggregated score metrics for all traffic." +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1SearchRelatedAccountGroupMembershipsRequest": { +"description": "The request message to search related account group memberships.", +"id": "GoogleCloudRecaptchaenterpriseV1SearchRelatedAccountGroupMembershipsRequest", +"properties": { +"accountId": { +"description": "Optional. The unique stable account identifier used to search connections. The identifier should correspond to an `account_id` provided in a previous `CreateAssessment` or `AnnotateAssessment` call. Either hashed_account_id or account_id must be set, but not both.", +"type": "string" +}, +"hashedAccountId": { +"deprecated": true, +"description": "Optional. Deprecated: use `account_id` instead. The unique stable hashed account identifier used to search connections. The identifier should correspond to a `hashed_account_id` provided in a previous `CreateAssessment` or `AnnotateAssessment` call. Either hashed_account_id or account_id must be set, but not both.", +"format": "byte", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of groups to return. The service might return fewer than this value. If unspecified, at most 50 groups are returned. The maximum value is 1000; values above 1000 are coerced to 1000.", +"format": "int32", +"type": "integer" +}, +"pageToken": { +"description": "Optional. A page token, received from a previous `SearchRelatedAccountGroupMemberships` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `SearchRelatedAccountGroupMemberships` must match the call that provided the page token.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1SearchRelatedAccountGroupMembershipsResponse": { +"description": "The response to a `SearchRelatedAccountGroupMemberships` call.", +"id": "GoogleCloudRecaptchaenterpriseV1SearchRelatedAccountGroupMembershipsResponse", +"properties": { +"nextPageToken": { +"description": "A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.", +"type": "string" +}, +"relatedAccountGroupMemberships": { +"description": "The queried memberships.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1RelatedAccountGroupMembership" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1SmsTollFraudVerdict": { +"description": "Information about SMS toll fraud.", +"id": "GoogleCloudRecaptchaenterpriseV1SmsTollFraudVerdict", +"properties": { +"reasons": { +"description": "Output only. Reasons contributing to the SMS toll fraud verdict.", +"items": { +"enum": [ +"SMS_TOLL_FRAUD_REASON_UNSPECIFIED", +"INVALID_PHONE_NUMBER" +], +"enumDescriptions": [ +"Default unspecified reason", +"The provided phone number was invalid" +], +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"risk": { +"description": "Output only. Probability of an SMS event being fraudulent. Values are from 0.0 (lowest) to 1.0 (highest).", +"format": "float", +"readOnly": true, +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1TestingOptions": { +"description": "Options for user acceptance testing.", +"id": "GoogleCloudRecaptchaenterpriseV1TestingOptions", +"properties": { +"testingChallenge": { +"description": "Optional. For challenge-based keys only (CHECKBOX, INVISIBLE), all challenge requests for this site return nocaptcha if NOCAPTCHA, or an unsolvable challenge if CHALLENGE.", +"enum": [ +"TESTING_CHALLENGE_UNSPECIFIED", +"NOCAPTCHA", +"UNSOLVABLE_CHALLENGE" +], +"enumDescriptions": [ +"Perform the normal risk analysis and return either nocaptcha or a challenge depending on risk and trust factors.", +"Challenge requests for this key always return a nocaptcha, which does not require a solution.", +"Challenge requests for this key always return an unsolvable challenge." +], +"type": "string" +}, +"testingScore": { +"description": "Optional. All assessments for this Key return this score. Must be between 0 (likely not legitimate) and 1 (likely legitimate) inclusive.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1TokenProperties": { +"description": "Properties of the provided event token.", +"id": "GoogleCloudRecaptchaenterpriseV1TokenProperties", +"properties": { +"action": { +"description": "Output only. Action name provided at token generation.", +"readOnly": true, +"type": "string" +}, +"androidPackageName": { +"description": "Output only. The name of the Android package with which the token was generated (Android keys only).", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The timestamp corresponding to the generation of the token.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"hostname": { +"description": "Output only. The hostname of the page on which the token was generated (Web keys only).", +"readOnly": true, +"type": "string" +}, +"invalidReason": { +"description": "Output only. Reason associated with the response when valid = false.", +"enum": [ +"INVALID_REASON_UNSPECIFIED", +"UNKNOWN_INVALID_REASON", +"MALFORMED", +"EXPIRED", +"DUPE", +"MISSING", +"BROWSER_ERROR" +], +"enumDescriptions": [ +"Default unspecified type.", +"If the failure reason was not accounted for.", +"The provided user verification token was malformed.", +"The user verification token had expired.", +"The user verification had already been seen.", +"The user verification token was not present.", +"A retriable error (such as network failure) occurred on the browser. Could easily be simulated by an attacker." +], +"readOnly": true, +"type": "string" +}, +"iosBundleId": { +"description": "Output only. The ID of the iOS bundle with which the token was generated (iOS keys only).", +"readOnly": true, +"type": "string" +}, +"valid": { +"description": "Output only. Whether the provided user response token is valid. When valid = false, the reason could be specified in invalid_reason or it could also be due to a user failing to solve a challenge or a sitekey mismatch (i.e the sitekey used to generate the token was different than the one specified in the assessment).", +"readOnly": true, +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1TransactionData": { +"description": "Transaction data associated with a payment protected by reCAPTCHA Enterprise.", +"id": "GoogleCloudRecaptchaenterpriseV1TransactionData", +"properties": { +"billingAddress": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TransactionDataAddress", +"description": "Optional. Address associated with the payment method when applicable." +}, +"cardBin": { +"description": "Optional. The Bank Identification Number - generally the first 6 or 8 digits of the card.", +"type": "string" +}, +"cardLastFour": { +"description": "Optional. The last four digits of the card.", +"type": "string" +}, +"currencyCode": { +"description": "Optional. The currency code in ISO-4217 format.", +"type": "string" +}, +"gatewayInfo": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TransactionDataGatewayInfo", +"description": "Optional. Information about the payment gateway's response to the transaction." +}, +"items": { +"description": "Optional. Items purchased in this transaction.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TransactionDataItem" +}, +"type": "array" +}, +"merchants": { +"description": "Optional. Information about the user or users fulfilling the transaction.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TransactionDataUser" +}, +"type": "array" +}, +"paymentMethod": { +"description": "Optional. The payment method for the transaction. The allowed values are: * credit-card * debit-card * gift-card * processor-{name} (If a third-party is used, for example, processor-paypal) * custom-{name} (If an alternative method is used, for example, custom-crypto)", +"type": "string" +}, +"shippingAddress": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TransactionDataAddress", +"description": "Optional. Destination address if this transaction involves shipping a physical item." +}, +"shippingValue": { +"description": "Optional. The value of shipping in the specified currency. 0 for free or no shipping.", +"format": "double", +"type": "number" +}, +"transactionId": { +"description": "Unique identifier for the transaction. This custom identifier can be used to reference this transaction in the future, for example, labeling a refund or chargeback event. Two attempts at the same transaction should use the same transaction id.", +"type": "string" +}, +"user": { +"$ref": "GoogleCloudRecaptchaenterpriseV1TransactionDataUser", +"description": "Optional. Information about the user paying/initiating the transaction." +}, +"value": { +"description": "Optional. The decimal value of the transaction in the specified currency.", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1TransactionDataAddress": { +"description": "Structured address format for billing and shipping addresses.", +"id": "GoogleCloudRecaptchaenterpriseV1TransactionDataAddress", +"properties": { +"address": { +"description": "Optional. The first lines of the address. The first line generally contains the street name and number, and further lines may include information such as an apartment number.", +"items": { +"type": "string" +}, +"type": "array" +}, +"administrativeArea": { +"description": "Optional. The state, province, or otherwise administrative area of the address.", +"type": "string" +}, +"locality": { +"description": "Optional. The town/city of the address.", +"type": "string" +}, +"postalCode": { +"description": "Optional. The postal or ZIP code of the address.", +"type": "string" +}, +"recipient": { +"description": "Optional. The recipient name, potentially including information such as \"care of\".", +"type": "string" +}, +"regionCode": { +"description": "Optional. The CLDR country/region of the address.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1TransactionDataGatewayInfo": { +"description": "Details about the transaction from the gateway.", +"id": "GoogleCloudRecaptchaenterpriseV1TransactionDataGatewayInfo", +"properties": { +"avsResponseCode": { +"description": "Optional. AVS response code from the gateway (available only when reCAPTCHA Enterprise is called after authorization).", +"type": "string" +}, +"cvvResponseCode": { +"description": "Optional. CVV response code from the gateway (available only when reCAPTCHA Enterprise is called after authorization).", +"type": "string" +}, +"gatewayResponseCode": { +"description": "Optional. Gateway response code describing the state of the transaction.", +"type": "string" +}, +"name": { +"description": "Optional. Name of the gateway service (for example, stripe, square, paypal).", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1TransactionDataItem": { +"description": "Line items being purchased in this transaction.", +"id": "GoogleCloudRecaptchaenterpriseV1TransactionDataItem", +"properties": { +"merchantAccountId": { +"description": "Optional. When a merchant is specified, its corresponding account_id. Necessary to populate marketplace-style transactions.", +"type": "string" +}, +"name": { +"description": "Optional. The full name of the item.", +"type": "string" +}, +"quantity": { +"description": "Optional. The quantity of this item that is being purchased.", +"format": "int64", +"type": "string" +}, +"value": { +"description": "Optional. The value per item that the user is paying, in the transaction currency, after discounts.", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1TransactionDataUser": { +"description": "Details about a user's account involved in the transaction.", +"id": "GoogleCloudRecaptchaenterpriseV1TransactionDataUser", +"properties": { +"accountId": { +"description": "Optional. Unique account identifier for this user. If using account defender, this should match the hashed_account_id field. Otherwise, a unique and persistent identifier for this account.", +"type": "string" +}, +"creationMs": { +"description": "Optional. The epoch milliseconds of the user's account creation.", +"format": "int64", +"type": "string" +}, +"email": { +"description": "Optional. The email address of the user.", +"type": "string" +}, +"emailVerified": { +"description": "Optional. Whether the email has been verified to be accessible by the user (OTP or similar).", +"type": "boolean" +}, +"phoneNumber": { +"description": "Optional. The phone number of the user, with country code.", +"type": "string" +}, +"phoneVerified": { +"description": "Optional. Whether the phone number has been verified to be accessible by the user (OTP or similar).", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1TransactionEvent": { +"description": "Describes an event in the lifecycle of a payment transaction.", +"id": "GoogleCloudRecaptchaenterpriseV1TransactionEvent", +"properties": { +"eventTime": { +"description": "Optional. Timestamp when this transaction event occurred; otherwise assumed to be the time of the API call.", +"format": "google-datetime", +"type": "string" +}, +"eventType": { +"description": "Optional. The type of this transaction event.", +"enum": [ +"TRANSACTION_EVENT_TYPE_UNSPECIFIED", +"MERCHANT_APPROVE", +"MERCHANT_DENY", +"MANUAL_REVIEW", +"AUTHORIZATION", +"AUTHORIZATION_DECLINE", +"PAYMENT_CAPTURE", +"PAYMENT_CAPTURE_DECLINE", +"CANCEL", +"CHARGEBACK_INQUIRY", +"CHARGEBACK_ALERT", +"FRAUD_NOTIFICATION", +"CHARGEBACK", +"CHARGEBACK_REPRESENTMENT", +"CHARGEBACK_REVERSE", +"REFUND_REQUEST", +"REFUND_DECLINE", +"REFUND", +"REFUND_REVERSE" +], +"enumDescriptions": [ +"Default, unspecified event type.", +"Indicates that the transaction is approved by the merchant. The accompanying reasons can include terms such as 'INHOUSE', 'ACCERTIFY', 'CYBERSOURCE', or 'MANUAL_REVIEW'.", +"Indicates that the transaction is denied and concluded due to risks detected by the merchant. The accompanying reasons can include terms such as 'INHOUSE', 'ACCERTIFY', 'CYBERSOURCE', or 'MANUAL_REVIEW'.", +"Indicates that the transaction is being evaluated by a human, due to suspicion or risk.", +"Indicates that the authorization attempt with the card issuer succeeded.", +"Indicates that the authorization attempt with the card issuer failed. The accompanying reasons can include Visa's '54' indicating that the card is expired, or '82' indicating that the CVV is incorrect.", +"Indicates that the transaction is completed because the funds were settled.", +"Indicates that the transaction could not be completed because the funds were not settled.", +"Indicates that the transaction has been canceled. Specify the reason for the cancellation. For example, 'INSUFFICIENT_INVENTORY'.", +"Indicates that the merchant has received a chargeback inquiry due to fraud for the transaction, requesting additional information before a fraud chargeback is officially issued and a formal chargeback notification is sent.", +"Indicates that the merchant has received a chargeback alert due to fraud for the transaction. The process of resolving the dispute without involving the payment network is started.", +"Indicates that a fraud notification is issued for the transaction, sent by the payment instrument's issuing bank because the transaction appears to be fraudulent. We recommend including TC40 or SAFE data in the `reason` field for this event type. For partial chargebacks, we recommend that you include an amount in the `value` field.", +"Indicates that the merchant is informed by the payment network that the transaction has entered the chargeback process due to fraud. Reason code examples include Discover's '6005' and '6041'. For partial chargebacks, we recommend that you include an amount in the `value` field.", +"Indicates that the transaction has entered the chargeback process due to fraud, and that the merchant has chosen to enter representment. Reason examples include Discover's '6005' and '6041'. For partial chargebacks, we recommend that you include an amount in the `value` field.", +"Indicates that the transaction has had a fraud chargeback which was illegitimate and was reversed as a result. For partial chargebacks, we recommend that you include an amount in the `value` field.", +"Indicates that the merchant has received a refund for a completed transaction. For partial refunds, we recommend that you include an amount in the `value` field. Reason example: 'TAX_EXEMPT' (partial refund of exempt tax)", +"Indicates that the merchant has received a refund request for this transaction, but that they have declined it. For partial refunds, we recommend that you include an amount in the `value` field. Reason example: 'TAX_EXEMPT' (partial refund of exempt tax)", +"Indicates that the completed transaction was refunded by the merchant. For partial refunds, we recommend that you include an amount in the `value` field. Reason example: 'TAX_EXEMPT' (partial refund of exempt tax)", +"Indicates that the completed transaction was refunded by the merchant, and that this refund was reversed. For partial refunds, we recommend that you include an amount in the `value` field." +], +"type": "string" +}, +"reason": { +"description": "Optional. The reason or standardized code that corresponds with this transaction event, if one exists. For example, a CHARGEBACK event with code 6005.", +"type": "string" +}, +"value": { +"description": "Optional. The value that corresponds with this transaction event, if one exists. For example, a refund event where $5.00 was refunded. Currency is obtained from the original transaction data.", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1UserId": { +"description": "An identifier associated with a user.", +"id": "GoogleCloudRecaptchaenterpriseV1UserId", +"properties": { +"email": { +"description": "Optional. An email address.", +"type": "string" +}, +"phoneNumber": { +"description": "Optional. A phone number. Should use the E.164 format.", +"type": "string" +}, +"username": { +"description": "Optional. A unique username, if different from all the other identifiers and `account_id` that are provided. Can be a unique login handle or display name for a user.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1UserInfo": { +"description": "User information associated with a request protected by reCAPTCHA Enterprise.", +"id": "GoogleCloudRecaptchaenterpriseV1UserInfo", +"properties": { +"accountId": { +"description": "Optional. For logged-in requests or login/registration requests, the unique account identifier associated with this user. You can use the username if it is stable (meaning it is the same for every request associated with the same user), or any stable user ID of your choice. Leave blank for non logged-in actions or guest checkout.", +"type": "string" +}, +"createAccountTime": { +"description": "Optional. Creation time for this account associated with this user. Leave blank for non logged-in actions, guest checkout, or when there is no account associated with the current user.", +"format": "google-datetime", +"type": "string" +}, +"userIds": { +"description": "Optional. Identifiers associated with this user or request.", +"items": { +"$ref": "GoogleCloudRecaptchaenterpriseV1UserId" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1WafSettings": { +"description": "Settings specific to keys that can be used for WAF (Web Application Firewall).", +"id": "GoogleCloudRecaptchaenterpriseV1WafSettings", +"properties": { +"wafFeature": { +"description": "Required. The WAF feature for which this key is enabled.", +"enum": [ +"WAF_FEATURE_UNSPECIFIED", +"CHALLENGE_PAGE", +"SESSION_TOKEN", +"ACTION_TOKEN", +"EXPRESS" +], +"enumDescriptions": [ +"Undefined feature.", +"Redirects suspicious traffic to reCAPTCHA.", +"Use reCAPTCHA session-tokens to protect the whole user session on the site's domain.", +"Use reCAPTCHA action-tokens to protect user actions.", +"Use reCAPTCHA WAF express protection to protect any content other than web pages, like APIs and IoT devices." +], +"type": "string" +}, +"wafService": { +"description": "Required. The WAF service that uses this key.", +"enum": [ +"WAF_SERVICE_UNSPECIFIED", +"CA", +"FASTLY", +"CLOUDFLARE", +"AKAMAI" +], +"enumDescriptions": [ +"Undefined WAF", +"Cloud Armor", +"Fastly", +"Cloudflare", +"Akamai" +], +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudRecaptchaenterpriseV1WebKeySettings": { +"description": "Settings specific to keys that can be used by websites.", +"id": "GoogleCloudRecaptchaenterpriseV1WebKeySettings", +"properties": { +"allowAllDomains": { +"description": "Optional. If set to true, it means allowed_domains are not enforced.", +"type": "boolean" +}, +"allowAmpTraffic": { +"description": "Optional. If set to true, the key can be used on AMP (Accelerated Mobile Pages) websites. This is supported only for the SCORE integration type.", +"type": "boolean" +}, +"allowedDomains": { +"description": "Optional. Domains or subdomains of websites allowed to use the key. All subdomains of an allowed domain are automatically allowed. A valid domain requires a host and must not include any path, port, query or fragment. Examples: 'example.com' or 'subdomain.example.com'", +"items": { +"type": "string" +}, +"type": "array" +}, +"challengeSecurityPreference": { +"description": "Optional. Settings for the frequency and difficulty at which this key triggers captcha challenges. This should only be specified for IntegrationTypes CHECKBOX and INVISIBLE and SCORE_AND_CHALLENGE.", +"enum": [ +"CHALLENGE_SECURITY_PREFERENCE_UNSPECIFIED", +"USABILITY", +"BALANCE", +"SECURITY" +], +"enumDescriptions": [ +"Default type that indicates this enum hasn't been specified.", +"Key tends to show fewer and easier challenges.", +"Key tends to show balanced (in amount and difficulty) challenges.", +"Key tends to show more and harder challenges." +], +"type": "string" +}, +"integrationType": { +"description": "Required. Describes how this key is integrated with the website.", +"enum": [ +"INTEGRATION_TYPE_UNSPECIFIED", +"SCORE", +"CHECKBOX", +"INVISIBLE" +], +"enumDescriptions": [ +"Default type that indicates this enum hasn't been specified. This is not a valid IntegrationType, one of the other types must be specified instead.", +"Only used to produce scores. It doesn't display the \"I'm not a robot\" checkbox and never shows captcha challenges.", +"Displays the \"I'm not a robot\" checkbox and may show captcha challenges after it is checked.", +"Doesn't display the \"I'm not a robot\" checkbox, but may show captcha challenges after risk analysis." +], +"type": "string" +} +}, +"type": "object" +}, +"GoogleProtobufEmpty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "GoogleProtobufEmpty", +"properties": {}, +"type": "object" +}, +"GoogleRpcStatus": { +"description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", +"id": "GoogleRpcStatus", +"properties": { +"code": { +"description": "The status code, which should be an enum value of google.rpc.Code.", +"format": "int32", +"type": "integer" +}, +"details": { +"description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", +"items": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"type": "object" +}, +"type": "array" +}, +"message": { +"description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "reCAPTCHA Enterprise API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/spanner.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/spanner.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..8f391aebc8abc5df972f7094144256b85c0c5ef8 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/spanner.v1.json @@ -0,0 +1,7464 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +}, +"https://www.googleapis.com/auth/spanner.admin": { +"description": "Administer your Spanner databases" +}, +"https://www.googleapis.com/auth/spanner.data": { +"description": "View and manage the contents of your Spanner databases" +} +} +} +}, +"basePath": "", +"baseUrl": "https://spanner.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Spanner", +"description": "Cloud Spanner is a managed, mission-critical, globally consistent and scalable relational database service.", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/spanner/", +"endpoints": [ +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.europe-west8.rep.googleapis.com/", +"location": "europe-west8" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.me-central2.rep.googleapis.com/", +"location": "me-central2" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-central1.rep.googleapis.com/", +"location": "us-central1" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-central2.rep.googleapis.com/", +"location": "us-central2" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-east1.rep.googleapis.com/", +"location": "us-east1" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-east4.rep.googleapis.com/", +"location": "us-east4" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-east5.rep.googleapis.com/", +"location": "us-east5" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-east7.rep.googleapis.com/", +"location": "us-east7" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-south1.rep.googleapis.com/", +"location": "us-south1" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-west1.rep.googleapis.com/", +"location": "us-west1" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-west2.rep.googleapis.com/", +"location": "us-west2" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-west3.rep.googleapis.com/", +"location": "us-west3" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-west4.rep.googleapis.com/", +"location": "us-west4" +}, +{ +"description": "Regional Endpoint", +"endpointUrl": "https://spanner.us-west8.rep.googleapis.com/", +"location": "us-west8" +} +], +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "spanner:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://spanner.mtls.googleapis.com/", +"name": "spanner", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"projects": { +"resources": { +"instanceConfigOperations": { +"methods": { +"list": { +"description": "Lists the user-managed instance configuration long-running operations in the given project. An instance configuration operation has a name of the form `projects//instanceConfigs//operations/`. The long-running operation metadata field type `metadata.type_url` describes the type of the metadata. Operations returned include those that have completed/failed/canceled within the last 7 days, and pending operations. Operations returned are ordered by `operation.metadata.value.start_time` in descending order starting from the most recently started operation.", +"flatPath": "v1/projects/{projectsId}/instanceConfigOperations", +"httpMethod": "GET", +"id": "spanner.projects.instanceConfigOperations.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of returned operations. A filter expression consists of a field name, a comparison operator, and a value for filtering. The value must be a string, a number, or a boolean. The comparison operator must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`. Colon `:` is the contains operator. Filter rules are not case sensitive. The following fields in the Operation are eligible for filtering: * `name` - The name of the long-running operation * `done` - False if the operation is in progress, else true. * `metadata.@type` - the type of metadata. For example, the type string for CreateInstanceConfigMetadata is `type.googleapis.com/google.spanner.admin.instance.v1.CreateInstanceConfigMetadata`. * `metadata.` - any field in metadata.value. `metadata.@type` must be specified first, if filtering on metadata fields. * `error` - Error associated with the long-running operation. * `response.@type` - the type of response. * `response.` - any field in response.value. You can combine multiple expressions by enclosing each expression in parentheses. By default, expressions are combined with AND logic. However, you can specify AND, OR, and NOT logic explicitly. Here are a few examples: * `done:true` - The operation is complete. * `(metadata.@type=` \\ `type.googleapis.com/google.spanner.admin.instance.v1.CreateInstanceConfigMetadata) AND` \\ `(metadata.instance_config.name:custom-config) AND` \\ `(metadata.progress.start_time < \\\"2021-03-28T14:50:00Z\\\") AND` \\ `(error:*)` - Return operations where: * The operation's metadata type is CreateInstanceConfigMetadata. * The instance configuration name contains \"custom-config\". * The operation started before 2021-03-28T14:50:00Z. * The operation resulted in an error.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Number of operations to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListInstanceConfigOperationsResponse to the same `parent` and with the same `filter`.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The project of the instance configuration operations. Values are of the form `projects/`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/instanceConfigOperations", +"response": { +"$ref": "ListInstanceConfigOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +}, +"instanceConfigs": { +"methods": { +"create": { +"description": "Creates an instance configuration and begins preparing it to be used. The returned long-running operation can be used to track the progress of preparing the new instance configuration. The instance configuration name is assigned by the caller. If the named instance configuration already exists, `CreateInstanceConfig` returns `ALREADY_EXISTS`. Immediately after the request returns: * The instance configuration is readable via the API, with all requested attributes. The instance configuration's reconciling field is set to true. Its state is `CREATING`. While the operation is pending: * Cancelling the operation renders the instance configuration immediately unreadable via the API. * Except for deleting the creating resource, all other attempts to modify the instance configuration are rejected. Upon completion of the returned operation: * Instances can be created using the instance configuration. * The instance configuration's reconciling field becomes false. Its state becomes `READY`. The returned long-running operation will have a name of the format `/operations/` and can be used to track creation of the instance configuration. The metadata field type is CreateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.create` permission on the resource parent.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs", +"httpMethod": "POST", +"id": "spanner.projects.instanceConfigs.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the project in which to create the instance configuration. Values are of the form `projects/`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/instanceConfigs", +"request": { +"$ref": "CreateInstanceConfigRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes the instance configuration. Deletion is only allowed when no instances are using the configuration. If any instances are using the configuration, returns `FAILED_PRECONDITION`. Only user-managed configurations can be deleted. Authorization requires `spanner.instanceConfigs.delete` permission on the resource name.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instanceConfigs.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"etag": { +"description": "Used for optimistic concurrency control as a way to help prevent simultaneous deletes of an instance configuration from overwriting each other. If not empty, the API only deletes the instance configuration when the etag provided matches the current status of the requested instance configuration. Otherwise, deletes the instance configuration without checking the current status of the requested instance configuration.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the instance configuration to be deleted. Values are of the form `projects//instanceConfigs/`", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+$", +"required": true, +"type": "string" +}, +"validateOnly": { +"description": "An option to validate, but not actually execute, a request, and provide the same response.", +"location": "query", +"type": "boolean" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets information about a particular instance configuration.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}", +"httpMethod": "GET", +"id": "spanner.projects.instanceConfigs.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the requested instance configuration. Values are of the form `projects//instanceConfigs/`.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "InstanceConfig" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists the supported instance configurations for a given project. Returns both Google-managed configurations and user-managed configurations.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs", +"httpMethod": "GET", +"id": "spanner.projects.instanceConfigs.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Number of instance configurations to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListInstanceConfigsResponse.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The name of the project for which a list of supported instance configurations is requested. Values are of the form `projects/`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/instanceConfigs", +"response": { +"$ref": "ListInstanceConfigsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"patch": { +"description": "Updates an instance configuration. The returned long-running operation can be used to track the progress of updating the instance. If the named instance configuration does not exist, returns `NOT_FOUND`. Only user-managed configurations can be updated. Immediately after the request returns: * The instance configuration's reconciling field is set to true. While the operation is pending: * Cancelling the operation sets its metadata's cancel_time. The operation is guaranteed to succeed at undoing all changes, after which point it terminates with a `CANCELLED` status. * All other attempts to modify the instance configuration are rejected. * Reading the instance configuration via the API continues to give the pre-request values. Upon completion of the returned operation: * Creating instances using the instance configuration uses the new values. * The new values of the instance configuration are readable via the API. * The instance configuration's reconciling field becomes false. The returned long-running operation will have a name of the format `/operations/` and can be used to track the instance configuration modification. The metadata field type is UpdateInstanceConfigMetadata. The response field type is InstanceConfig, if successful. Authorization requires `spanner.instanceConfigs.update` permission on the resource name.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}", +"httpMethod": "PATCH", +"id": "spanner.projects.instanceConfigs.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`. User instance configuration must start with `custom-`.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "UpdateInstanceConfigRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +}, +"resources": { +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "spanner.projects.instanceConfigs.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instanceConfigs.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "spanner.projects.instanceConfigs.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}/operations", +"httpMethod": "GET", +"id": "spanner.projects.instanceConfigs.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+/operations$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +}, +"ssdCaches": { +"resources": { +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}/ssdCaches/{ssdCachesId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "spanner.projects.instanceConfigs.ssdCaches.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+/ssdCaches/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}/ssdCaches/{ssdCachesId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instanceConfigs.ssdCaches.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+/ssdCaches/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}/ssdCaches/{ssdCachesId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "spanner.projects.instanceConfigs.ssdCaches.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+/ssdCaches/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instanceConfigs/{instanceConfigsId}/ssdCaches/{ssdCachesId}/operations", +"httpMethod": "GET", +"id": "spanner.projects.instanceConfigs.ssdCaches.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/instanceConfigs/[^/]+/ssdCaches/[^/]+/operations$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +} +} +} +} +}, +"instances": { +"methods": { +"create": { +"description": "Creates an instance and begins preparing it to begin serving. The returned long-running operation can be used to track the progress of preparing the new instance. The instance name is assigned by the caller. If the named instance already exists, `CreateInstance` returns `ALREADY_EXISTS`. Immediately upon completion of this request: * The instance is readable via the API, with all requested attributes but no allocated resources. Its state is `CREATING`. Until completion of the returned operation: * Cancelling the operation renders the instance immediately unreadable via the API. * The instance can be deleted. * All other attempts to modify the instance are rejected. Upon completion of the returned operation: * Billing for all successfully-allocated resources begins (some types may have lower than the requested levels). * Databases can be created in the instance. * The instance's allocated resource levels are readable via the API. * The instance's state becomes `READY`. The returned long-running operation will have a name of the format `/operations/` and can be used to track creation of the instance. The metadata field type is CreateInstanceMetadata. The response field type is Instance, if successful.", +"flatPath": "v1/projects/{projectsId}/instances", +"httpMethod": "POST", +"id": "spanner.projects.instances.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the project in which to create the instance. Values are of the form `projects/`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/instances", +"request": { +"$ref": "CreateInstanceRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes an instance. Immediately upon completion of the request: * Billing ceases for all of the instance's reserved resources. Soon afterward: * The instance and *all of its databases* immediately and irrevocably disappear from the API. All data in the databases is permanently deleted.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the instance to be deleted. Values are of the form `projects//instances/`", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets information about a particular instance.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.get", +"parameterOrder": [ +"name" +], +"parameters": { +"fieldMask": { +"description": "If field_mask is present, specifies the subset of Instance fields that should be returned. If absent, all Instance fields are returned.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the requested instance. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Instance" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for an instance resource. Returns an empty policy if an instance exists but does not have a policy set. Authorization requires `spanner.instances.getIamPolicy` on resource.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}:getIamPolicy", +"httpMethod": "POST", +"id": "spanner.projects.instances.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which the policy is being retrieved. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"request": { +"$ref": "GetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists all instances in the given project.", +"flatPath": "v1/projects/{projectsId}/instances", +"httpMethod": "GET", +"id": "spanner.projects.instances.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression for filtering the results of the request. Filter rules are case insensitive. The fields eligible for filtering are: * `name` * `display_name` * `labels.key` where key is the name of a label Some examples of using filters are: * `name:*` --> The instance has a name. * `name:Howl` --> The instance's name contains the string \"howl\". * `name:HOWL` --> Equivalent to above. * `NAME:howl` --> Equivalent to above. * `labels.env:*` --> The instance has the label \"env\". * `labels.env:dev` --> The instance has the label \"env\" and the value of the label contains the string \"dev\". * `name:howl labels.env:dev` --> The instance's name contains \"howl\" and it has the label \"env\" with its value containing \"dev\".", +"location": "query", +"type": "string" +}, +"instanceDeadline": { +"description": "Deadline used while retrieving metadata for instances. Instances whose metadata cannot be retrieved within this deadline will be added to unreachable in ListInstancesResponse.", +"format": "google-datetime", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Number of instances to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListInstancesResponse.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The name of the project for which a list of instances is requested. Values are of the form `projects/`.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/instances", +"response": { +"$ref": "ListInstancesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"move": { +"description": "Moves an instance to the target instance configuration. You can use the returned long-running operation to track the progress of moving the instance. `MoveInstance` returns `FAILED_PRECONDITION` if the instance meets any of the following criteria: * Is undergoing a move to a different instance configuration * Has backups * Has an ongoing update * Contains any CMEK-enabled databases * Is a free trial instance While the operation is pending: * All other attempts to modify the instance, including changes to its compute capacity, are rejected. * The following database and backup admin operations are rejected: * `DatabaseAdmin.CreateDatabase` * `DatabaseAdmin.UpdateDatabaseDdl` (disabled if default_leader is specified in the request.) * `DatabaseAdmin.RestoreDatabase` * `DatabaseAdmin.CreateBackup` * `DatabaseAdmin.CopyBackup` * Both the source and target instance configurations are subject to hourly compute and storage charges. * The instance might experience higher read-write latencies and a higher transaction abort rate. However, moving an instance doesn't cause any downtime. The returned long-running operation has a name of the format `/operations/` and can be used to track the move instance operation. The metadata field type is MoveInstanceMetadata. The response field type is Instance, if successful. Cancelling the operation sets its metadata's cancel_time. Cancellation is not immediate because it involves moving any data previously moved to the target instance configuration back to the original instance configuration. You can use this operation to track the progress of the cancellation. Upon successful completion of the cancellation, the operation terminates with `CANCELLED` status. If not cancelled, upon completion of the returned operation: * The instance successfully moves to the target instance configuration. * You are billed for compute and storage in target instance configuration. Authorization requires the `spanner.instances.update` permission on the resource instance. For more details, see [Move an instance](https://cloud.google.com/spanner/docs/move-instance).", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}:move", +"httpMethod": "POST", +"id": "spanner.projects.instances.move", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The instance to move. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:move", +"request": { +"$ref": "MoveInstanceRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"patch": { +"description": "Updates an instance, and begins allocating or releasing resources as requested. The returned long-running operation can be used to track the progress of updating the instance. If the named instance does not exist, returns `NOT_FOUND`. Immediately upon completion of this request: * For resource types for which a decrease in the instance's allocation has been requested, billing is based on the newly-requested level. Until completion of the returned operation: * Cancelling the operation sets its metadata's cancel_time, and begins restoring resources to their pre-request values. The operation is guaranteed to succeed at undoing all resource changes, after which point it terminates with a `CANCELLED` status. * All other attempts to modify the instance are rejected. * Reading the instance via the API continues to give the pre-request resource levels. Upon completion of the returned operation: * Billing begins for all successfully-allocated resources (some types may have lower than the requested levels). * All newly-reserved resources are available for serving the instance's tables. * The instance's new resource levels are readable via the API. The returned long-running operation will have a name of the format `/operations/` and can be used to track the instance modification. The metadata field type is UpdateInstanceMetadata. The response field type is Instance, if successful. Authorization requires `spanner.instances.update` permission on the resource name.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}", +"httpMethod": "PATCH", +"id": "spanner.projects.instances.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A unique identifier for the instance, which cannot be changed after the instance is created. Values are of the form `projects//instances/a-z*[a-z0-9]`. The final segment of the name must be between 2 and 64 characters in length.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "UpdateInstanceRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on an instance resource. Replaces any existing policy. Authorization requires `spanner.instances.setIamPolicy` on resource.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}:setIamPolicy", +"httpMethod": "POST", +"id": "spanner.projects.instances.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which the policy is being set. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for databases resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"testIamPermissions": { +"description": "Returns permissions that the caller has on the specified instance resource. Attempting this RPC on a non-existent Cloud Spanner instance resource will result in a NOT_FOUND error if the user has `spanner.instances.list` permission on the containing Google Cloud Project. Otherwise returns an empty set of permissions.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}:testIamPermissions", +"httpMethod": "POST", +"id": "spanner.projects.instances.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which permissions are being tested. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +}, +"resources": { +"backupOperations": { +"methods": { +"list": { +"description": "Lists the backup long-running operations in the given instance. A backup operation has a name of the form `projects//instances//backups//operations/`. The long-running operation metadata field type `metadata.type_url` describes the type of the metadata. Operations returned include those that have completed/failed/canceled within the last 7 days, and pending operations. Operations returned are ordered by `operation.metadata.value.progress.start_time` in descending order starting from the most recently started operation.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backupOperations", +"httpMethod": "GET", +"id": "spanner.projects.instances.backupOperations.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of returned backup operations. A filter expression consists of a field name, a comparison operator, and a value for filtering. The value must be a string, a number, or a boolean. The comparison operator must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`. Colon `:` is the contains operator. Filter rules are not case sensitive. The following fields in the operation are eligible for filtering: * `name` - The name of the long-running operation * `done` - False if the operation is in progress, else true. * `metadata.@type` - the type of metadata. For example, the type string for CreateBackupMetadata is `type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata`. * `metadata.` - any field in metadata.value. `metadata.@type` must be specified first if filtering on metadata fields. * `error` - Error associated with the long-running operation. * `response.@type` - the type of response. * `response.` - any field in response.value. You can combine multiple expressions by enclosing each expression in parentheses. By default, expressions are combined with AND logic, but you can specify AND, OR, and NOT logic explicitly. Here are a few examples: * `done:true` - The operation is complete. * `(metadata.@type=type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) AND` \\ `metadata.database:prod` - Returns operations where: * The operation's metadata type is CreateBackupMetadata. * The source database name of backup contains the string \"prod\". * `(metadata.@type=type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) AND` \\ `(metadata.name:howl) AND` \\ `(metadata.progress.start_time < \\\"2018-03-28T14:50:00Z\\\") AND` \\ `(error:*)` - Returns operations where: * The operation's metadata type is CreateBackupMetadata. * The backup name contains the string \"howl\". * The operation started before 2018-03-28T14:50:00Z. * The operation resulted in an error. * `(metadata.@type=type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) AND` \\ `(metadata.source_backup:test) AND` \\ `(metadata.progress.start_time < \\\"2022-01-18T14:50:00Z\\\") AND` \\ `(error:*)` - Returns operations where: * The operation's metadata type is CopyBackupMetadata. * The source backup name contains the string \"test\". * The operation started before 2022-01-18T14:50:00Z. * The operation resulted in an error. * `((metadata.@type=type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) AND` \\ `(metadata.database:test_db)) OR` \\ `((metadata.@type=type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) AND` \\ `(metadata.source_backup:test_bkp)) AND` \\ `(error:*)` - Returns operations where: * The operation's metadata matches either of criteria: * The operation's metadata type is CreateBackupMetadata AND the source database name of the backup contains the string \"test_db\" * The operation's metadata type is CopyBackupMetadata AND the source backup name contains the string \"test_bkp\" * The operation resulted in an error.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Number of operations to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListBackupOperationsResponse to the same `parent` and with the same `filter`.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The instance of the backup operations. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/backupOperations", +"response": { +"$ref": "ListBackupOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +}, +"backups": { +"methods": { +"copy": { +"description": "Starts copying a Cloud Spanner Backup. The returned backup long-running operation will have a name of the format `projects//instances//backups//operations/` and can be used to track copying of the backup. The operation is associated with the destination backup. The metadata field type is CopyBackupMetadata. The response field type is Backup, if successful. Cancelling the returned operation will stop the copying and delete the destination backup. Concurrent CopyBackup requests can run on the same source backup.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups:copy", +"httpMethod": "POST", +"id": "spanner.projects.instances.backups.copy", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the destination instance that will contain the backup copy. Values are of the form: `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/backups:copy", +"request": { +"$ref": "CopyBackupRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"create": { +"description": "Starts creating a new Cloud Spanner Backup. The returned backup long-running operation will have a name of the format `projects//instances//backups//operations/` and can be used to track creation of the backup. The metadata field type is CreateBackupMetadata. The response field type is Backup, if successful. Cancelling the returned operation will stop the creation and delete the backup. There can be only one pending backup creation per database. Backup creation of different databases can run concurrently.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups", +"httpMethod": "POST", +"id": "spanner.projects.instances.backups.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"backupId": { +"description": "Required. The id of the backup to be created. The `backup_id` appended to `parent` forms the full backup name of the form `projects//instances//backups/`.", +"location": "query", +"type": "string" +}, +"encryptionConfig.encryptionType": { +"description": "Required. The encryption type of the backup.", +"enum": [ +"ENCRYPTION_TYPE_UNSPECIFIED", +"USE_DATABASE_ENCRYPTION", +"GOOGLE_DEFAULT_ENCRYPTION", +"CUSTOMER_MANAGED_ENCRYPTION" +], +"enumDescriptions": [ +"Unspecified. Do not use.", +"Use the same encryption configuration as the database. This is the default option when encryption_config is empty. For example, if the database is using `Customer_Managed_Encryption`, the backup will be using the same Cloud KMS key as the database.", +"Use Google default encryption.", +"Use customer managed encryption. If specified, `kms_key_name` must contain a valid Cloud KMS key." +], +"location": "query", +"type": "string" +}, +"encryptionConfig.kmsKeyName": { +"description": "Optional. The Cloud KMS key that will be used to protect the backup. This field should be set only when encryption_type is `CUSTOMER_MANAGED_ENCRYPTION`. Values are of the form `projects//locations//keyRings//cryptoKeys/`.", +"location": "query", +"type": "string" +}, +"encryptionConfig.kmsKeyNames": { +"description": "Optional. Specifies the KMS configuration for the one or more keys used to protect the backup. Values are of the form `projects//locations//keyRings//cryptoKeys/`. The keys referenced by `kms_key_names` must fully cover all regions of the backup's instance configuration. Some examples: * For regional (single-region) instance configurations, specify a regional location KMS key. * For multi-region instance configurations of type `GOOGLE_MANAGED`, either specify a multi-region location KMS key or multiple regional location KMS keys that cover all regions in the instance configuration. * For an instance configuration of type `USER_MANAGED`, specify only regional location KMS keys to cover each region in the instance configuration. Multi-region location KMS keys aren't supported for `USER_MANAGED` type instance configurations.", +"location": "query", +"repeated": true, +"type": "string" +}, +"parent": { +"description": "Required. The name of the instance in which the backup will be created. This must be the same instance that contains the database the backup will be created from. The backup will be stored in the location(s) specified in the instance configuration of this instance. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/backups", +"request": { +"$ref": "Backup" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes a pending or completed Backup.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.backups.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the backup to delete. Values are of the form `projects//instances//backups/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets metadata on a pending or completed Backup.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.backups.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the backup. Values are of the form `projects//instances//backups/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Backup" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a database or backup resource. Returns an empty policy if a database or backup exists but does not have a policy set. Authorization requires `spanner.databases.getIamPolicy` permission on resource. For backups, authorization requires `spanner.backups.getIamPolicy` permission on resource. For backup schedules, authorization requires `spanner.backupSchedules.getIamPolicy` permission on resource.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}:getIamPolicy", +"httpMethod": "POST", +"id": "spanner.projects.instances.backups.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which the policy is being retrieved. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"request": { +"$ref": "GetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists completed and pending backups. Backups returned are ordered by `create_time` in descending order, starting from the most recent `create_time`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups", +"httpMethod": "GET", +"id": "spanner.projects.instances.backups.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of returned backups. A filter expression consists of a field name, a comparison operator, and a value for filtering. The value must be a string, a number, or a boolean. The comparison operator must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`. Colon `:` is the contains operator. Filter rules are not case sensitive. The following fields in the Backup are eligible for filtering: * `name` * `database` * `state` * `create_time` (and values are of the format YYYY-MM-DDTHH:MM:SSZ) * `expire_time` (and values are of the format YYYY-MM-DDTHH:MM:SSZ) * `version_time` (and values are of the format YYYY-MM-DDTHH:MM:SSZ) * `size_bytes` * `backup_schedules` You can combine multiple expressions by enclosing each expression in parentheses. By default, expressions are combined with AND logic, but you can specify AND, OR, and NOT logic explicitly. Here are a few examples: * `name:Howl` - The backup's name contains the string \"howl\". * `database:prod` - The database's name contains the string \"prod\". * `state:CREATING` - The backup is pending creation. * `state:READY` - The backup is fully created and ready for use. * `(name:howl) AND (create_time < \\\"2018-03-28T14:50:00Z\\\")` - The backup name contains the string \"howl\" and `create_time` of the backup is before 2018-03-28T14:50:00Z. * `expire_time < \\\"2018-03-28T14:50:00Z\\\"` - The backup `expire_time` is before 2018-03-28T14:50:00Z. * `size_bytes > 10000000000` - The backup's size is greater than 10GB * `backup_schedules:daily` - The backup is created from a schedule with \"daily\" in its name.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Number of backups to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListBackupsResponse to the same `parent` and with the same `filter`.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The instance to list backups from. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/backups", +"response": { +"$ref": "ListBackupsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"patch": { +"description": "Updates a pending or completed Backup.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}", +"httpMethod": "PATCH", +"id": "spanner.projects.instances.backups.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Output only for the CreateBackup operation. Required for the UpdateBackup operation. A globally unique identifier for the backup which cannot be changed. Values are of the form `projects//instances//backups/a-z*[a-z0-9]` The final segment of the name must be between 2 and 60 characters in length. The backup is stored in the location(s) specified in the instance configuration of the instance containing the backup, identified by the prefix of the backup name of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. A mask specifying which fields (e.g. `expire_time`) in the Backup resource should be updated. This mask is relative to the Backup resource, not to the request message. The field mask must always be specified; this prevents any future fields from being erased accidentally by clients that do not know about them.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "Backup" +}, +"response": { +"$ref": "Backup" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on a database or backup resource. Replaces any existing policy. Authorization requires `spanner.databases.setIamPolicy` permission on resource. For backups, authorization requires `spanner.backups.setIamPolicy` permission on resource. For backup schedules, authorization requires `spanner.backupSchedules.setIamPolicy` permission on resource.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}:setIamPolicy", +"httpMethod": "POST", +"id": "spanner.projects.instances.backups.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which the policy is being set. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for databases resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"testIamPermissions": { +"description": "Returns permissions that the caller has on the specified database or backup resource. Attempting this RPC on a non-existent Cloud Spanner database will result in a NOT_FOUND error if the user has `spanner.databases.list` permission on the containing Cloud Spanner instance. Otherwise returns an empty set of permissions. Calling this method on a backup that does not exist will result in a NOT_FOUND error if the user has `spanner.backups.list` permission on the containing instance. Calling this method on a backup schedule that does not exist will result in a NOT_FOUND error if the user has `spanner.backupSchedules.list` permission on the containing database.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}:testIamPermissions", +"httpMethod": "POST", +"id": "spanner.projects.instances.backups.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which permissions are being tested. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +}, +"resources": { +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "spanner.projects.instances.backups.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.backups.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.backups.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/backups/{backupsId}/operations", +"httpMethod": "GET", +"id": "spanner.projects.instances.backups.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/backups/[^/]+/operations$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +} +} +}, +"databaseOperations": { +"methods": { +"list": { +"description": "Lists database longrunning-operations. A database operation has a name of the form `projects//instances//databases//operations/`. The long-running operation metadata field type `metadata.type_url` describes the type of the metadata. Operations returned include those that have completed/failed/canceled within the last 7 days, and pending operations.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databaseOperations", +"httpMethod": "GET", +"id": "spanner.projects.instances.databaseOperations.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "An expression that filters the list of returned operations. A filter expression consists of a field name, a comparison operator, and a value for filtering. The value must be a string, a number, or a boolean. The comparison operator must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`. Colon `:` is the contains operator. Filter rules are not case sensitive. The following fields in the operation are eligible for filtering: * `name` - The name of the long-running operation * `done` - False if the operation is in progress, else true. * `metadata.@type` - the type of metadata. For example, the type string for RestoreDatabaseMetadata is `type.googleapis.com/google.spanner.admin.database.v1.RestoreDatabaseMetadata`. * `metadata.` - any field in metadata.value. `metadata.@type` must be specified first, if filtering on metadata fields. * `error` - Error associated with the long-running operation. * `response.@type` - the type of response. * `response.` - any field in response.value. You can combine multiple expressions by enclosing each expression in parentheses. By default, expressions are combined with AND logic. However, you can specify AND, OR, and NOT logic explicitly. Here are a few examples: * `done:true` - The operation is complete. * `(metadata.@type=type.googleapis.com/google.spanner.admin.database.v1.RestoreDatabaseMetadata) AND` \\ `(metadata.source_type:BACKUP) AND` \\ `(metadata.backup_info.backup:backup_howl) AND` \\ `(metadata.name:restored_howl) AND` \\ `(metadata.progress.start_time < \\\"2018-03-28T14:50:00Z\\\") AND` \\ `(error:*)` - Return operations where: * The operation's metadata type is RestoreDatabaseMetadata. * The database is restored from a backup. * The backup name contains \"backup_howl\". * The restored database's name contains \"restored_howl\". * The operation started before 2018-03-28T14:50:00Z. * The operation resulted in an error.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Number of operations to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListDatabaseOperationsResponse to the same `parent` and with the same `filter`.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The instance of the database operations. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/databaseOperations", +"response": { +"$ref": "ListDatabaseOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +}, +"databases": { +"methods": { +"changequorum": { +"description": "`ChangeQuorum` is strictly restricted to databases that use dual-region instance configurations. Initiates a background operation to change the quorum of a database from dual-region mode to single-region mode or vice versa. The returned long-running operation has a name of the format `projects//instances//databases//operations/` and can be used to track execution of the `ChangeQuorum`. The metadata field type is ChangeQuorumMetadata. Authorization requires `spanner.databases.changequorum` permission on the resource database.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}:changequorum", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.changequorum", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. Name of the database in which to apply `ChangeQuorum`. Values are of the form `projects//instances//databases/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:changequorum", +"request": { +"$ref": "ChangeQuorumRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"create": { +"description": "Creates a new Spanner database and starts to prepare it for serving. The returned long-running operation will have a name of the format `/operations/` and can be used to track preparation of the database. The metadata field type is CreateDatabaseMetadata. The response field type is Database, if successful.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the instance that will serve the new database. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/databases", +"request": { +"$ref": "CreateDatabaseRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"dropDatabase": { +"description": "Drops (aka deletes) a Cloud Spanner database. Completed backups for the database will be retained according to their `expire_time`. Note: Cloud Spanner might continue to accept requests for a few seconds after the database has been deleted.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.databases.dropDatabase", +"parameterOrder": [ +"database" +], +"parameters": { +"database": { +"description": "Required. The database to be dropped.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+database}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets the state of a Cloud Spanner database.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the requested database. Values are of the form `projects//instances//databases/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Database" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"getDdl": { +"description": "Returns the schema of a Cloud Spanner database as a list of formatted DDL statements. This method does not show pending schema updates, those may be queried using the Operations API.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/ddl", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.getDdl", +"parameterOrder": [ +"database" +], +"parameters": { +"database": { +"description": "Required. The database whose schema we wish to get. Values are of the form `projects//instances//databases/`", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+database}/ddl", +"response": { +"$ref": "GetDatabaseDdlResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a database or backup resource. Returns an empty policy if a database or backup exists but does not have a policy set. Authorization requires `spanner.databases.getIamPolicy` permission on resource. For backups, authorization requires `spanner.backups.getIamPolicy` permission on resource. For backup schedules, authorization requires `spanner.backupSchedules.getIamPolicy` permission on resource.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}:getIamPolicy", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which the policy is being retrieved. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"request": { +"$ref": "GetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"getScans": { +"description": "Request a specific scan with Database-specific data for Cloud Key Visualizer.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/scans", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.getScans", +"parameterOrder": [ +"name" +], +"parameters": { +"endTime": { +"description": "The upper bound for the time range to retrieve Scan data for.", +"format": "google-datetime", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The unique name of the scan containing the requested information, specific to the Database service implementing this interface.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +}, +"startTime": { +"description": "These fields restrict the Database-specific information returned in the `Scan.data` field. If a `View` is provided that does not include the `Scan.data` field, these are ignored. This range of time must be entirely contained within the defined time range of the targeted scan. The lower bound for the time range to retrieve Scan data for.", +"format": "google-datetime", +"location": "query", +"type": "string" +}, +"view": { +"description": "Specifies which parts of the Scan should be returned in the response. Note, if left unspecified, the FULL view is assumed.", +"enum": [ +"VIEW_UNSPECIFIED", +"SUMMARY", +"FULL" +], +"enumDescriptions": [ +"Not specified, equivalent to SUMMARY.", +"Server responses only include `name`, `details`, `start_time` and `end_time`. The default value. Note, the ListScans method may only use this view type, others view types are not supported.", +"Full representation of the scan is returned in the server response, including `data`." +], +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}/scans", +"response": { +"$ref": "Scan" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"list": { +"description": "Lists Cloud Spanner databases.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Number of databases to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListDatabasesResponse.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The instance whose databases should be listed. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/databases", +"response": { +"$ref": "ListDatabasesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"patch": { +"description": "Updates a Cloud Spanner database. The returned long-running operation can be used to track the progress of updating the database. If the named database does not exist, returns `NOT_FOUND`. While the operation is pending: * The database's reconciling field is set to true. * Cancelling the operation is best-effort. If the cancellation succeeds, the operation metadata's cancel_time is set, the updates are reverted, and the operation terminates with a `CANCELLED` status. * New UpdateDatabase requests will return a `FAILED_PRECONDITION` error until the pending operation is done (returns successfully or with error). * Reading the database via the API continues to give the pre-request values. Upon completion of the returned operation: * The new values are in effect and readable via the API. * The database's reconciling field becomes false. The returned long-running operation will have a name of the format `projects//instances//databases//operations/` and can be used to track the database modification. The metadata field type is UpdateDatabaseMetadata. The response field type is Database, if successful.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}", +"httpMethod": "PATCH", +"id": "spanner.projects.instances.databases.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the database. Values are of the form `projects//instances//databases/`, where `` is as specified in the `CREATE DATABASE` statement. This name can be passed to other API methods to identify the database.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. The list of fields to update. Currently, only `enable_drop_protection` field can be updated.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "Database" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"restore": { +"description": "Create a new database by restoring from a completed backup. The new database must be in the same project and in an instance with the same instance configuration as the instance containing the backup. The returned database long-running operation has a name of the format `projects//instances//databases//operations/`, and can be used to track the progress of the operation, and to cancel it. The metadata field type is RestoreDatabaseMetadata. The response type is Database, if successful. Cancelling the returned operation will stop the restore and delete the database. There can be only one database being restored into an instance at a time. Once the restore operation completes, a new restore operation can be initiated, without waiting for the optimize operation associated with the first restore to complete.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases:restore", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.restore", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the instance in which to create the restored database. This instance must be in the same project and have the same instance configuration as the instance containing the source backup. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/databases:restore", +"request": { +"$ref": "RestoreDatabaseRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on a database or backup resource. Replaces any existing policy. Authorization requires `spanner.databases.setIamPolicy` permission on resource. For backups, authorization requires `spanner.backups.setIamPolicy` permission on resource. For backup schedules, authorization requires `spanner.backupSchedules.setIamPolicy` permission on resource.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}:setIamPolicy", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which the policy is being set. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for databases resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"testIamPermissions": { +"description": "Returns permissions that the caller has on the specified database or backup resource. Attempting this RPC on a non-existent Cloud Spanner database will result in a NOT_FOUND error if the user has `spanner.databases.list` permission on the containing Cloud Spanner instance. Otherwise returns an empty set of permissions. Calling this method on a backup that does not exist will result in a NOT_FOUND error if the user has `spanner.backups.list` permission on the containing instance. Calling this method on a backup schedule that does not exist will result in a NOT_FOUND error if the user has `spanner.backupSchedules.list` permission on the containing database.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}:testIamPermissions", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which permissions are being tested. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"updateDdl": { +"description": "Updates the schema of a Cloud Spanner database by creating/altering/dropping tables, columns, indexes, etc. The returned long-running operation will have a name of the format `/operations/` and can be used to track execution of the schema change(s). The metadata field type is UpdateDatabaseDdlMetadata. The operation has no response.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/ddl", +"httpMethod": "PATCH", +"id": "spanner.projects.instances.databases.updateDdl", +"parameterOrder": [ +"database" +], +"parameters": { +"database": { +"description": "Required. The database to update.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+database}/ddl", +"request": { +"$ref": "UpdateDatabaseDdlRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +}, +"resources": { +"backupSchedules": { +"methods": { +"create": { +"description": "Creates a new backup schedule.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/backupSchedules", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.backupSchedules.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"backupScheduleId": { +"description": "Required. The Id to use for the backup schedule. The `backup_schedule_id` appended to `parent` forms the full backup schedule name of the form `projects//instances//databases//backupSchedules/`.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The name of the database that this backup schedule applies to.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/backupSchedules", +"request": { +"$ref": "BackupSchedule" +}, +"response": { +"$ref": "BackupSchedule" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes a backup schedule.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/backupSchedules/{backupSchedulesId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.databases.backupSchedules.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the schedule to delete. Values are of the form `projects//instances//databases//backupSchedules/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/backupSchedules/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets backup schedule for the input schedule name.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/backupSchedules/{backupSchedulesId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.backupSchedules.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the schedule to retrieve. Values are of the form `projects//instances//databases//backupSchedules/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/backupSchedules/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "BackupSchedule" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"getIamPolicy": { +"description": "Gets the access control policy for a database or backup resource. Returns an empty policy if a database or backup exists but does not have a policy set. Authorization requires `spanner.databases.getIamPolicy` permission on resource. For backups, authorization requires `spanner.backups.getIamPolicy` permission on resource. For backup schedules, authorization requires `spanner.backupSchedules.getIamPolicy` permission on resource.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/backupSchedules/{backupSchedulesId}:getIamPolicy", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.backupSchedules.getIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which the policy is being retrieved. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/backupSchedules/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:getIamPolicy", +"request": { +"$ref": "GetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists all the backup schedules for the database.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/backupSchedules", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.backupSchedules.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Optional. Number of backup schedules to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. If non-empty, `page_token` should contain a next_page_token from a previous ListBackupSchedulesResponse to the same `parent`.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. Database is the parent resource whose backup schedules should be listed. Values are of the form projects//instances//databases/", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/backupSchedules", +"response": { +"$ref": "ListBackupSchedulesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"patch": { +"description": "Updates a backup schedule.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/backupSchedules/{backupSchedulesId}", +"httpMethod": "PATCH", +"id": "spanner.projects.instances.databases.backupSchedules.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Identifier. Output only for the CreateBackupSchedule operation. Required for the UpdateBackupSchedule operation. A globally unique identifier for the backup schedule which cannot be changed. Values are of the form `projects//instances//databases//backupSchedules/a-z*[a-z0-9]` The final segment of the name must be between 2 and 60 characters in length.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/backupSchedules/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. A mask specifying which fields in the BackupSchedule resource should be updated. This mask is relative to the BackupSchedule resource, not to the request message. The field mask must always be specified; this prevents any future fields from being erased accidentally.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "BackupSchedule" +}, +"response": { +"$ref": "BackupSchedule" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"setIamPolicy": { +"description": "Sets the access control policy on a database or backup resource. Replaces any existing policy. Authorization requires `spanner.databases.setIamPolicy` permission on resource. For backups, authorization requires `spanner.backups.setIamPolicy` permission on resource. For backup schedules, authorization requires `spanner.backupSchedules.setIamPolicy` permission on resource.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/backupSchedules/{backupSchedulesId}:setIamPolicy", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.backupSchedules.setIamPolicy", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which the policy is being set. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for databases resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/backupSchedules/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:setIamPolicy", +"request": { +"$ref": "SetIamPolicyRequest" +}, +"response": { +"$ref": "Policy" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"testIamPermissions": { +"description": "Returns permissions that the caller has on the specified database or backup resource. Attempting this RPC on a non-existent Cloud Spanner database will result in a NOT_FOUND error if the user has `spanner.databases.list` permission on the containing Cloud Spanner instance. Otherwise returns an empty set of permissions. Calling this method on a backup that does not exist will result in a NOT_FOUND error if the user has `spanner.backups.list` permission on the containing instance. Calling this method on a backup schedule that does not exist will result in a NOT_FOUND error if the user has `spanner.backupSchedules.list` permission on the containing database.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/backupSchedules/{backupSchedulesId}:testIamPermissions", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.backupSchedules.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which permissions are being tested. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/backupSchedules/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +}, +"databaseRoles": { +"methods": { +"list": { +"description": "Lists Cloud Spanner database roles.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/databaseRoles", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.databaseRoles.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "Number of database roles to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListDatabaseRolesResponse.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The database whose roles should be listed. Values are of the form `projects//instances//databases/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/databaseRoles", +"response": { +"$ref": "ListDatabaseRolesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"testIamPermissions": { +"description": "Returns permissions that the caller has on the specified database or backup resource. Attempting this RPC on a non-existent Cloud Spanner database will result in a NOT_FOUND error if the user has `spanner.databases.list` permission on the containing Cloud Spanner instance. Otherwise returns an empty set of permissions. Calling this method on a backup that does not exist will result in a NOT_FOUND error if the user has `spanner.backups.list` permission on the containing instance. Calling this method on a backup schedule that does not exist will result in a NOT_FOUND error if the user has `spanner.backupSchedules.list` permission on the containing database.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/databaseRoles/{databaseRolesId}:testIamPermissions", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.databaseRoles.testIamPermissions", +"parameterOrder": [ +"resource" +], +"parameters": { +"resource": { +"description": "REQUIRED: The Cloud Spanner resource for which permissions are being tested. The format is `projects//instances/` for instance resources and `projects//instances//databases/` for database resources.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/databaseRoles/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+resource}:testIamPermissions", +"request": { +"$ref": "TestIamPermissionsRequest" +}, +"response": { +"$ref": "TestIamPermissionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +}, +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.databases.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/operations", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/operations$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +}, +"sessions": { +"methods": { +"batchCreate": { +"description": "Creates multiple new sessions. This API can be used to initialize a session cache on the clients. See https://goo.gl/TgSFN2 for best practices on session cache management.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions:batchCreate", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.batchCreate", +"parameterOrder": [ +"database" +], +"parameters": { +"database": { +"description": "Required. The database in which the new sessions are created.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+database}/sessions:batchCreate", +"request": { +"$ref": "BatchCreateSessionsRequest" +}, +"response": { +"$ref": "BatchCreateSessionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"batchWrite": { +"description": "Batches the supplied mutation groups in a collection of efficient transactions. All mutations in a group are committed atomically. However, mutations across groups can be committed non-atomically in an unspecified order and thus, they must be independent of each other. Partial failure is possible, i.e., some groups may have been committed successfully, while some may have failed. The results of individual batches are streamed into the response as the batches are applied. BatchWrite requests are not replay protected, meaning that each mutation group may be applied more than once. Replays of non-idempotent mutations may have undesirable effects. For example, replays of an insert mutation may produce an already exists error or if you use generated or commit timestamp-based keys, it may result in additional rows being added to the mutation's table. We recommend structuring your mutation groups to be idempotent to avoid this issue.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:batchWrite", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.batchWrite", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the batch request is to be run.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:batchWrite", +"request": { +"$ref": "BatchWriteRequest" +}, +"response": { +"$ref": "BatchWriteResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"beginTransaction": { +"description": "Begins a new transaction. This step can often be skipped: Read, ExecuteSql and Commit can begin a new transaction as a side-effect.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:beginTransaction", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.beginTransaction", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the transaction runs.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:beginTransaction", +"request": { +"$ref": "BeginTransactionRequest" +}, +"response": { +"$ref": "Transaction" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"commit": { +"description": "Commits a transaction. The request includes the mutations to be applied to rows in the database. `Commit` might return an `ABORTED` error. This can occur at any time; commonly, the cause is conflicts with concurrent transactions. However, it can also happen for a variety of other reasons. If `Commit` returns `ABORTED`, the caller should re-attempt the transaction from the beginning, re-using the same session. On very rare occasions, `Commit` might return `UNKNOWN`. This can happen, for example, if the client job experiences a 1+ hour networking failure. At that point, Cloud Spanner has lost track of the transaction outcome and we recommend that you perform another read from the database to see the state of things as they are now.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:commit", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.commit", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the transaction to be committed is running.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:commit", +"request": { +"$ref": "CommitRequest" +}, +"response": { +"$ref": "CommitResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"create": { +"description": "Creates a new session. A session can be used to perform transactions that read and/or modify data in a Cloud Spanner database. Sessions are meant to be reused for many consecutive transactions. Sessions can only execute one transaction at a time. To execute multiple concurrent read-write/write-only transactions, create multiple sessions. Note that standalone reads and queries use a transaction internally, and count toward the one transaction limit. Active sessions use additional server resources, so it is a good idea to delete idle and unneeded sessions. Aside from explicit deletes, Cloud Spanner may delete sessions for which no operations are sent for more than an hour. If a session is deleted, requests to it return `NOT_FOUND`. Idle sessions can be kept alive by sending a trivial SQL query periodically, e.g., `\"SELECT 1\"`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.create", +"parameterOrder": [ +"database" +], +"parameters": { +"database": { +"description": "Required. The database in which the new session is created.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+database}/sessions", +"request": { +"$ref": "CreateSessionRequest" +}, +"response": { +"$ref": "Session" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"delete": { +"description": "Ends a session, releasing server resources associated with it. This will asynchronously trigger cancellation of any operations that are running with this session.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.databases.sessions.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the session to delete.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"executeBatchDml": { +"description": "Executes a batch of SQL DML statements. This method allows many statements to be run with lower latency than submitting them sequentially with ExecuteSql. Statements are executed in sequential order. A request can succeed even if a statement fails. The ExecuteBatchDmlResponse.status field in the response provides information about the statement that failed. Clients must inspect this field to determine whether an error occurred. Execution stops after the first failed statement; the remaining statements are not executed.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:executeBatchDml", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.executeBatchDml", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the DML statements should be performed.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:executeBatchDml", +"request": { +"$ref": "ExecuteBatchDmlRequest" +}, +"response": { +"$ref": "ExecuteBatchDmlResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"executeSql": { +"description": "Executes an SQL statement, returning all results in a single reply. This method cannot be used to return a result set larger than 10 MiB; if the query yields more data than that, the query fails with a `FAILED_PRECONDITION` error. Operations inside read-write transactions might return `ABORTED`. If this occurs, the application should restart the transaction from the beginning. See Transaction for more details. Larger result sets can be fetched in streaming fashion by calling ExecuteStreamingSql instead.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:executeSql", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.executeSql", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the SQL query should be performed.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:executeSql", +"request": { +"$ref": "ExecuteSqlRequest" +}, +"response": { +"$ref": "ResultSet" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"executeStreamingSql": { +"description": "Like ExecuteSql, except returns the result set as a stream. Unlike ExecuteSql, there is no limit on the size of the returned result set. However, no individual row in the result set can exceed 100 MiB, and no column value can exceed 10 MiB.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:executeStreamingSql", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.executeStreamingSql", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the SQL query should be performed.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:executeStreamingSql", +"request": { +"$ref": "ExecuteSqlRequest" +}, +"response": { +"$ref": "PartialResultSet" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"get": { +"description": "Gets a session. Returns `NOT_FOUND` if the session does not exist. This is mainly useful for determining whether a session is still alive.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.sessions.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the session to retrieve.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Session" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"list": { +"description": "Lists all sessions in a given database.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions", +"httpMethod": "GET", +"id": "spanner.projects.instances.databases.sessions.list", +"parameterOrder": [ +"database" +], +"parameters": { +"database": { +"description": "Required. The database in which to list sessions.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+$", +"required": true, +"type": "string" +}, +"filter": { +"description": "An expression for filtering the results of the request. Filter rules are case insensitive. The fields eligible for filtering are: * `labels.key` where key is the name of a label Some examples of using filters are: * `labels.env:*` --> The session has the label \"env\". * `labels.env:dev` --> The session has the label \"env\" and the value of the label contains the string \"dev\".", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Number of sessions to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListSessionsResponse.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+database}/sessions", +"response": { +"$ref": "ListSessionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"partitionQuery": { +"description": "Creates a set of partition tokens that can be used to execute a query operation in parallel. Each of the returned partition tokens can be used by ExecuteStreamingSql to specify a subset of the query result to read. The same session and read-only transaction must be used by the PartitionQueryRequest used to create the partition tokens and the ExecuteSqlRequests that use the partition tokens. Partition tokens become invalid when the session used to create them is deleted, is idle for too long, begins a new transaction, or becomes too old. When any of these happen, it is not possible to resume the query, and the whole operation must be restarted from the beginning.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:partitionQuery", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.partitionQuery", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session used to create the partitions.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:partitionQuery", +"request": { +"$ref": "PartitionQueryRequest" +}, +"response": { +"$ref": "PartitionResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"partitionRead": { +"description": "Creates a set of partition tokens that can be used to execute a read operation in parallel. Each of the returned partition tokens can be used by StreamingRead to specify a subset of the read result to read. The same session and read-only transaction must be used by the PartitionReadRequest used to create the partition tokens and the ReadRequests that use the partition tokens. There are no ordering guarantees on rows returned among the returned partition tokens, or even within each individual StreamingRead call issued with a partition_token. Partition tokens become invalid when the session used to create them is deleted, is idle for too long, begins a new transaction, or becomes too old. When any of these happen, it is not possible to resume the read, and the whole operation must be restarted from the beginning.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:partitionRead", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.partitionRead", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session used to create the partitions.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:partitionRead", +"request": { +"$ref": "PartitionReadRequest" +}, +"response": { +"$ref": "PartitionResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"read": { +"description": "Reads rows from the database using key lookups and scans, as a simple key/value style alternative to ExecuteSql. This method cannot be used to return a result set larger than 10 MiB; if the read matches more data than that, the read fails with a `FAILED_PRECONDITION` error. Reads inside read-write transactions might return `ABORTED`. If this occurs, the application should restart the transaction from the beginning. See Transaction for more details. Larger result sets can be yielded in streaming fashion by calling StreamingRead instead.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:read", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.read", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the read should be performed.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:read", +"request": { +"$ref": "ReadRequest" +}, +"response": { +"$ref": "ResultSet" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"rollback": { +"description": "Rolls back a transaction, releasing any locks it holds. It is a good idea to call this for any transaction that includes one or more Read or ExecuteSql requests and ultimately decides not to commit. `Rollback` returns `OK` if it successfully aborts the transaction, the transaction was already aborted, or the transaction is not found. `Rollback` never returns `ABORTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:rollback", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.rollback", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the transaction to roll back is running.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:rollback", +"request": { +"$ref": "RollbackRequest" +}, +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +}, +"streamingRead": { +"description": "Like Read, except returns the result set as a stream. Unlike Read, there is no limit on the size of the returned result set. However, no individual row in the result set can exceed 100 MiB, and no column value can exceed 10 MiB.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/databases/{databasesId}/sessions/{sessionsId}:streamingRead", +"httpMethod": "POST", +"id": "spanner.projects.instances.databases.sessions.streamingRead", +"parameterOrder": [ +"session" +], +"parameters": { +"session": { +"description": "Required. The session in which the read should be performed.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/databases/[^/]+/sessions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+session}:streamingRead", +"request": { +"$ref": "ReadRequest" +}, +"response": { +"$ref": "PartialResultSet" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +} +} +} +} +}, +"instancePartitionOperations": { +"methods": { +"list": { +"description": "Lists instance partition long-running operations in the given instance. An instance partition operation has a name of the form `projects//instances//instancePartitions//operations/`. The long-running operation metadata field type `metadata.type_url` describes the type of the metadata. Operations returned include those that have completed/failed/canceled within the last 7 days, and pending operations. Operations returned are ordered by `operation.metadata.value.start_time` in descending order starting from the most recently started operation. Authorization requires `spanner.instancePartitionOperations.list` permission on the resource parent.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitionOperations", +"httpMethod": "GET", +"id": "spanner.projects.instances.instancePartitionOperations.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Optional. An expression that filters the list of returned operations. A filter expression consists of a field name, a comparison operator, and a value for filtering. The value must be a string, a number, or a boolean. The comparison operator must be one of: `<`, `>`, `<=`, `>=`, `!=`, `=`, or `:`. Colon `:` is the contains operator. Filter rules are not case sensitive. The following fields in the Operation are eligible for filtering: * `name` - The name of the long-running operation * `done` - False if the operation is in progress, else true. * `metadata.@type` - the type of metadata. For example, the type string for CreateInstancePartitionMetadata is `type.googleapis.com/google.spanner.admin.instance.v1.CreateInstancePartitionMetadata`. * `metadata.` - any field in metadata.value. `metadata.@type` must be specified first, if filtering on metadata fields. * `error` - Error associated with the long-running operation. * `response.@type` - the type of response. * `response.` - any field in response.value. You can combine multiple expressions by enclosing each expression in parentheses. By default, expressions are combined with AND logic. However, you can specify AND, OR, and NOT logic explicitly. Here are a few examples: * `done:true` - The operation is complete. * `(metadata.@type=` \\ `type.googleapis.com/google.spanner.admin.instance.v1.CreateInstancePartitionMetadata) AND` \\ `(metadata.instance_partition.name:custom-instance-partition) AND` \\ `(metadata.start_time < \\\"2021-03-28T14:50:00Z\\\") AND` \\ `(error:*)` - Return operations where: * The operation's metadata type is CreateInstancePartitionMetadata. * The instance partition name contains \"custom-instance-partition\". * The operation started before 2021-03-28T14:50:00Z. * The operation resulted in an error.", +"location": "query", +"type": "string" +}, +"instancePartitionDeadline": { +"description": "Optional. Deadline used while retrieving metadata for instance partition operations. Instance partitions whose operation metadata cannot be retrieved within this deadline will be added to unreachable_instance_partitions in ListInstancePartitionOperationsResponse.", +"format": "google-datetime", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. Number of operations to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. If non-empty, `page_token` should contain a next_page_token from a previous ListInstancePartitionOperationsResponse to the same `parent` and with the same `filter`.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent instance of the instance partition operations. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/instancePartitionOperations", +"response": { +"$ref": "ListInstancePartitionOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +}, +"instancePartitions": { +"methods": { +"create": { +"description": "Creates an instance partition and begins preparing it to be used. The returned long-running operation can be used to track the progress of preparing the new instance partition. The instance partition name is assigned by the caller. If the named instance partition already exists, `CreateInstancePartition` returns `ALREADY_EXISTS`. Immediately upon completion of this request: * The instance partition is readable via the API, with all requested attributes but no allocated resources. Its state is `CREATING`. Until completion of the returned operation: * Cancelling the operation renders the instance partition immediately unreadable via the API. * The instance partition can be deleted. * All other attempts to modify the instance partition are rejected. Upon completion of the returned operation: * Billing for all successfully-allocated resources begins (some types may have lower than the requested levels). * Databases can start using this instance partition. * The instance partition's allocated resource levels are readable via the API. * The instance partition's state becomes `READY`. The returned long-running operation will have a name of the format `/operations/` and can be used to track creation of the instance partition. The metadata field type is CreateInstancePartitionMetadata. The response field type is InstancePartition, if successful.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions", +"httpMethod": "POST", +"id": "spanner.projects.instances.instancePartitions.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The name of the instance in which to create the instance partition. Values are of the form `projects//instances/`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/instancePartitions", +"request": { +"$ref": "CreateInstancePartitionRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes an existing instance partition. Requires that the instance partition is not used by any database or backup and is not the default instance partition of an instance. Authorization requires `spanner.instancePartitions.delete` permission on the resource name.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions/{instancePartitionsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.instancePartitions.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"etag": { +"description": "Optional. If not empty, the API only deletes the instance partition when the etag provided matches the current status of the requested instance partition. Otherwise, deletes the instance partition without checking the current status of the requested instance partition.", +"location": "query", +"type": "string" +}, +"name": { +"description": "Required. The name of the instance partition to be deleted. Values are of the form `projects/{project}/instances/{instance}/instancePartitions/{instance_partition}`", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/instancePartitions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets information about a particular instance partition.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions/{instancePartitionsId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.instancePartitions.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The name of the requested instance partition. Values are of the form `projects/{project}/instances/{instance}/instancePartitions/{instance_partition}`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/instancePartitions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "InstancePartition" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists all instance partitions for the given instance.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions", +"httpMethod": "GET", +"id": "spanner.projects.instances.instancePartitions.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"instancePartitionDeadline": { +"description": "Optional. Deadline used while retrieving metadata for instance partitions. Instance partitions whose metadata cannot be retrieved within this deadline will be added to unreachable in ListInstancePartitionsResponse.", +"format": "google-datetime", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Number of instance partitions to be returned in the response. If 0 or less, defaults to the server's maximum allowed page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "If non-empty, `page_token` should contain a next_page_token from a previous ListInstancePartitionsResponse.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The instance whose instance partitions should be listed. Values are of the form `projects//instances/`. Use `{instance} = '-'` to list instance partitions for all Instances in a project, e.g., `projects/myproject/instances/-`.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+parent}/instancePartitions", +"response": { +"$ref": "ListInstancePartitionsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"patch": { +"description": "Updates an instance partition, and begins allocating or releasing resources as requested. The returned long-running operation can be used to track the progress of updating the instance partition. If the named instance partition does not exist, returns `NOT_FOUND`. Immediately upon completion of this request: * For resource types for which a decrease in the instance partition's allocation has been requested, billing is based on the newly-requested level. Until completion of the returned operation: * Cancelling the operation sets its metadata's cancel_time, and begins restoring resources to their pre-request values. The operation is guaranteed to succeed at undoing all resource changes, after which point it terminates with a `CANCELLED` status. * All other attempts to modify the instance partition are rejected. * Reading the instance partition via the API continues to give the pre-request resource levels. Upon completion of the returned operation: * Billing begins for all successfully-allocated resources (some types may have lower than the requested levels). * All newly-reserved resources are available for serving the instance partition's tables. * The instance partition's new resource levels are readable via the API. The returned long-running operation will have a name of the format `/operations/` and can be used to track the instance partition modification. The metadata field type is UpdateInstancePartitionMetadata. The response field type is InstancePartition, if successful. Authorization requires `spanner.instancePartitions.update` permission on the resource name.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions/{instancePartitionsId}", +"httpMethod": "PATCH", +"id": "spanner.projects.instances.instancePartitions.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. A unique identifier for the instance partition. Values are of the form `projects//instances//instancePartitions/a-z*[a-z0-9]`. The final segment of the name must be between 2 and 64 characters in length. An instance partition's name cannot be changed after the instance partition is created.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/instancePartitions/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"request": { +"$ref": "UpdateInstancePartitionRequest" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +}, +"resources": { +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions/{instancePartitionsId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "spanner.projects.instances.instancePartitions.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/instancePartitions/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions/{instancePartitionsId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.instancePartitions.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/instancePartitions/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions/{instancePartitionsId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.instancePartitions.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/instancePartitions/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/instancePartitions/{instancePartitionsId}/operations", +"httpMethod": "GET", +"id": "spanner.projects.instances.instancePartitions.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/instancePartitions/[^/]+/operations$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +} +} +}, +"operations": { +"methods": { +"cancel": { +"description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/operations/{operationsId}:cancel", +"httpMethod": "POST", +"id": "spanner.projects.instances.operations.cancel", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be cancelled.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}:cancel", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"delete": { +"description": "Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/operations/{operationsId}", +"httpMethod": "DELETE", +"id": "spanner.projects.instances.operations.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource to be deleted.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"get": { +"description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/operations/{operationsId}", +"httpMethod": "GET", +"id": "spanner.projects.instances.operations.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The name of the operation resource.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/operations/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +}, +"list": { +"description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.", +"flatPath": "v1/projects/{projectsId}/instances/{instancesId}/operations", +"httpMethod": "GET", +"id": "spanner.projects.instances.operations.list", +"parameterOrder": [ +"name" +], +"parameters": { +"filter": { +"description": "The standard list filter.", +"location": "query", +"type": "string" +}, +"name": { +"description": "The name of the operation's parent resource.", +"location": "path", +"pattern": "^projects/[^/]+/instances/[^/]+/operations$", +"required": true, +"type": "string" +}, +"pageSize": { +"description": "The standard list page size.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The standard list page token.", +"location": "query", +"type": "string" +} +}, +"path": "v1/{+name}", +"response": { +"$ref": "ListOperationsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.admin" +] +} +} +} +} +} +} +}, +"scans": { +"methods": { +"list": { +"description": "Return available scans given a Database-specific resource name.", +"flatPath": "v1/scans", +"httpMethod": "GET", +"id": "spanner.scans.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "A filter expression to restrict the results based on information present in the available Scan collection. The filter applies to all fields within the Scan message except for `data`.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of items to return.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "The next_page_token value returned from a previous List request, if any.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The unique name of the parent resource, specific to the Database service implementing this interface.", +"location": "path", +"pattern": "^scans$", +"required": true, +"type": "string" +}, +"view": { +"description": "Specifies which parts of the Scan should be returned in the response. Note, only the SUMMARY view (the default) is currently supported for ListScans.", +"enum": [ +"VIEW_UNSPECIFIED", +"SUMMARY", +"FULL" +], +"enumDescriptions": [ +"Not specified, equivalent to SUMMARY.", +"Server responses only include `name`, `details`, `start_time` and `end_time`. The default value. Note, the ListScans method may only use this view type, others view types are not supported.", +"Full representation of the scan is returned in the server response, including `data`." +], +"location": "query", +"type": "string" +} +}, +"path": "v1/{+parent}", +"response": { +"$ref": "ListScansResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform", +"https://www.googleapis.com/auth/spanner.data" +] +} +} +} +}, +"revision": "20241218", +"rootUrl": "https://spanner.googleapis.com/", +"schemas": { +"AsymmetricAutoscalingOption": { +"description": "AsymmetricAutoscalingOption specifies the scaling of replicas identified by the given selection.", +"id": "AsymmetricAutoscalingOption", +"properties": { +"overrides": { +"$ref": "AutoscalingConfigOverrides", +"description": "Optional. Overrides applied to the top-level autoscaling configuration for the selected replicas." +}, +"replicaSelection": { +"$ref": "InstanceReplicaSelection", +"description": "Required. Selects the replicas to which this AsymmetricAutoscalingOption applies. Only read-only replicas are supported." +} +}, +"type": "object" +}, +"AutoscalingConfig": { +"description": "Autoscaling configuration for an instance.", +"id": "AutoscalingConfig", +"properties": { +"asymmetricAutoscalingOptions": { +"description": "Optional. Optional asymmetric autoscaling options. Replicas matching the replica selection criteria will be autoscaled independently from other replicas. The autoscaler will scale the replicas based on the utilization of replicas identified by the replica selection. Replica selections should not overlap with each other. Other replicas (those do not match any replica selection) will be autoscaled together and will have the same compute capacity allocated to them.", +"items": { +"$ref": "AsymmetricAutoscalingOption" +}, +"type": "array" +}, +"autoscalingLimits": { +"$ref": "AutoscalingLimits", +"description": "Required. Autoscaling limits for an instance." +}, +"autoscalingTargets": { +"$ref": "AutoscalingTargets", +"description": "Required. The autoscaling targets for an instance." +} +}, +"type": "object" +}, +"AutoscalingConfigOverrides": { +"description": "Overrides the top-level autoscaling configuration for the replicas identified by `replica_selection`. All fields in this message are optional. Any unspecified fields will use the corresponding values from the top-level autoscaling configuration.", +"id": "AutoscalingConfigOverrides", +"properties": { +"autoscalingLimits": { +"$ref": "AutoscalingLimits", +"description": "Optional. If specified, overrides the min/max limit in the top-level autoscaling configuration for the selected replicas." +}, +"autoscalingTargetHighPriorityCpuUtilizationPercent": { +"description": "Optional. If specified, overrides the autoscaling target high_priority_cpu_utilization_percent in the top-level autoscaling configuration for the selected replicas.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"AutoscalingLimits": { +"description": "The autoscaling limits for the instance. Users can define the minimum and maximum compute capacity allocated to the instance, and the autoscaler will only scale within that range. Users can either use nodes or processing units to specify the limits, but should use the same unit to set both the min_limit and max_limit.", +"id": "AutoscalingLimits", +"properties": { +"maxNodes": { +"description": "Maximum number of nodes allocated to the instance. If set, this number should be greater than or equal to min_nodes.", +"format": "int32", +"type": "integer" +}, +"maxProcessingUnits": { +"description": "Maximum number of processing units allocated to the instance. If set, this number should be multiples of 1000 and be greater than or equal to min_processing_units.", +"format": "int32", +"type": "integer" +}, +"minNodes": { +"description": "Minimum number of nodes allocated to the instance. If set, this number should be greater than or equal to 1.", +"format": "int32", +"type": "integer" +}, +"minProcessingUnits": { +"description": "Minimum number of processing units allocated to the instance. If set, this number should be multiples of 1000.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"AutoscalingTargets": { +"description": "The autoscaling targets for an instance.", +"id": "AutoscalingTargets", +"properties": { +"highPriorityCpuUtilizationPercent": { +"description": "Required. The target high priority cpu utilization percentage that the autoscaler should be trying to achieve for the instance. This number is on a scale from 0 (no utilization) to 100 (full utilization). The valid range is [10, 90] inclusive.", +"format": "int32", +"type": "integer" +}, +"storageUtilizationPercent": { +"description": "Required. The target storage utilization percentage that the autoscaler should be trying to achieve for the instance. This number is on a scale from 0 (no utilization) to 100 (full utilization). The valid range is [10, 99] inclusive.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"Backup": { +"description": "A backup of a Cloud Spanner database.", +"id": "Backup", +"properties": { +"backupSchedules": { +"description": "Output only. List of backup schedule URIs that are associated with creating this backup. This is only applicable for scheduled backups, and is empty for on-demand backups. To optimize for storage, whenever possible, multiple schedules are collapsed together to create one backup. In such cases, this field captures the list of all backup schedule URIs that are associated with creating this backup. If collapsing is not done, then this field captures the single backup schedule URI associated with creating this backup.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"createTime": { +"description": "Output only. The time the CreateBackup request is received. If the request does not specify `version_time`, the `version_time` of the backup will be equivalent to the `create_time`.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"database": { +"description": "Required for the CreateBackup operation. Name of the database from which this backup was created. This needs to be in the same instance as the backup. Values are of the form `projects//instances//databases/`.", +"type": "string" +}, +"databaseDialect": { +"description": "Output only. The database dialect information for the backup.", +"enum": [ +"DATABASE_DIALECT_UNSPECIFIED", +"GOOGLE_STANDARD_SQL", +"POSTGRESQL" +], +"enumDescriptions": [ +"Default value. This value will create a database with the GOOGLE_STANDARD_SQL dialect.", +"GoogleSQL supported SQL.", +"PostgreSQL supported SQL." +], +"readOnly": true, +"type": "string" +}, +"encryptionInfo": { +"$ref": "EncryptionInfo", +"description": "Output only. The encryption information for the backup.", +"readOnly": true +}, +"encryptionInformation": { +"description": "Output only. The encryption information for the backup, whether it is protected by one or more KMS keys. The information includes all Cloud KMS key versions used to encrypt the backup. The `encryption_status` field inside of each `EncryptionInfo` is not populated. At least one of the key versions must be available for the backup to be restored. If a key version is revoked in the middle of a restore, the restore behavior is undefined.", +"items": { +"$ref": "EncryptionInfo" +}, +"readOnly": true, +"type": "array" +}, +"exclusiveSizeBytes": { +"description": "Output only. For a backup in an incremental backup chain, this is the storage space needed to keep the data that has changed since the previous backup. For all other backups, this is always the size of the backup. This value may change if backups on the same chain get deleted or expired. This field can be used to calculate the total storage space used by a set of backups. For example, the total space used by all backups of a database can be computed by summing up this field.", +"format": "int64", +"readOnly": true, +"type": "string" +}, +"expireTime": { +"description": "Required for the CreateBackup operation. The expiration time of the backup, with microseconds granularity that must be at least 6 hours and at most 366 days from the time the CreateBackup request is processed. Once the `expire_time` has passed, the backup is eligible to be automatically deleted by Cloud Spanner to free the resources used by the backup.", +"format": "google-datetime", +"type": "string" +}, +"freeableSizeBytes": { +"description": "Output only. The number of bytes that will be freed by deleting this backup. This value will be zero if, for example, this backup is part of an incremental backup chain and younger backups in the chain require that we keep its data. For backups not in an incremental backup chain, this is always the size of the backup. This value may change if backups on the same chain get created, deleted or expired.", +"format": "int64", +"readOnly": true, +"type": "string" +}, +"incrementalBackupChainId": { +"description": "Output only. Populated only for backups in an incremental backup chain. Backups share the same chain id if and only if they belong to the same incremental backup chain. Use this field to determine which backups are part of the same incremental backup chain. The ordering of backups in the chain can be determined by ordering the backup `version_time`.", +"readOnly": true, +"type": "string" +}, +"maxExpireTime": { +"description": "Output only. The max allowed expiration time of the backup, with microseconds granularity. A backup's expiration time can be configured in multiple APIs: CreateBackup, UpdateBackup, CopyBackup. When updating or copying an existing backup, the expiration time specified must be less than `Backup.max_expire_time`.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"name": { +"description": "Output only for the CreateBackup operation. Required for the UpdateBackup operation. A globally unique identifier for the backup which cannot be changed. Values are of the form `projects//instances//backups/a-z*[a-z0-9]` The final segment of the name must be between 2 and 60 characters in length. The backup is stored in the location(s) specified in the instance configuration of the instance containing the backup, identified by the prefix of the backup name of the form `projects//instances/`.", +"type": "string" +}, +"oldestVersionTime": { +"description": "Output only. Data deleted at a time older than this is guaranteed not to be retained in order to support this backup. For a backup in an incremental backup chain, this is the version time of the oldest backup that exists or ever existed in the chain. For all other backups, this is the version time of the backup. This field can be used to understand what data is being retained by the backup system.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"referencingBackups": { +"description": "Output only. The names of the destination backups being created by copying this source backup. The backup names are of the form `projects//instances//backups/`. Referencing backups may exist in different instances. The existence of any referencing backup prevents the backup from being deleted. When the copy operation is done (either successfully completed or cancelled or the destination backup is deleted), the reference to the backup is removed.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"referencingDatabases": { +"description": "Output only. The names of the restored databases that reference the backup. The database names are of the form `projects//instances//databases/`. Referencing databases may exist in different instances. The existence of any referencing database prevents the backup from being deleted. When a restored database from the backup enters the `READY` state, the reference to the backup is removed.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"sizeBytes": { +"description": "Output only. Size of the backup in bytes. For a backup in an incremental backup chain, this is the sum of the `exclusive_size_bytes` of itself and all older backups in the chain.", +"format": "int64", +"readOnly": true, +"type": "string" +}, +"state": { +"description": "Output only. The current state of the backup.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY" +], +"enumDescriptions": [ +"Not specified.", +"The pending backup is still being created. Operations on the backup may fail with `FAILED_PRECONDITION` in this state.", +"The backup is complete and ready for use." +], +"readOnly": true, +"type": "string" +}, +"versionTime": { +"description": "The backup will contain an externally consistent copy of the database at the timestamp specified by `version_time`. If `version_time` is not specified, the system will set `version_time` to the `create_time` of the backup.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"BackupInfo": { +"description": "Information about a backup.", +"id": "BackupInfo", +"properties": { +"backup": { +"description": "Name of the backup.", +"type": "string" +}, +"createTime": { +"description": "The time the CreateBackup request was received.", +"format": "google-datetime", +"type": "string" +}, +"sourceDatabase": { +"description": "Name of the database the backup was created from.", +"type": "string" +}, +"versionTime": { +"description": "The backup contains an externally consistent copy of `source_database` at the timestamp specified by `version_time`. If the CreateBackup request did not specify `version_time`, the `version_time` of the backup is equivalent to the `create_time`.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"BackupSchedule": { +"description": "BackupSchedule expresses the automated backup creation specification for a Spanner database.", +"id": "BackupSchedule", +"properties": { +"encryptionConfig": { +"$ref": "CreateBackupEncryptionConfig", +"description": "Optional. The encryption configuration that will be used to encrypt the backup. If this field is not specified, the backup will use the same encryption configuration as the database." +}, +"fullBackupSpec": { +"$ref": "FullBackupSpec", +"description": "The schedule creates only full backups." +}, +"incrementalBackupSpec": { +"$ref": "IncrementalBackupSpec", +"description": "The schedule creates incremental backup chains." +}, +"name": { +"description": "Identifier. Output only for the CreateBackupSchedule operation. Required for the UpdateBackupSchedule operation. A globally unique identifier for the backup schedule which cannot be changed. Values are of the form `projects//instances//databases//backupSchedules/a-z*[a-z0-9]` The final segment of the name must be between 2 and 60 characters in length.", +"type": "string" +}, +"retentionDuration": { +"description": "Optional. The retention duration of a backup that must be at least 6 hours and at most 366 days. The backup is eligible to be automatically deleted once the retention period has elapsed.", +"format": "google-duration", +"type": "string" +}, +"spec": { +"$ref": "BackupScheduleSpec", +"description": "Optional. The schedule specification based on which the backup creations are triggered." +}, +"updateTime": { +"description": "Output only. The timestamp at which the schedule was last updated. If the schedule has never been updated, this field contains the timestamp when the schedule was first created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"BackupScheduleSpec": { +"description": "Defines specifications of the backup schedule.", +"id": "BackupScheduleSpec", +"properties": { +"cronSpec": { +"$ref": "CrontabSpec", +"description": "Cron style schedule specification." +} +}, +"type": "object" +}, +"BatchCreateSessionsRequest": { +"description": "The request for BatchCreateSessions.", +"id": "BatchCreateSessionsRequest", +"properties": { +"sessionCount": { +"description": "Required. The number of sessions to be created in this batch call. The API may return fewer than the requested number of sessions. If a specific number of sessions are desired, the client can make additional calls to BatchCreateSessions (adjusting session_count as necessary).", +"format": "int32", +"type": "integer" +}, +"sessionTemplate": { +"$ref": "Session", +"description": "Parameters to be applied to each created session." +} +}, +"type": "object" +}, +"BatchCreateSessionsResponse": { +"description": "The response for BatchCreateSessions.", +"id": "BatchCreateSessionsResponse", +"properties": { +"session": { +"description": "The freshly created sessions.", +"items": { +"$ref": "Session" +}, +"type": "array" +} +}, +"type": "object" +}, +"BatchWriteRequest": { +"description": "The request for BatchWrite.", +"id": "BatchWriteRequest", +"properties": { +"excludeTxnFromChangeStreams": { +"description": "Optional. When `exclude_txn_from_change_streams` is set to `true`: * Modifications from all transactions in this batch write operation will not be recorded in change streams with DDL option `allow_txn_exclusion=true` that are tracking columns modified by these transactions. * Modifications from all transactions in this batch write operation will be recorded in change streams with DDL option `allow_txn_exclusion=false or not set` that are tracking columns modified by these transactions. When `exclude_txn_from_change_streams` is set to `false` or not set, Modifications from all transactions in this batch write operation will be recorded in all change streams that are tracking columns modified by these transactions.", +"type": "boolean" +}, +"mutationGroups": { +"description": "Required. The groups of mutations to be applied.", +"items": { +"$ref": "MutationGroup" +}, +"type": "array" +}, +"requestOptions": { +"$ref": "RequestOptions", +"description": "Common options for this request." +} +}, +"type": "object" +}, +"BatchWriteResponse": { +"description": "The result of applying a batch of mutations.", +"id": "BatchWriteResponse", +"properties": { +"commitTimestamp": { +"description": "The commit timestamp of the transaction that applied this batch. Present if `status` is `OK`, absent otherwise.", +"format": "google-datetime", +"type": "string" +}, +"indexes": { +"description": "The mutation groups applied in this batch. The values index into the `mutation_groups` field in the corresponding `BatchWriteRequest`.", +"items": { +"format": "int32", +"type": "integer" +}, +"type": "array" +}, +"status": { +"$ref": "Status", +"description": "An `OK` status indicates success. Any other status indicates a failure." +} +}, +"type": "object" +}, +"BeginTransactionRequest": { +"description": "The request for BeginTransaction.", +"id": "BeginTransactionRequest", +"properties": { +"mutationKey": { +"$ref": "Mutation", +"description": "Optional. Required for read-write transactions on a multiplexed session that commit mutations but do not perform any reads or queries. Clients should randomly select one of the mutations from the mutation set and send it as a part of this request." +}, +"options": { +"$ref": "TransactionOptions", +"description": "Required. Options for the new transaction." +}, +"requestOptions": { +"$ref": "RequestOptions", +"description": "Common options for this request. Priority is ignored for this request. Setting the priority in this request_options struct will not do anything. To set the priority for a transaction, set it on the reads and writes that are part of this transaction instead." +} +}, +"type": "object" +}, +"Binding": { +"description": "Associates `members`, or principals, with a `role`.", +"id": "Binding", +"properties": { +"condition": { +"$ref": "Expr", +"description": "The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies)." +}, +"members": { +"description": "Specifies the principals requesting access for a Google Cloud resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workforce identity pool. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/group/{group_id}`: All workforce identities in a group. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All workforce identities with a specific attribute value. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/*`: All identities in a workforce identity pool. * `principal://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/subject/{subject_attribute_value}`: A single identity in a workload identity pool. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/group/{group_id}`: A workload identity pool group. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/attribute.{attribute_name}/{attribute_value}`: All identities in a workload identity pool with a certain attribute. * `principalSet://iam.googleapis.com/projects/{project_number}/locations/global/workloadIdentityPools/{pool_id}/*`: All identities in a workload identity pool. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/subject/{subject_attribute_value}`: Deleted single identity in a workforce identity pool. For example, `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-pool-id/subject/my-subject-attribute-value`.", +"items": { +"type": "string" +}, +"type": "array" +}, +"role": { +"description": "Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview of the IAM roles and permissions, see the [IAM documentation](https://cloud.google.com/iam/docs/roles-overview). For a list of the available pre-defined roles, see [here](https://cloud.google.com/iam/docs/understanding-roles).", +"type": "string" +} +}, +"type": "object" +}, +"ChangeQuorumMetadata": { +"description": "Metadata type for the long-running operation returned by ChangeQuorum.", +"id": "ChangeQuorumMetadata", +"properties": { +"endTime": { +"description": "If set, the time at which this operation failed or was completed successfully.", +"format": "google-datetime", +"type": "string" +}, +"request": { +"$ref": "ChangeQuorumRequest", +"description": "The request for ChangeQuorum." +}, +"startTime": { +"description": "Time the request was received.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"ChangeQuorumRequest": { +"description": "The request for ChangeQuorum.", +"id": "ChangeQuorumRequest", +"properties": { +"etag": { +"description": "Optional. The etag is the hash of the `QuorumInfo`. The `ChangeQuorum` operation is only performed if the etag matches that of the `QuorumInfo` in the current database resource. Otherwise the API returns an `ABORTED` error. The etag is used for optimistic concurrency control as a way to help prevent simultaneous change quorum requests that could create a race condition.", +"type": "string" +}, +"name": { +"description": "Required. Name of the database in which to apply `ChangeQuorum`. Values are of the form `projects//instances//databases/`.", +"type": "string" +}, +"quorumType": { +"$ref": "QuorumType", +"description": "Required. The type of this quorum." +} +}, +"type": "object" +}, +"ChildLink": { +"description": "Metadata associated with a parent-child relationship appearing in a PlanNode.", +"id": "ChildLink", +"properties": { +"childIndex": { +"description": "The node to which the link points.", +"format": "int32", +"type": "integer" +}, +"type": { +"description": "The type of the link. For example, in Hash Joins this could be used to distinguish between the build child and the probe child, or in the case of the child being an output variable, to represent the tag associated with the output variable.", +"type": "string" +}, +"variable": { +"description": "Only present if the child node is SCALAR and corresponds to an output variable of the parent node. The field carries the name of the output variable. For example, a `TableScan` operator that reads rows from a table will have child links to the `SCALAR` nodes representing the output variables created for each column that is read by the operator. The corresponding `variable` fields will be set to the variable names assigned to the columns.", +"type": "string" +} +}, +"type": "object" +}, +"CommitRequest": { +"description": "The request for Commit.", +"id": "CommitRequest", +"properties": { +"maxCommitDelay": { +"description": "Optional. The amount of latency this request is configured to incur in order to improve throughput. If this field is not set, Spanner assumes requests are relatively latency sensitive and automatically determines an appropriate delay time. You can specify a commit delay value between 0 and 500 ms.", +"format": "google-duration", +"type": "string" +}, +"mutations": { +"description": "The mutations to be executed when this transaction commits. All mutations are applied atomically, in the order they appear in this list.", +"items": { +"$ref": "Mutation" +}, +"type": "array" +}, +"precommitToken": { +"$ref": "MultiplexedSessionPrecommitToken", +"description": "Optional. If the read-write transaction was executed on a multiplexed session, the precommit token with the highest sequence number received in this transaction attempt, should be included here. Failing to do so will result in a FailedPrecondition error." +}, +"requestOptions": { +"$ref": "RequestOptions", +"description": "Common options for this request." +}, +"returnCommitStats": { +"description": "If `true`, then statistics related to the transaction will be included in the CommitResponse. Default value is `false`.", +"type": "boolean" +}, +"singleUseTransaction": { +"$ref": "TransactionOptions", +"description": "Execute mutations in a temporary transaction. Note that unlike commit of a previously-started transaction, commit with a temporary transaction is non-idempotent. That is, if the `CommitRequest` is sent to Cloud Spanner more than once (for instance, due to retries in the application, or in the transport library), it is possible that the mutations are executed more than once. If this is undesirable, use BeginTransaction and Commit instead." +}, +"transactionId": { +"description": "Commit a previously-started transaction.", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"CommitResponse": { +"description": "The response for Commit.", +"id": "CommitResponse", +"properties": { +"commitStats": { +"$ref": "CommitStats", +"description": "The statistics about this Commit. Not returned by default. For more information, see CommitRequest.return_commit_stats." +}, +"commitTimestamp": { +"description": "The Cloud Spanner timestamp at which the transaction committed.", +"format": "google-datetime", +"type": "string" +}, +"precommitToken": { +"$ref": "MultiplexedSessionPrecommitToken", +"description": "If specified, transaction has not committed yet. Clients must retry the commit with the new precommit token." +} +}, +"type": "object" +}, +"CommitStats": { +"description": "Additional statistics about a commit.", +"id": "CommitStats", +"properties": { +"mutationCount": { +"description": "The total number of mutations for the transaction. Knowing the `mutation_count` value can help you maximize the number of mutations in a transaction and minimize the number of API round trips. You can also monitor this value to prevent transactions from exceeding the system [limit](https://cloud.google.com/spanner/quotas#limits_for_creating_reading_updating_and_deleting_data). If the number of mutations exceeds the limit, the server returns [INVALID_ARGUMENT](https://cloud.google.com/spanner/docs/reference/rest/v1/Code#ENUM_VALUES.INVALID_ARGUMENT).", +"format": "int64", +"type": "string" +} +}, +"type": "object" +}, +"ContextValue": { +"description": "A message representing context for a KeyRangeInfo, including a label, value, unit, and severity.", +"id": "ContextValue", +"properties": { +"label": { +"$ref": "LocalizedString", +"description": "The label for the context value. e.g. \"latency\"." +}, +"severity": { +"description": "The severity of this context.", +"enum": [ +"SEVERITY_UNSPECIFIED", +"INFO", +"WARNING", +"ERROR", +"FATAL" +], +"enumDescriptions": [ +"Required default value.", +"Lowest severity level \"Info\".", +"Middle severity level \"Warning\".", +"Severity level signaling an error \"Error\"", +"Severity level signaling a non recoverable error \"Fatal\"" +], +"type": "string" +}, +"unit": { +"description": "The unit of the context value.", +"type": "string" +}, +"value": { +"description": "The value for the context.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"CopyBackupEncryptionConfig": { +"description": "Encryption configuration for the copied backup.", +"id": "CopyBackupEncryptionConfig", +"properties": { +"encryptionType": { +"description": "Required. The encryption type of the backup.", +"enum": [ +"ENCRYPTION_TYPE_UNSPECIFIED", +"USE_CONFIG_DEFAULT_OR_BACKUP_ENCRYPTION", +"GOOGLE_DEFAULT_ENCRYPTION", +"CUSTOMER_MANAGED_ENCRYPTION" +], +"enumDescriptions": [ +"Unspecified. Do not use.", +"This is the default option for CopyBackup when encryption_config is not specified. For example, if the source backup is using `Customer_Managed_Encryption`, the backup will be using the same Cloud KMS key as the source backup.", +"Use Google default encryption.", +"Use customer managed encryption. If specified, either `kms_key_name` or `kms_key_names` must contain valid Cloud KMS key(s)." +], +"type": "string" +}, +"kmsKeyName": { +"description": "Optional. The Cloud KMS key that will be used to protect the backup. This field should be set only when encryption_type is `CUSTOMER_MANAGED_ENCRYPTION`. Values are of the form `projects//locations//keyRings//cryptoKeys/`.", +"type": "string" +}, +"kmsKeyNames": { +"description": "Optional. Specifies the KMS configuration for the one or more keys used to protect the backup. Values are of the form `projects//locations//keyRings//cryptoKeys/`. KMS keys specified can be in any order. The keys referenced by `kms_key_names` must fully cover all regions of the backup's instance configuration. Some examples: * For regional (single-region) instance configurations, specify a regional location KMS key. * For multi-region instance configurations of type `GOOGLE_MANAGED`, either specify a multi-region location KMS key or multiple regional location KMS keys that cover all regions in the instance configuration. * For an instance configuration of type `USER_MANAGED`, specify only regional location KMS keys to cover each region in the instance configuration. Multi-region location KMS keys aren't supported for `USER_MANAGED` type instance configurations.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"CopyBackupMetadata": { +"description": "Metadata type for the operation returned by CopyBackup.", +"id": "CopyBackupMetadata", +"properties": { +"cancelTime": { +"description": "The time at which cancellation of CopyBackup operation was received. Operations.CancelOperation starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"format": "google-datetime", +"type": "string" +}, +"name": { +"description": "The name of the backup being created through the copy operation. Values are of the form `projects//instances//backups/`.", +"type": "string" +}, +"progress": { +"$ref": "OperationProgress", +"description": "The progress of the CopyBackup operation." +}, +"sourceBackup": { +"description": "The name of the source backup that is being copied. Values are of the form `projects//instances//backups/`.", +"type": "string" +} +}, +"type": "object" +}, +"CopyBackupRequest": { +"description": "The request for CopyBackup.", +"id": "CopyBackupRequest", +"properties": { +"backupId": { +"description": "Required. The id of the backup copy. The `backup_id` appended to `parent` forms the full backup_uri of the form `projects//instances//backups/`.", +"type": "string" +}, +"encryptionConfig": { +"$ref": "CopyBackupEncryptionConfig", +"description": "Optional. The encryption configuration used to encrypt the backup. If this field is not specified, the backup will use the same encryption configuration as the source backup by default, namely encryption_type = `USE_CONFIG_DEFAULT_OR_BACKUP_ENCRYPTION`." +}, +"expireTime": { +"description": "Required. The expiration time of the backup in microsecond granularity. The expiration time must be at least 6 hours and at most 366 days from the `create_time` of the source backup. Once the `expire_time` has passed, the backup is eligible to be automatically deleted by Cloud Spanner to free the resources used by the backup.", +"format": "google-datetime", +"type": "string" +}, +"sourceBackup": { +"description": "Required. The source backup to be copied. The source backup needs to be in READY state for it to be copied. Once CopyBackup is in progress, the source backup cannot be deleted or cleaned up on expiration until CopyBackup is finished. Values are of the form: `projects//instances//backups/`.", +"type": "string" +} +}, +"type": "object" +}, +"CreateBackupEncryptionConfig": { +"description": "Encryption configuration for the backup to create.", +"id": "CreateBackupEncryptionConfig", +"properties": { +"encryptionType": { +"description": "Required. The encryption type of the backup.", +"enum": [ +"ENCRYPTION_TYPE_UNSPECIFIED", +"USE_DATABASE_ENCRYPTION", +"GOOGLE_DEFAULT_ENCRYPTION", +"CUSTOMER_MANAGED_ENCRYPTION" +], +"enumDescriptions": [ +"Unspecified. Do not use.", +"Use the same encryption configuration as the database. This is the default option when encryption_config is empty. For example, if the database is using `Customer_Managed_Encryption`, the backup will be using the same Cloud KMS key as the database.", +"Use Google default encryption.", +"Use customer managed encryption. If specified, `kms_key_name` must contain a valid Cloud KMS key." +], +"type": "string" +}, +"kmsKeyName": { +"description": "Optional. The Cloud KMS key that will be used to protect the backup. This field should be set only when encryption_type is `CUSTOMER_MANAGED_ENCRYPTION`. Values are of the form `projects//locations//keyRings//cryptoKeys/`.", +"type": "string" +}, +"kmsKeyNames": { +"description": "Optional. Specifies the KMS configuration for the one or more keys used to protect the backup. Values are of the form `projects//locations//keyRings//cryptoKeys/`. The keys referenced by `kms_key_names` must fully cover all regions of the backup's instance configuration. Some examples: * For regional (single-region) instance configurations, specify a regional location KMS key. * For multi-region instance configurations of type `GOOGLE_MANAGED`, either specify a multi-region location KMS key or multiple regional location KMS keys that cover all regions in the instance configuration. * For an instance configuration of type `USER_MANAGED`, specify only regional location KMS keys to cover each region in the instance configuration. Multi-region location KMS keys aren't supported for `USER_MANAGED` type instance configurations.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"CreateBackupMetadata": { +"description": "Metadata type for the operation returned by CreateBackup.", +"id": "CreateBackupMetadata", +"properties": { +"cancelTime": { +"description": "The time at which cancellation of this operation was received. Operations.CancelOperation starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"format": "google-datetime", +"type": "string" +}, +"database": { +"description": "The name of the database the backup is created from.", +"type": "string" +}, +"name": { +"description": "The name of the backup being created.", +"type": "string" +}, +"progress": { +"$ref": "OperationProgress", +"description": "The progress of the CreateBackup operation." +} +}, +"type": "object" +}, +"CreateDatabaseMetadata": { +"description": "Metadata type for the operation returned by CreateDatabase.", +"id": "CreateDatabaseMetadata", +"properties": { +"database": { +"description": "The database being created.", +"type": "string" +} +}, +"type": "object" +}, +"CreateDatabaseRequest": { +"description": "The request for CreateDatabase.", +"id": "CreateDatabaseRequest", +"properties": { +"createStatement": { +"description": "Required. A `CREATE DATABASE` statement, which specifies the ID of the new database. The database ID must conform to the regular expression `a-z*[a-z0-9]` and be between 2 and 30 characters in length. If the database ID is a reserved word or if it contains a hyphen, the database ID must be enclosed in backticks (`` ` ``).", +"type": "string" +}, +"databaseDialect": { +"description": "Optional. The dialect of the Cloud Spanner Database.", +"enum": [ +"DATABASE_DIALECT_UNSPECIFIED", +"GOOGLE_STANDARD_SQL", +"POSTGRESQL" +], +"enumDescriptions": [ +"Default value. This value will create a database with the GOOGLE_STANDARD_SQL dialect.", +"GoogleSQL supported SQL.", +"PostgreSQL supported SQL." +], +"type": "string" +}, +"encryptionConfig": { +"$ref": "EncryptionConfig", +"description": "Optional. The encryption configuration for the database. If this field is not specified, Cloud Spanner will encrypt/decrypt all data at rest using Google default encryption." +}, +"extraStatements": { +"description": "Optional. A list of DDL statements to run inside the newly created database. Statements can create tables, indexes, etc. These statements execute atomically with the creation of the database: if there is an error in any statement, the database is not created.", +"items": { +"type": "string" +}, +"type": "array" +}, +"protoDescriptors": { +"description": "Optional. Proto descriptors used by `CREATE/ALTER PROTO BUNDLE` statements in 'extra_statements'. Contains a protobuf-serialized [`google.protobuf.FileDescriptorSet`](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto) descriptor set. To generate it, [install](https://grpc.io/docs/protoc-installation/) and run `protoc` with --include_imports and --descriptor_set_out. For example, to generate for moon/shot/app.proto, run ``` $protoc --proto_path=/app_path --proto_path=/lib_path \\ --include_imports \\ --descriptor_set_out=descriptors.data \\ moon/shot/app.proto ``` For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"CreateInstanceConfigMetadata": { +"description": "Metadata type for the operation returned by CreateInstanceConfig.", +"id": "CreateInstanceConfigMetadata", +"properties": { +"cancelTime": { +"description": "The time at which this operation was cancelled.", +"format": "google-datetime", +"type": "string" +}, +"instanceConfig": { +"$ref": "InstanceConfig", +"description": "The target instance configuration end state." +}, +"progress": { +"$ref": "InstanceOperationProgress", +"description": "The progress of the CreateInstanceConfig operation." +} +}, +"type": "object" +}, +"CreateInstanceConfigRequest": { +"description": "The request for CreateInstanceConfig.", +"id": "CreateInstanceConfigRequest", +"properties": { +"instanceConfig": { +"$ref": "InstanceConfig", +"description": "Required. The `InstanceConfig` proto of the configuration to create. `instance_config.name` must be `/instanceConfigs/`. `instance_config.base_config` must be a Google-managed configuration name, e.g. /instanceConfigs/us-east1, /instanceConfigs/nam3." +}, +"instanceConfigId": { +"description": "Required. The ID of the instance configuration to create. Valid identifiers are of the form `custom-[-a-z0-9]*[a-z0-9]` and must be between 2 and 64 characters in length. The `custom-` prefix is required to avoid name conflicts with Google-managed configurations.", +"type": "string" +}, +"validateOnly": { +"description": "An option to validate, but not actually execute, a request, and provide the same response.", +"type": "boolean" +} +}, +"type": "object" +}, +"CreateInstanceMetadata": { +"description": "Metadata type for the operation returned by CreateInstance.", +"id": "CreateInstanceMetadata", +"properties": { +"cancelTime": { +"description": "The time at which this operation was cancelled. If set, this operation is in the process of undoing itself (which is guaranteed to succeed) and cannot be cancelled again.", +"format": "google-datetime", +"type": "string" +}, +"endTime": { +"description": "The time at which this operation failed or was completed successfully.", +"format": "google-datetime", +"type": "string" +}, +"expectedFulfillmentPeriod": { +"description": "The expected fulfillment period of this create operation.", +"enum": [ +"FULFILLMENT_PERIOD_UNSPECIFIED", +"FULFILLMENT_PERIOD_NORMAL", +"FULFILLMENT_PERIOD_EXTENDED" +], +"enumDescriptions": [ +"Not specified.", +"Normal fulfillment period. The operation is expected to complete within minutes.", +"Extended fulfillment period. It can take up to an hour for the operation to complete." +], +"type": "string" +}, +"instance": { +"$ref": "Instance", +"description": "The instance being created." +}, +"startTime": { +"description": "The time at which the CreateInstance request was received.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"CreateInstancePartitionMetadata": { +"description": "Metadata type for the operation returned by CreateInstancePartition.", +"id": "CreateInstancePartitionMetadata", +"properties": { +"cancelTime": { +"description": "The time at which this operation was cancelled. If set, this operation is in the process of undoing itself (which is guaranteed to succeed) and cannot be cancelled again.", +"format": "google-datetime", +"type": "string" +}, +"endTime": { +"description": "The time at which this operation failed or was completed successfully.", +"format": "google-datetime", +"type": "string" +}, +"instancePartition": { +"$ref": "InstancePartition", +"description": "The instance partition being created." +}, +"startTime": { +"description": "The time at which the CreateInstancePartition request was received.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"CreateInstancePartitionRequest": { +"description": "The request for CreateInstancePartition.", +"id": "CreateInstancePartitionRequest", +"properties": { +"instancePartition": { +"$ref": "InstancePartition", +"description": "Required. The instance partition to create. The instance_partition.name may be omitted, but if specified must be `/instancePartitions/`." +}, +"instancePartitionId": { +"description": "Required. The ID of the instance partition to create. Valid identifiers are of the form `a-z*[a-z0-9]` and must be between 2 and 64 characters in length.", +"type": "string" +} +}, +"type": "object" +}, +"CreateInstanceRequest": { +"description": "The request for CreateInstance.", +"id": "CreateInstanceRequest", +"properties": { +"instance": { +"$ref": "Instance", +"description": "Required. The instance to create. The name may be omitted, but if specified must be `/instances/`." +}, +"instanceId": { +"description": "Required. The ID of the instance to create. Valid identifiers are of the form `a-z*[a-z0-9]` and must be between 2 and 64 characters in length.", +"type": "string" +} +}, +"type": "object" +}, +"CreateSessionRequest": { +"description": "The request for CreateSession.", +"id": "CreateSessionRequest", +"properties": { +"session": { +"$ref": "Session", +"description": "Required. The session to create." +} +}, +"type": "object" +}, +"CrontabSpec": { +"description": "CrontabSpec can be used to specify the version time and frequency at which the backup should be created.", +"id": "CrontabSpec", +"properties": { +"creationWindow": { +"description": "Output only. Schedule backups will contain an externally consistent copy of the database at the version time specified in `schedule_spec.cron_spec`. However, Spanner may not initiate the creation of the scheduled backups at that version time. Spanner will initiate the creation of scheduled backups within the time window bounded by the version_time specified in `schedule_spec.cron_spec` and version_time + `creation_window`.", +"format": "google-duration", +"readOnly": true, +"type": "string" +}, +"text": { +"description": "Required. Textual representation of the crontab. User can customize the backup frequency and the backup version time using the cron expression. The version time must be in UTC timzeone. The backup will contain an externally consistent copy of the database at the version time. Allowed frequencies are 12 hour, 1 day, 1 week and 1 month. Examples of valid cron specifications: * `0 2/12 * * * ` : every 12 hours at (2, 14) hours past midnight in UTC. * `0 2,14 * * * ` : every 12 hours at (2,14) hours past midnight in UTC. * `0 2 * * * ` : once a day at 2 past midnight in UTC. * `0 2 * * 0 ` : once a week every Sunday at 2 past midnight in UTC. * `0 2 8 * * ` : once a month on 8th day at 2 past midnight in UTC.", +"type": "string" +}, +"timeZone": { +"description": "Output only. The time zone of the times in `CrontabSpec.text`. Currently only UTC is supported.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Database": { +"description": "A Cloud Spanner database.", +"id": "Database", +"properties": { +"createTime": { +"description": "Output only. If exists, the time at which the database creation started.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"databaseDialect": { +"description": "Output only. The dialect of the Cloud Spanner Database.", +"enum": [ +"DATABASE_DIALECT_UNSPECIFIED", +"GOOGLE_STANDARD_SQL", +"POSTGRESQL" +], +"enumDescriptions": [ +"Default value. This value will create a database with the GOOGLE_STANDARD_SQL dialect.", +"GoogleSQL supported SQL.", +"PostgreSQL supported SQL." +], +"readOnly": true, +"type": "string" +}, +"defaultLeader": { +"description": "Output only. The read-write region which contains the database's leader replicas. This is the same as the value of default_leader database option set using DatabaseAdmin.CreateDatabase or DatabaseAdmin.UpdateDatabaseDdl. If not explicitly set, this is empty.", +"readOnly": true, +"type": "string" +}, +"earliestVersionTime": { +"description": "Output only. Earliest timestamp at which older versions of the data can be read. This value is continuously updated by Cloud Spanner and becomes stale the moment it is queried. If you are using this value to recover data, make sure to account for the time from the moment when the value is queried to the moment when you initiate the recovery.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"enableDropProtection": { +"description": "Optional. Whether drop protection is enabled for this database. Defaults to false, if not set. For more details, please see how to [prevent accidental database deletion](https://cloud.google.com/spanner/docs/prevent-database-deletion).", +"type": "boolean" +}, +"encryptionConfig": { +"$ref": "EncryptionConfig", +"description": "Output only. For databases that are using customer managed encryption, this field contains the encryption configuration for the database. For databases that are using Google default or other types of encryption, this field is empty.", +"readOnly": true +}, +"encryptionInfo": { +"description": "Output only. For databases that are using customer managed encryption, this field contains the encryption information for the database, such as all Cloud KMS key versions that are in use. The `encryption_status` field inside of each `EncryptionInfo` is not populated. For databases that are using Google default or other types of encryption, this field is empty. This field is propagated lazily from the backend. There might be a delay from when a key version is being used and when it appears in this field.", +"items": { +"$ref": "EncryptionInfo" +}, +"readOnly": true, +"type": "array" +}, +"name": { +"description": "Required. The name of the database. Values are of the form `projects//instances//databases/`, where `` is as specified in the `CREATE DATABASE` statement. This name can be passed to other API methods to identify the database.", +"type": "string" +}, +"quorumInfo": { +"$ref": "QuorumInfo", +"description": "Output only. Applicable only for databases that use dual-region instance configurations. Contains information about the quorum.", +"readOnly": true +}, +"reconciling": { +"description": "Output only. If true, the database is being updated. If false, there are no ongoing update operations for the database.", +"readOnly": true, +"type": "boolean" +}, +"restoreInfo": { +"$ref": "RestoreInfo", +"description": "Output only. Applicable only for restored databases. Contains information about the restore source.", +"readOnly": true +}, +"state": { +"description": "Output only. The current database state.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY", +"READY_OPTIMIZING" +], +"enumDescriptions": [ +"Not specified.", +"The database is still being created. Operations on the database may fail with `FAILED_PRECONDITION` in this state.", +"The database is fully created and ready for use.", +"The database is fully created and ready for use, but is still being optimized for performance and cannot handle full load. In this state, the database still references the backup it was restore from, preventing the backup from being deleted. When optimizations are complete, the full performance of the database will be restored, and the database will transition to `READY` state." +], +"readOnly": true, +"type": "string" +}, +"versionRetentionPeriod": { +"description": "Output only. The period in which Cloud Spanner retains all versions of data for the database. This is the same as the value of version_retention_period database option set using UpdateDatabaseDdl. Defaults to 1 hour, if not set.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"DatabaseRole": { +"description": "A Cloud Spanner database role.", +"id": "DatabaseRole", +"properties": { +"name": { +"description": "Required. The name of the database role. Values are of the form `projects//instances//databases//databaseRoles/` where `` is as specified in the `CREATE ROLE` DDL statement.", +"type": "string" +} +}, +"type": "object" +}, +"DdlStatementActionInfo": { +"description": "Action information extracted from a DDL statement. This proto is used to display the brief info of the DDL statement for the operation UpdateDatabaseDdl.", +"id": "DdlStatementActionInfo", +"properties": { +"action": { +"description": "The action for the DDL statement, e.g. CREATE, ALTER, DROP, GRANT, etc. This field is a non-empty string.", +"type": "string" +}, +"entityNames": { +"description": "The entity name(s) being operated on the DDL statement. E.g. 1. For statement \"CREATE TABLE t1(...)\", `entity_names` = [\"t1\"]. 2. For statement \"GRANT ROLE r1, r2 ...\", `entity_names` = [\"r1\", \"r2\"]. 3. For statement \"ANALYZE\", `entity_names` = [].", +"items": { +"type": "string" +}, +"type": "array" +}, +"entityType": { +"description": "The entity type for the DDL statement, e.g. TABLE, INDEX, VIEW, etc. This field can be empty string for some DDL statement, e.g. for statement \"ANALYZE\", `entity_type` = \"\".", +"type": "string" +} +}, +"type": "object" +}, +"Delete": { +"description": "Arguments to delete operations.", +"id": "Delete", +"properties": { +"keySet": { +"$ref": "KeySet", +"description": "Required. The primary keys of the rows within table to delete. The primary keys must be specified in the order in which they appear in the `PRIMARY KEY()` clause of the table's equivalent DDL statement (the DDL statement used to create the table). Delete is idempotent. The transaction will succeed even if some or all rows do not exist." +}, +"table": { +"description": "Required. The table whose rows will be deleted.", +"type": "string" +} +}, +"type": "object" +}, +"DerivedMetric": { +"description": "A message representing a derived metric.", +"id": "DerivedMetric", +"properties": { +"denominator": { +"$ref": "LocalizedString", +"description": "The name of the denominator metric. e.g. \"rows\"." +}, +"numerator": { +"$ref": "LocalizedString", +"description": "The name of the numerator metric. e.g. \"latency\"." +} +}, +"type": "object" +}, +"DiagnosticMessage": { +"description": "A message representing the key visualizer diagnostic messages.", +"id": "DiagnosticMessage", +"properties": { +"info": { +"$ref": "LocalizedString", +"description": "Information about this diagnostic information." +}, +"metric": { +"$ref": "LocalizedString", +"description": "The metric." +}, +"metricSpecific": { +"description": "Whether this message is specific only for the current metric. By default Diagnostics are shown for all metrics, regardless which metric is the currently selected metric in the UI. However occasionally a metric will generate so many messages that the resulting visual clutter becomes overwhelming. In this case setting this to true, will show the diagnostic messages for that metric only if it is the currently selected metric.", +"type": "boolean" +}, +"severity": { +"description": "The severity of the diagnostic message.", +"enum": [ +"SEVERITY_UNSPECIFIED", +"INFO", +"WARNING", +"ERROR", +"FATAL" +], +"enumDescriptions": [ +"Required default value.", +"Lowest severity level \"Info\".", +"Middle severity level \"Warning\".", +"Severity level signaling an error \"Error\"", +"Severity level signaling a non recoverable error \"Fatal\"" +], +"type": "string" +}, +"shortMessage": { +"$ref": "LocalizedString", +"description": "The short message." +} +}, +"type": "object" +}, +"DirectedReadOptions": { +"description": "The DirectedReadOptions can be used to indicate which replicas or regions should be used for non-transactional reads or queries. DirectedReadOptions may only be specified for a read-only transaction, otherwise the API will return an `INVALID_ARGUMENT` error.", +"id": "DirectedReadOptions", +"properties": { +"excludeReplicas": { +"$ref": "ExcludeReplicas", +"description": "Exclude_replicas indicates that specified replicas should be excluded from serving requests. Spanner will not route requests to the replicas in this list." +}, +"includeReplicas": { +"$ref": "IncludeReplicas", +"description": "Include_replicas indicates the order of replicas (as they appear in this list) to process the request. If auto_failover_disabled is set to true and all replicas are exhausted without finding a healthy replica, Spanner will wait for a replica in the list to become available, requests may fail due to `DEADLINE_EXCEEDED` errors." +} +}, +"type": "object" +}, +"DualRegionQuorum": { +"description": "Message type for a dual-region quorum. Currently this type has no options.", +"id": "DualRegionQuorum", +"properties": {}, +"type": "object" +}, +"Empty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "Empty", +"properties": {}, +"type": "object" +}, +"EncryptionConfig": { +"description": "Encryption configuration for a Cloud Spanner database.", +"id": "EncryptionConfig", +"properties": { +"kmsKeyName": { +"description": "The Cloud KMS key to be used for encrypting and decrypting the database. Values are of the form `projects//locations//keyRings//cryptoKeys/`.", +"type": "string" +}, +"kmsKeyNames": { +"description": "Specifies the KMS configuration for one or more keys used to encrypt the database. Values are of the form `projects//locations//keyRings//cryptoKeys/`. The keys referenced by `kms_key_names` must fully cover all regions of the database's instance configuration. Some examples: * For regional (single-region) instance configurations, specify a regional location KMS key. * For multi-region instance configurations of type `GOOGLE_MANAGED`, either specify a multi-region location KMS key or multiple regional location KMS keys that cover all regions in the instance configuration. * For an instance configuration of type `USER_MANAGED`, specify only regional location KMS keys to cover each region in the instance configuration. Multi-region location KMS keys aren't supported for `USER_MANAGED` type instance configurations.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"EncryptionInfo": { +"description": "Encryption information for a Cloud Spanner database or backup.", +"id": "EncryptionInfo", +"properties": { +"encryptionStatus": { +"$ref": "Status", +"description": "Output only. If present, the status of a recent encrypt/decrypt call on underlying data for this database or backup. Regardless of status, data is always encrypted at rest.", +"readOnly": true +}, +"encryptionType": { +"description": "Output only. The type of encryption.", +"enum": [ +"TYPE_UNSPECIFIED", +"GOOGLE_DEFAULT_ENCRYPTION", +"CUSTOMER_MANAGED_ENCRYPTION" +], +"enumDescriptions": [ +"Encryption type was not specified, though data at rest remains encrypted.", +"The data is encrypted at rest with a key that is fully managed by Google. No key version or status will be populated. This is the default state.", +"The data is encrypted at rest with a key that is managed by the customer. The active version of the key. `kms_key_version` will be populated, and `encryption_status` may be populated." +], +"readOnly": true, +"type": "string" +}, +"kmsKeyVersion": { +"description": "Output only. A Cloud KMS key version that is being used to protect the database or backup.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"ExcludeReplicas": { +"description": "An ExcludeReplicas contains a repeated set of ReplicaSelection that should be excluded from serving requests.", +"id": "ExcludeReplicas", +"properties": { +"replicaSelections": { +"description": "The directed read replica selector.", +"items": { +"$ref": "ReplicaSelection" +}, +"type": "array" +} +}, +"type": "object" +}, +"ExecuteBatchDmlRequest": { +"description": "The request for ExecuteBatchDml.", +"id": "ExecuteBatchDmlRequest", +"properties": { +"requestOptions": { +"$ref": "RequestOptions", +"description": "Common options for this request." +}, +"seqno": { +"description": "Required. A per-transaction sequence number used to identify this request. This field makes each request idempotent such that if the request is received multiple times, at most one will succeed. The sequence number must be monotonically increasing within the transaction. If a request arrives for the first time with an out-of-order sequence number, the transaction may be aborted. Replays of previously handled requests will yield the same response as the first execution.", +"format": "int64", +"type": "string" +}, +"statements": { +"description": "Required. The list of statements to execute in this batch. Statements are executed serially, such that the effects of statement `i` are visible to statement `i+1`. Each statement must be a DML statement. Execution stops at the first failed statement; the remaining statements are not executed. Callers must provide at least one statement.", +"items": { +"$ref": "Statement" +}, +"type": "array" +}, +"transaction": { +"$ref": "TransactionSelector", +"description": "Required. The transaction to use. Must be a read-write transaction. To protect against replays, single-use transactions are not supported. The caller must either supply an existing transaction ID or begin a new transaction." +} +}, +"type": "object" +}, +"ExecuteBatchDmlResponse": { +"description": "The response for ExecuteBatchDml. Contains a list of ResultSet messages, one for each DML statement that has successfully executed, in the same order as the statements in the request. If a statement fails, the status in the response body identifies the cause of the failure. To check for DML statements that failed, use the following approach: 1. Check the status in the response message. The google.rpc.Code enum value `OK` indicates that all statements were executed successfully. 2. If the status was not `OK`, check the number of result sets in the response. If the response contains `N` ResultSet messages, then statement `N+1` in the request failed. Example 1: * Request: 5 DML statements, all executed successfully. * Response: 5 ResultSet messages, with the status `OK`. Example 2: * Request: 5 DML statements. The third statement has a syntax error. * Response: 2 ResultSet messages, and a syntax error (`INVALID_ARGUMENT`) status. The number of ResultSet messages indicates that the third statement failed, and the fourth and fifth statements were not executed.", +"id": "ExecuteBatchDmlResponse", +"properties": { +"precommitToken": { +"$ref": "MultiplexedSessionPrecommitToken", +"description": "Optional. A precommit token will be included if the read-write transaction is on a multiplexed session. The precommit token with the highest sequence number from this transaction attempt should be passed to the Commit request for this transaction." +}, +"resultSets": { +"description": "One ResultSet for each statement in the request that ran successfully, in the same order as the statements in the request. Each ResultSet does not contain any rows. The ResultSetStats in each ResultSet contain the number of rows modified by the statement. Only the first ResultSet in the response contains valid ResultSetMetadata.", +"items": { +"$ref": "ResultSet" +}, +"type": "array" +}, +"status": { +"$ref": "Status", +"description": "If all DML statements are executed successfully, the status is `OK`. Otherwise, the error status of the first failed statement." +} +}, +"type": "object" +}, +"ExecuteSqlRequest": { +"description": "The request for ExecuteSql and ExecuteStreamingSql.", +"id": "ExecuteSqlRequest", +"properties": { +"dataBoostEnabled": { +"description": "If this is for a partitioned query and this field is set to `true`, the request is executed with Spanner Data Boost independent compute resources. If the field is set to `true` but the request does not set `partition_token`, the API returns an `INVALID_ARGUMENT` error.", +"type": "boolean" +}, +"directedReadOptions": { +"$ref": "DirectedReadOptions", +"description": "Directed read options for this request." +}, +"paramTypes": { +"additionalProperties": { +"$ref": "Type" +}, +"description": "It is not always possible for Cloud Spanner to infer the right SQL type from a JSON value. For example, values of type `BYTES` and values of type `STRING` both appear in params as JSON strings. In these cases, `param_types` can be used to specify the exact SQL type for some or all of the SQL statement parameters. See the definition of Type for more information about SQL types.", +"type": "object" +}, +"params": { +"additionalProperties": { +"description": "Properties of the object.", +"type": "any" +}, +"description": "Parameter names and values that bind to placeholders in the SQL string. A parameter placeholder consists of the `@` character followed by the parameter name (for example, `@firstName`). Parameter names must conform to the naming requirements of identifiers as specified at https://cloud.google.com/spanner/docs/lexical#identifiers. Parameters can appear anywhere that a literal value is expected. The same parameter name can be used more than once, for example: `\"WHERE id > @msg_id AND id < @msg_id + 100\"` It is an error to execute a SQL statement with unbound parameters.", +"type": "object" +}, +"partitionToken": { +"description": "If present, results will be restricted to the specified partition previously created using PartitionQuery(). There must be an exact match for the values of fields common to this message and the PartitionQueryRequest message used to create this partition_token.", +"format": "byte", +"type": "string" +}, +"queryMode": { +"description": "Used to control the amount of debugging information returned in ResultSetStats. If partition_token is set, query_mode can only be set to QueryMode.NORMAL.", +"enum": [ +"NORMAL", +"PLAN", +"PROFILE", +"WITH_STATS", +"WITH_PLAN_AND_STATS" +], +"enumDescriptions": [ +"The default mode. Only the statement results are returned.", +"This mode returns only the query plan, without any results or execution statistics information.", +"This mode returns the query plan, overall execution statistics, operator level execution statistics along with the results. This has a performance overhead compared to the other modes. It is not recommended to use this mode for production traffic.", +"This mode returns the overall (but not operator-level) execution statistics along with the results.", +"This mode returns the query plan, overall (but not operator-level) execution statistics along with the results." +], +"type": "string" +}, +"queryOptions": { +"$ref": "QueryOptions", +"description": "Query optimizer configuration to use for the given query." +}, +"requestOptions": { +"$ref": "RequestOptions", +"description": "Common options for this request." +}, +"resumeToken": { +"description": "If this request is resuming a previously interrupted SQL statement execution, `resume_token` should be copied from the last PartialResultSet yielded before the interruption. Doing this enables the new SQL statement execution to resume where the last one left off. The rest of the request parameters must exactly match the request that yielded this token.", +"format": "byte", +"type": "string" +}, +"seqno": { +"description": "A per-transaction sequence number used to identify this request. This field makes each request idempotent such that if the request is received multiple times, at most one will succeed. The sequence number must be monotonically increasing within the transaction. If a request arrives for the first time with an out-of-order sequence number, the transaction may be aborted. Replays of previously handled requests will yield the same response as the first execution. Required for DML statements. Ignored for queries.", +"format": "int64", +"type": "string" +}, +"sql": { +"description": "Required. The SQL string.", +"type": "string" +}, +"transaction": { +"$ref": "TransactionSelector", +"description": "The transaction to use. For queries, if none is provided, the default is a temporary read-only transaction with strong concurrency. Standard DML statements require a read-write transaction. To protect against replays, single-use transactions are not supported. The caller must either supply an existing transaction ID or begin a new transaction. Partitioned DML requires an existing Partitioned DML transaction ID." +} +}, +"type": "object" +}, +"Expr": { +"description": "Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() < 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != 'private' && document.type != 'internal'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"'New message received at ' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.", +"id": "Expr", +"properties": { +"description": { +"description": "Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.", +"type": "string" +}, +"expression": { +"description": "Textual representation of an expression in Common Expression Language syntax.", +"type": "string" +}, +"location": { +"description": "Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.", +"type": "string" +}, +"title": { +"description": "Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.", +"type": "string" +} +}, +"type": "object" +}, +"Field": { +"description": "Message representing a single field of a struct.", +"id": "Field", +"properties": { +"name": { +"description": "The name of the field. For reads, this is the column name. For SQL queries, it is the column alias (e.g., `\"Word\"` in the query `\"SELECT 'hello' AS Word\"`), or the column name (e.g., `\"ColName\"` in the query `\"SELECT ColName FROM Table\"`). Some columns might have an empty name (e.g., `\"SELECT UPPER(ColName)\"`). Note that a query result can contain multiple fields with the same name.", +"type": "string" +}, +"type": { +"$ref": "Type", +"description": "The type of the field." +} +}, +"type": "object" +}, +"FreeInstanceMetadata": { +"description": "Free instance specific metadata that is kept even after an instance has been upgraded for tracking purposes.", +"id": "FreeInstanceMetadata", +"properties": { +"expireBehavior": { +"description": "Specifies the expiration behavior of a free instance. The default of ExpireBehavior is `REMOVE_AFTER_GRACE_PERIOD`. This can be modified during or after creation, and before expiration.", +"enum": [ +"EXPIRE_BEHAVIOR_UNSPECIFIED", +"FREE_TO_PROVISIONED", +"REMOVE_AFTER_GRACE_PERIOD" +], +"enumDescriptions": [ +"Not specified.", +"When the free instance expires, upgrade the instance to a provisioned instance.", +"When the free instance expires, disable the instance, and delete it after the grace period passes if it has not been upgraded." +], +"type": "string" +}, +"expireTime": { +"description": "Output only. Timestamp after which the instance will either be upgraded or scheduled for deletion after a grace period. ExpireBehavior is used to choose between upgrading or scheduling the free instance for deletion. This timestamp is set during the creation of a free instance.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"upgradeTime": { +"description": "Output only. If present, the timestamp at which the free instance was upgraded to a provisioned instance.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"FullBackupSpec": { +"description": "The specification for full backups. A full backup stores the entire contents of the database at a given version time.", +"id": "FullBackupSpec", +"properties": {}, +"type": "object" +}, +"GetDatabaseDdlResponse": { +"description": "The response for GetDatabaseDdl.", +"id": "GetDatabaseDdlResponse", +"properties": { +"protoDescriptors": { +"description": "Proto descriptors stored in the database. Contains a protobuf-serialized [google.protobuf.FileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).", +"format": "byte", +"type": "string" +}, +"statements": { +"description": "A list of formatted DDL statements defining the schema of the database specified in the request.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GetIamPolicyRequest": { +"description": "Request message for `GetIamPolicy` method.", +"id": "GetIamPolicyRequest", +"properties": { +"options": { +"$ref": "GetPolicyOptions", +"description": "OPTIONAL: A `GetPolicyOptions` object for specifying options to `GetIamPolicy`." +} +}, +"type": "object" +}, +"GetPolicyOptions": { +"description": "Encapsulates settings provided to GetIamPolicy.", +"id": "GetPolicyOptions", +"properties": { +"requestedPolicyVersion": { +"description": "Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"IncludeReplicas": { +"description": "An IncludeReplicas contains a repeated set of ReplicaSelection which indicates the order in which replicas should be considered.", +"id": "IncludeReplicas", +"properties": { +"autoFailoverDisabled": { +"description": "If true, Spanner will not route requests to a replica outside the include_replicas list when all of the specified replicas are unavailable or unhealthy. Default value is `false`.", +"type": "boolean" +}, +"replicaSelections": { +"description": "The directed read replica selector.", +"items": { +"$ref": "ReplicaSelection" +}, +"type": "array" +} +}, +"type": "object" +}, +"IncrementalBackupSpec": { +"description": "The specification for incremental backup chains. An incremental backup stores the delta of changes between a previous backup and the database contents at a given version time. An incremental backup chain consists of a full backup and zero or more successive incremental backups. The first backup created for an incremental backup chain is always a full backup.", +"id": "IncrementalBackupSpec", +"properties": {}, +"type": "object" +}, +"IndexAdvice": { +"description": "Recommendation to add new indexes to run queries more efficiently.", +"id": "IndexAdvice", +"properties": { +"ddl": { +"description": "Optional. DDL statements to add new indexes that will improve the query.", +"items": { +"type": "string" +}, +"type": "array" +}, +"improvementFactor": { +"description": "Optional. Estimated latency improvement factor. For example if the query currently takes 500 ms to run and the estimated latency with new indexes is 100 ms this field will be 5.", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"IndexedHotKey": { +"description": "A message representing a (sparse) collection of hot keys for specific key buckets.", +"id": "IndexedHotKey", +"properties": { +"sparseHotKeys": { +"additionalProperties": { +"format": "int32", +"type": "integer" +}, +"description": "A (sparse) mapping from key bucket index to the index of the specific hot row key for that key bucket. The index of the hot row key can be translated to the actual row key via the ScanData.VisualizationData.indexed_keys repeated field.", +"type": "object" +} +}, +"type": "object" +}, +"IndexedKeyRangeInfos": { +"description": "A message representing a (sparse) collection of KeyRangeInfos for specific key buckets.", +"id": "IndexedKeyRangeInfos", +"properties": { +"keyRangeInfos": { +"additionalProperties": { +"$ref": "KeyRangeInfos" +}, +"description": "A (sparse) mapping from key bucket index to the KeyRangeInfos for that key bucket.", +"type": "object" +} +}, +"type": "object" +}, +"Instance": { +"description": "An isolated set of Cloud Spanner resources on which databases can be hosted.", +"id": "Instance", +"properties": { +"autoscalingConfig": { +"$ref": "AutoscalingConfig", +"description": "Optional. The autoscaling configuration. Autoscaling is enabled if this field is set. When autoscaling is enabled, node_count and processing_units are treated as OUTPUT_ONLY fields and reflect the current compute capacity allocated to the instance." +}, +"config": { +"description": "Required. The name of the instance's configuration. Values are of the form `projects//instanceConfigs/`. See also InstanceConfig and ListInstanceConfigs.", +"type": "string" +}, +"createTime": { +"description": "Output only. The time at which the instance was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"defaultBackupScheduleType": { +"description": "Optional. Controls the default backup behavior for new databases within the instance. Note that `AUTOMATIC` is not permitted for free instances, as backups and backup schedules are not allowed for free instances. In the `GetInstance` or `ListInstances` response, if the value of default_backup_schedule_type is unset or NONE, no default backup schedule will be created for new databases within the instance.", +"enum": [ +"DEFAULT_BACKUP_SCHEDULE_TYPE_UNSPECIFIED", +"NONE", +"AUTOMATIC" +], +"enumDescriptions": [ +"Not specified.", +"No default backup schedule will be created automatically on creation of a database within the instance.", +"A default backup schedule will be created automatically on creation of a database within the instance. Once created, the default backup schedule can be edited or deleted just like any other backup schedule. Currently, the default backup schedule creates a full backup every 24 hours and retains the backup for a period of 7 days." +], +"type": "string" +}, +"displayName": { +"description": "Required. The descriptive name for this instance as it appears in UIs. Must be unique per project and between 4 and 30 characters in length.", +"type": "string" +}, +"edition": { +"description": "Optional. The `Edition` of the current instance.", +"enum": [ +"EDITION_UNSPECIFIED", +"STANDARD", +"ENTERPRISE", +"ENTERPRISE_PLUS" +], +"enumDescriptions": [ +"Edition not specified.", +"Standard edition.", +"Enterprise edition.", +"Enterprise Plus edition." +], +"type": "string" +}, +"endpointUris": { +"description": "Deprecated. This field is not populated.", +"items": { +"type": "string" +}, +"type": "array" +}, +"freeInstanceMetadata": { +"$ref": "FreeInstanceMetadata", +"description": "Free instance metadata. Only populated for free instances." +}, +"instanceType": { +"description": "The `InstanceType` of the current instance.", +"enum": [ +"INSTANCE_TYPE_UNSPECIFIED", +"PROVISIONED", +"FREE_INSTANCE" +], +"enumDescriptions": [ +"Not specified.", +"Provisioned instances have dedicated resources, standard usage limits and support.", +"Free instances provide no guarantee for dedicated resources, [node_count, processing_units] should be 0. They come with stricter usage limits and limited support." +], +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer's organizational needs and deployment strategies. Cloud Labels can be used to filter collections of resources. They can be used to control how resource metrics are aggregated. And they can be used as arguments to policy management rules (e.g. route, firewall, load balancing, etc.). * Label keys must be between 1 and 63 characters long and must conform to the following regular expression: `a-z{0,62}`. * Label values must be between 0 and 63 characters long and must conform to the regular expression `[a-z0-9_-]{0,63}`. * No more than 64 labels can be associated with a given resource. See https://goo.gl/xmQnxf for more information on and examples of labels. If you plan to use labels in your own code, please note that additional characters may be allowed in the future. And so you are advised to use an internal label representation, such as JSON, which doesn't rely upon specific characters being disallowed. For example, representing labels as the string: name + \"_\" + value would prove problematic if we were to allow \"_\" in a future release.", +"type": "object" +}, +"name": { +"description": "Required. A unique identifier for the instance, which cannot be changed after the instance is created. Values are of the form `projects//instances/a-z*[a-z0-9]`. The final segment of the name must be between 2 and 64 characters in length.", +"type": "string" +}, +"nodeCount": { +"description": "The number of nodes allocated to this instance. At most, one of either `node_count` or `processing_units` should be present in the message. Users can set the `node_count` field to specify the target number of nodes allocated to the instance. If autoscaling is enabled, `node_count` is treated as an `OUTPUT_ONLY` field and reflects the current number of nodes allocated to the instance. This might be zero in API responses for instances that are not yet in the `READY` state. For more information, see [Compute capacity, nodes, and processing units](https://cloud.google.com/spanner/docs/compute-capacity).", +"format": "int32", +"type": "integer" +}, +"processingUnits": { +"description": "The number of processing units allocated to this instance. At most, one of either `processing_units` or `node_count` should be present in the message. Users can set the `processing_units` field to specify the target number of processing units allocated to the instance. If autoscaling is enabled, `processing_units` is treated as an `OUTPUT_ONLY` field and reflects the current number of processing units allocated to the instance. This might be zero in API responses for instances that are not yet in the `READY` state. For more information, see [Compute capacity, nodes and processing units](https://cloud.google.com/spanner/docs/compute-capacity).", +"format": "int32", +"type": "integer" +}, +"replicaComputeCapacity": { +"description": "Output only. Lists the compute capacity per ReplicaSelection. A replica selection identifies a set of replicas with common properties. Replicas identified by a ReplicaSelection are scaled with the same compute capacity.", +"items": { +"$ref": "ReplicaComputeCapacity" +}, +"readOnly": true, +"type": "array" +}, +"state": { +"description": "Output only. The current instance state. For CreateInstance, the state must be either omitted or set to `CREATING`. For UpdateInstance, the state must be either omitted or set to `READY`.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY" +], +"enumDescriptions": [ +"Not specified.", +"The instance is still being created. Resources may not be available yet, and operations such as database creation may not work.", +"The instance is fully created and ready to do work such as creating databases." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time at which the instance was most recently updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"InstanceConfig": { +"description": "A possible configuration for a Cloud Spanner instance. Configurations define the geographic placement of nodes and their replication.", +"id": "InstanceConfig", +"properties": { +"baseConfig": { +"description": "Base configuration name, e.g. projects//instanceConfigs/nam3, based on which this configuration is created. Only set for user-managed configurations. `base_config` must refer to a configuration of type `GOOGLE_MANAGED` in the same project as this configuration.", +"type": "string" +}, +"configType": { +"description": "Output only. Whether this instance configuration is a Google-managed or user-managed configuration.", +"enum": [ +"TYPE_UNSPECIFIED", +"GOOGLE_MANAGED", +"USER_MANAGED" +], +"enumDescriptions": [ +"Unspecified.", +"Google-managed configuration.", +"User-managed configuration." +], +"readOnly": true, +"type": "string" +}, +"displayName": { +"description": "The name of this instance configuration as it appears in UIs.", +"type": "string" +}, +"etag": { +"description": "etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a instance configuration from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform instance configuration updates in order to avoid race conditions: An etag is returned in the response which contains instance configurations, and systems are expected to put that etag in the request to update instance configuration to ensure that their change is applied to the same version of the instance configuration. If no etag is provided in the call to update the instance configuration, then the existing instance configuration is overwritten blindly.", +"type": "string" +}, +"freeInstanceAvailability": { +"description": "Output only. Describes whether free instances are available to be created in this instance configuration.", +"enum": [ +"FREE_INSTANCE_AVAILABILITY_UNSPECIFIED", +"AVAILABLE", +"UNSUPPORTED", +"DISABLED", +"QUOTA_EXCEEDED" +], +"enumDescriptions": [ +"Not specified.", +"Indicates that free instances are available to be created in this instance configuration.", +"Indicates that free instances are not supported in this instance configuration.", +"Indicates that free instances are currently not available to be created in this instance configuration.", +"Indicates that additional free instances cannot be created in this instance configuration because the project has reached its limit of free instances." +], +"readOnly": true, +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "Cloud Labels are a flexible and lightweight mechanism for organizing cloud resources into groups that reflect a customer's organizational needs and deployment strategies. Cloud Labels can be used to filter collections of resources. They can be used to control how resource metrics are aggregated. And they can be used as arguments to policy management rules (e.g. route, firewall, load balancing, etc.). * Label keys must be between 1 and 63 characters long and must conform to the following regular expression: `a-z{0,62}`. * Label values must be between 0 and 63 characters long and must conform to the regular expression `[a-z0-9_-]{0,63}`. * No more than 64 labels can be associated with a given resource. See https://goo.gl/xmQnxf for more information on and examples of labels. If you plan to use labels in your own code, please note that additional characters may be allowed in the future. Therefore, you are advised to use an internal label representation, such as JSON, which doesn't rely upon specific characters being disallowed. For example, representing labels as the string: name + \"_\" + value would prove problematic if we were to allow \"_\" in a future release.", +"type": "object" +}, +"leaderOptions": { +"description": "Allowed values of the \"default_leader\" schema option for databases in instances that use this instance configuration.", +"items": { +"type": "string" +}, +"type": "array" +}, +"name": { +"description": "A unique identifier for the instance configuration. Values are of the form `projects//instanceConfigs/a-z*`. User instance configuration must start with `custom-`.", +"type": "string" +}, +"optionalReplicas": { +"description": "Output only. The available optional replicas to choose from for user-managed configurations. Populated for Google-managed configurations.", +"items": { +"$ref": "ReplicaInfo" +}, +"readOnly": true, +"type": "array" +}, +"quorumType": { +"description": "Output only. The `QuorumType` of the instance configuration.", +"enum": [ +"QUORUM_TYPE_UNSPECIFIED", +"REGION", +"DUAL_REGION", +"MULTI_REGION" +], +"enumDescriptions": [ +"Quorum type not specified.", +"An instance configuration tagged with `REGION` quorum type forms a write quorum in a single region.", +"An instance configuration tagged with the `DUAL_REGION` quorum type forms a write quorum with exactly two read-write regions in a multi-region configuration. This instance configuration requires failover in the event of regional failures.", +"An instance configuration tagged with the `MULTI_REGION` quorum type forms a write quorum from replicas that are spread across more than one region in a multi-region configuration." +], +"readOnly": true, +"type": "string" +}, +"reconciling": { +"description": "Output only. If true, the instance configuration is being created or updated. If false, there are no ongoing operations for the instance configuration.", +"readOnly": true, +"type": "boolean" +}, +"replicas": { +"description": "The geographic placement of nodes in this instance configuration and their replication properties. To create user-managed configurations, input `replicas` must include all replicas in `replicas` of the `base_config` and include one or more replicas in the `optional_replicas` of the `base_config`.", +"items": { +"$ref": "ReplicaInfo" +}, +"type": "array" +}, +"state": { +"description": "Output only. The current instance configuration state. Applicable only for `USER_MANAGED` configurations.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY" +], +"enumDescriptions": [ +"Not specified.", +"The instance configuration is still being created.", +"The instance configuration is fully created and ready to be used to create instances." +], +"readOnly": true, +"type": "string" +}, +"storageLimitPerProcessingUnit": { +"description": "Output only. The storage limit in bytes per processing unit.", +"format": "int64", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"InstanceOperationProgress": { +"description": "Encapsulates progress related information for a Cloud Spanner long running instance operations.", +"id": "InstanceOperationProgress", +"properties": { +"endTime": { +"description": "If set, the time at which this operation failed or was completed successfully.", +"format": "google-datetime", +"type": "string" +}, +"progressPercent": { +"description": "Percent completion of the operation. Values are between 0 and 100 inclusive.", +"format": "int32", +"type": "integer" +}, +"startTime": { +"description": "Time the request was received.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"InstancePartition": { +"description": "An isolated set of Cloud Spanner resources that databases can define placements on.", +"id": "InstancePartition", +"properties": { +"config": { +"description": "Required. The name of the instance partition's configuration. Values are of the form `projects//instanceConfigs/`. See also InstanceConfig and ListInstanceConfigs.", +"type": "string" +}, +"createTime": { +"description": "Output only. The time at which the instance partition was created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"displayName": { +"description": "Required. The descriptive name for this instance partition as it appears in UIs. Must be unique per project and between 4 and 30 characters in length.", +"type": "string" +}, +"etag": { +"description": "Used for optimistic concurrency control as a way to help prevent simultaneous updates of a instance partition from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform instance partition updates in order to avoid race conditions: An etag is returned in the response which contains instance partitions, and systems are expected to put that etag in the request to update instance partitions to ensure that their change will be applied to the same version of the instance partition. If no etag is provided in the call to update instance partition, then the existing instance partition is overwritten blindly.", +"type": "string" +}, +"name": { +"description": "Required. A unique identifier for the instance partition. Values are of the form `projects//instances//instancePartitions/a-z*[a-z0-9]`. The final segment of the name must be between 2 and 64 characters in length. An instance partition's name cannot be changed after the instance partition is created.", +"type": "string" +}, +"nodeCount": { +"description": "The number of nodes allocated to this instance partition. Users can set the `node_count` field to specify the target number of nodes allocated to the instance partition. This may be zero in API responses for instance partitions that are not yet in state `READY`.", +"format": "int32", +"type": "integer" +}, +"processingUnits": { +"description": "The number of processing units allocated to this instance partition. Users can set the `processing_units` field to specify the target number of processing units allocated to the instance partition. This might be zero in API responses for instance partitions that are not yet in the `READY` state.", +"format": "int32", +"type": "integer" +}, +"referencingBackups": { +"deprecated": true, +"description": "Output only. Deprecated: This field is not populated. Output only. The names of the backups that reference this instance partition. Referencing backups should share the parent instance. The existence of any referencing backup prevents the instance partition from being deleted.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"referencingDatabases": { +"description": "Output only. The names of the databases that reference this instance partition. Referencing databases should share the parent instance. The existence of any referencing database prevents the instance partition from being deleted.", +"items": { +"type": "string" +}, +"readOnly": true, +"type": "array" +}, +"state": { +"description": "Output only. The current instance partition state.", +"enum": [ +"STATE_UNSPECIFIED", +"CREATING", +"READY" +], +"enumDescriptions": [ +"Not specified.", +"The instance partition is still being created. Resources may not be available yet, and operations such as creating placements using this instance partition may not work.", +"The instance partition is fully created and ready to do work such as creating placements and using in databases." +], +"readOnly": true, +"type": "string" +}, +"updateTime": { +"description": "Output only. The time at which the instance partition was most recently updated.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"InstanceReplicaSelection": { +"description": "ReplicaSelection identifies replicas with common properties.", +"id": "InstanceReplicaSelection", +"properties": { +"location": { +"description": "Required. Name of the location of the replicas (e.g., \"us-central1\").", +"type": "string" +} +}, +"type": "object" +}, +"KeyRange": { +"description": "KeyRange represents a range of rows in a table or index. A range has a start key and an end key. These keys can be open or closed, indicating if the range includes rows with that key. Keys are represented by lists, where the ith value in the list corresponds to the ith component of the table or index primary key. Individual values are encoded as described here. For example, consider the following table definition: CREATE TABLE UserEvents ( UserName STRING(MAX), EventDate STRING(10) ) PRIMARY KEY(UserName, EventDate); The following keys name rows in this table: \"Bob\", \"2014-09-23\" Since the `UserEvents` table's `PRIMARY KEY` clause names two columns, each `UserEvents` key has two elements; the first is the `UserName`, and the second is the `EventDate`. Key ranges with multiple components are interpreted lexicographically by component using the table or index key's declared sort order. For example, the following range returns all events for user `\"Bob\"` that occurred in the year 2015: \"start_closed\": [\"Bob\", \"2015-01-01\"] \"end_closed\": [\"Bob\", \"2015-12-31\"] Start and end keys can omit trailing key components. This affects the inclusion and exclusion of rows that exactly match the provided key components: if the key is closed, then rows that exactly match the provided components are included; if the key is open, then rows that exactly match are not included. For example, the following range includes all events for `\"Bob\"` that occurred during and after the year 2000: \"start_closed\": [\"Bob\", \"2000-01-01\"] \"end_closed\": [\"Bob\"] The next example retrieves all events for `\"Bob\"`: \"start_closed\": [\"Bob\"] \"end_closed\": [\"Bob\"] To retrieve events before the year 2000: \"start_closed\": [\"Bob\"] \"end_open\": [\"Bob\", \"2000-01-01\"] The following range includes all rows in the table: \"start_closed\": [] \"end_closed\": [] This range returns all users whose `UserName` begins with any character from A to C: \"start_closed\": [\"A\"] \"end_open\": [\"D\"] This range returns all users whose `UserName` begins with B: \"start_closed\": [\"B\"] \"end_open\": [\"C\"] Key ranges honor column sort order. For example, suppose a table is defined as follows: CREATE TABLE DescendingSortedTable { Key INT64, ... ) PRIMARY KEY(Key DESC); The following range retrieves all rows with key values between 1 and 100 inclusive: \"start_closed\": [\"100\"] \"end_closed\": [\"1\"] Note that 100 is passed as the start, and 1 is passed as the end, because `Key` is a descending column in the schema.", +"id": "KeyRange", +"properties": { +"endClosed": { +"description": "If the end is closed, then the range includes all rows whose first `len(end_closed)` key columns exactly match `end_closed`.", +"items": { +"type": "any" +}, +"type": "array" +}, +"endOpen": { +"description": "If the end is open, then the range excludes rows whose first `len(end_open)` key columns exactly match `end_open`.", +"items": { +"type": "any" +}, +"type": "array" +}, +"startClosed": { +"description": "If the start is closed, then the range includes all rows whose first `len(start_closed)` key columns exactly match `start_closed`.", +"items": { +"type": "any" +}, +"type": "array" +}, +"startOpen": { +"description": "If the start is open, then the range excludes rows whose first `len(start_open)` key columns exactly match `start_open`.", +"items": { +"type": "any" +}, +"type": "array" +} +}, +"type": "object" +}, +"KeyRangeInfo": { +"description": "A message representing information for a key range (possibly one key).", +"id": "KeyRangeInfo", +"properties": { +"contextValues": { +"description": "The list of context values for this key range.", +"items": { +"$ref": "ContextValue" +}, +"type": "array" +}, +"endKeyIndex": { +"description": "The index of the end key in indexed_keys.", +"format": "int32", +"type": "integer" +}, +"info": { +"$ref": "LocalizedString", +"description": "Information about this key range, for all metrics." +}, +"keysCount": { +"description": "The number of keys this range covers.", +"format": "int64", +"type": "string" +}, +"metric": { +"$ref": "LocalizedString", +"description": "The name of the metric. e.g. \"latency\"." +}, +"startKeyIndex": { +"description": "The index of the start key in indexed_keys.", +"format": "int32", +"type": "integer" +}, +"timeOffset": { +"description": "The time offset. This is the time since the start of the time interval.", +"format": "google-duration", +"type": "string" +}, +"unit": { +"$ref": "LocalizedString", +"description": "The unit of the metric. This is an unstructured field and will be mapped as is to the user." +}, +"value": { +"description": "The value of the metric.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"KeyRangeInfos": { +"description": "A message representing a list of specific information for multiple key ranges.", +"id": "KeyRangeInfos", +"properties": { +"infos": { +"description": "The list individual KeyRangeInfos.", +"items": { +"$ref": "KeyRangeInfo" +}, +"type": "array" +}, +"totalSize": { +"description": "The total size of the list of all KeyRangeInfos. This may be larger than the number of repeated messages above. If that is the case, this number may be used to determine how many are not being shown.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"KeySet": { +"description": "`KeySet` defines a collection of Cloud Spanner keys and/or key ranges. All the keys are expected to be in the same table or index. The keys need not be sorted in any particular way. If the same key is specified multiple times in the set (for example if two ranges, two keys, or a key and a range overlap), Cloud Spanner behaves as if the key were only specified once.", +"id": "KeySet", +"properties": { +"all": { +"description": "For convenience `all` can be set to `true` to indicate that this `KeySet` matches all keys in the table or index. Note that any keys specified in `keys` or `ranges` are only yielded once.", +"type": "boolean" +}, +"keys": { +"description": "A list of specific keys. Entries in `keys` should have exactly as many elements as there are columns in the primary or index key with which this `KeySet` is used. Individual key values are encoded as described here.", +"items": { +"items": { +"type": "any" +}, +"type": "array" +}, +"type": "array" +}, +"ranges": { +"description": "A list of key ranges. See KeyRange for more information about key range specifications.", +"items": { +"$ref": "KeyRange" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListBackupOperationsResponse": { +"description": "The response for ListBackupOperations.", +"id": "ListBackupOperationsResponse", +"properties": { +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListBackupOperations call to fetch more of the matching metadata.", +"type": "string" +}, +"operations": { +"description": "The list of matching backup long-running operations. Each operation's name will be prefixed by the backup's name. The operation's metadata field type `metadata.type_url` describes the type of the metadata. Operations returned include those that are pending or have completed/failed/canceled within the last 7 days. Operations returned are ordered by `operation.metadata.value.progress.start_time` in descending order starting from the most recently started operation.", +"items": { +"$ref": "Operation" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListBackupSchedulesResponse": { +"description": "The response for ListBackupSchedules.", +"id": "ListBackupSchedulesResponse", +"properties": { +"backupSchedules": { +"description": "The list of backup schedules for a database.", +"items": { +"$ref": "BackupSchedule" +}, +"type": "array" +}, +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListBackupSchedules call to fetch more of the schedules.", +"type": "string" +} +}, +"type": "object" +}, +"ListBackupsResponse": { +"description": "The response for ListBackups.", +"id": "ListBackupsResponse", +"properties": { +"backups": { +"description": "The list of matching backups. Backups returned are ordered by `create_time` in descending order, starting from the most recent `create_time`.", +"items": { +"$ref": "Backup" +}, +"type": "array" +}, +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListBackups call to fetch more of the matching backups.", +"type": "string" +} +}, +"type": "object" +}, +"ListDatabaseOperationsResponse": { +"description": "The response for ListDatabaseOperations.", +"id": "ListDatabaseOperationsResponse", +"properties": { +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListDatabaseOperations call to fetch more of the matching metadata.", +"type": "string" +}, +"operations": { +"description": "The list of matching database long-running operations. Each operation's name will be prefixed by the database's name. The operation's metadata field type `metadata.type_url` describes the type of the metadata.", +"items": { +"$ref": "Operation" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListDatabaseRolesResponse": { +"description": "The response for ListDatabaseRoles.", +"id": "ListDatabaseRolesResponse", +"properties": { +"databaseRoles": { +"description": "Database roles that matched the request.", +"items": { +"$ref": "DatabaseRole" +}, +"type": "array" +}, +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListDatabaseRoles call to fetch more of the matching roles.", +"type": "string" +} +}, +"type": "object" +}, +"ListDatabasesResponse": { +"description": "The response for ListDatabases.", +"id": "ListDatabasesResponse", +"properties": { +"databases": { +"description": "Databases that matched the request.", +"items": { +"$ref": "Database" +}, +"type": "array" +}, +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListDatabases call to fetch more of the matching databases.", +"type": "string" +} +}, +"type": "object" +}, +"ListInstanceConfigOperationsResponse": { +"description": "The response for ListInstanceConfigOperations.", +"id": "ListInstanceConfigOperationsResponse", +"properties": { +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListInstanceConfigOperations call to fetch more of the matching metadata.", +"type": "string" +}, +"operations": { +"description": "The list of matching instance configuration long-running operations. Each operation's name will be prefixed by the name of the instance configuration. The operation's metadata field type `metadata.type_url` describes the type of the metadata.", +"items": { +"$ref": "Operation" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListInstanceConfigsResponse": { +"description": "The response for ListInstanceConfigs.", +"id": "ListInstanceConfigsResponse", +"properties": { +"instanceConfigs": { +"description": "The list of requested instance configurations.", +"items": { +"$ref": "InstanceConfig" +}, +"type": "array" +}, +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListInstanceConfigs call to fetch more of the matching instance configurations.", +"type": "string" +} +}, +"type": "object" +}, +"ListInstancePartitionOperationsResponse": { +"description": "The response for ListInstancePartitionOperations.", +"id": "ListInstancePartitionOperationsResponse", +"properties": { +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListInstancePartitionOperations call to fetch more of the matching metadata.", +"type": "string" +}, +"operations": { +"description": "The list of matching instance partition long-running operations. Each operation's name will be prefixed by the instance partition's name. The operation's metadata field type `metadata.type_url` describes the type of the metadata.", +"items": { +"$ref": "Operation" +}, +"type": "array" +}, +"unreachableInstancePartitions": { +"description": "The list of unreachable instance partitions. It includes the names of instance partitions whose operation metadata could not be retrieved within instance_partition_deadline.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListInstancePartitionsResponse": { +"description": "The response for ListInstancePartitions.", +"id": "ListInstancePartitionsResponse", +"properties": { +"instancePartitions": { +"description": "The list of requested instancePartitions.", +"items": { +"$ref": "InstancePartition" +}, +"type": "array" +}, +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListInstancePartitions call to fetch more of the matching instance partitions.", +"type": "string" +}, +"unreachable": { +"description": "The list of unreachable instances or instance partitions. It includes the names of instances or instance partitions whose metadata could not be retrieved within instance_partition_deadline.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListInstancesResponse": { +"description": "The response for ListInstances.", +"id": "ListInstancesResponse", +"properties": { +"instances": { +"description": "The list of requested instances.", +"items": { +"$ref": "Instance" +}, +"type": "array" +}, +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListInstances call to fetch more of the matching instances.", +"type": "string" +}, +"unreachable": { +"description": "The list of unreachable instances. It includes the names of instances whose metadata could not be retrieved within instance_deadline.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListOperationsResponse": { +"description": "The response message for Operations.ListOperations.", +"id": "ListOperationsResponse", +"properties": { +"nextPageToken": { +"description": "The standard List next-page token.", +"type": "string" +}, +"operations": { +"description": "A list of operations that matches the specified filter in the request.", +"items": { +"$ref": "Operation" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListScansResponse": { +"description": "Response method from the ListScans method.", +"id": "ListScansResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"scans": { +"description": "Available scans based on the list query parameters.", +"items": { +"$ref": "Scan" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListSessionsResponse": { +"description": "The response for ListSessions.", +"id": "ListSessionsResponse", +"properties": { +"nextPageToken": { +"description": "`next_page_token` can be sent in a subsequent ListSessions call to fetch more of the matching sessions.", +"type": "string" +}, +"sessions": { +"description": "The list of requested sessions.", +"items": { +"$ref": "Session" +}, +"type": "array" +} +}, +"type": "object" +}, +"LocalizedString": { +"description": "A message representing a user-facing string whose value may need to be translated before being displayed.", +"id": "LocalizedString", +"properties": { +"args": { +"additionalProperties": { +"type": "string" +}, +"description": "A map of arguments used when creating the localized message. Keys represent parameter names which may be used by the localized version when substituting dynamic values.", +"type": "object" +}, +"message": { +"description": "The canonical English version of this message. If no token is provided or the front-end has no message associated with the token, this text will be displayed as-is.", +"type": "string" +}, +"token": { +"description": "The token identifying the message, e.g. 'METRIC_READ_CPU'. This should be unique within the service.", +"type": "string" +} +}, +"type": "object" +}, +"Metric": { +"description": "A message representing the actual monitoring data, values for each key bucket over time, of a metric.", +"id": "Metric", +"properties": { +"aggregation": { +"description": "The aggregation function used to aggregate each key bucket", +"enum": [ +"AGGREGATION_UNSPECIFIED", +"MAX", +"SUM" +], +"enumDescriptions": [ +"Required default value.", +"Use the maximum of all values.", +"Use the sum of all values." +], +"type": "string" +}, +"category": { +"$ref": "LocalizedString", +"description": "The category of the metric, e.g. \"Activity\", \"Alerts\", \"Reads\", etc." +}, +"derived": { +"$ref": "DerivedMetric", +"description": "The references to numerator and denominator metrics for a derived metric." +}, +"displayLabel": { +"$ref": "LocalizedString", +"description": "The displayed label of the metric." +}, +"hasNonzeroData": { +"description": "Whether the metric has any non-zero data.", +"type": "boolean" +}, +"hotValue": { +"description": "The value that is considered hot for the metric. On a per metric basis hotness signals high utilization and something that might potentially be a cause for concern by the end user. hot_value is used to calibrate and scale visual color scales.", +"format": "float", +"type": "number" +}, +"indexedHotKeys": { +"additionalProperties": { +"$ref": "IndexedHotKey" +}, +"description": "The (sparse) mapping from time index to an IndexedHotKey message, representing those time intervals for which there are hot keys.", +"type": "object" +}, +"indexedKeyRangeInfos": { +"additionalProperties": { +"$ref": "IndexedKeyRangeInfos" +}, +"description": "The (sparse) mapping from time interval index to an IndexedKeyRangeInfos message, representing those time intervals for which there are informational messages concerning key ranges.", +"type": "object" +}, +"info": { +"$ref": "LocalizedString", +"description": "Information about the metric." +}, +"matrix": { +"$ref": "MetricMatrix", +"description": "The data for the metric as a matrix." +}, +"unit": { +"$ref": "LocalizedString", +"description": "The unit of the metric." +}, +"visible": { +"description": "Whether the metric is visible to the end user.", +"type": "boolean" +} +}, +"type": "object" +}, +"MetricMatrix": { +"description": "A message representing a matrix of floats.", +"id": "MetricMatrix", +"properties": { +"rows": { +"description": "The rows of the matrix.", +"items": { +"$ref": "MetricMatrixRow" +}, +"type": "array" +} +}, +"type": "object" +}, +"MetricMatrixRow": { +"description": "A message representing a row of a matrix of floats.", +"id": "MetricMatrixRow", +"properties": { +"cols": { +"description": "The columns of the row.", +"items": { +"format": "float", +"type": "number" +}, +"type": "array" +} +}, +"type": "object" +}, +"MoveInstanceRequest": { +"description": "The request for MoveInstance.", +"id": "MoveInstanceRequest", +"properties": { +"targetConfig": { +"description": "Required. The target instance configuration where to move the instance. Values are of the form `projects//instanceConfigs/`.", +"type": "string" +} +}, +"type": "object" +}, +"MultiplexedSessionPrecommitToken": { +"description": "When a read-write transaction is executed on a multiplexed session, this precommit token is sent back to the client as a part of the [Transaction] message in the BeginTransaction response and also as a part of the [ResultSet] and [PartialResultSet] responses.", +"id": "MultiplexedSessionPrecommitToken", +"properties": { +"precommitToken": { +"description": "Opaque precommit token.", +"format": "byte", +"type": "string" +}, +"seqNum": { +"description": "An incrementing seq number is generated on every precommit token that is returned. Clients should remember the precommit token with the highest sequence number from the current transaction attempt.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"Mutation": { +"description": "A modification to one or more Cloud Spanner rows. Mutations can be applied to a Cloud Spanner database by sending them in a Commit call.", +"id": "Mutation", +"properties": { +"delete": { +"$ref": "Delete", +"description": "Delete rows from a table. Succeeds whether or not the named rows were present." +}, +"insert": { +"$ref": "Write", +"description": "Insert new rows in a table. If any of the rows already exist, the write or transaction fails with error `ALREADY_EXISTS`." +}, +"insertOrUpdate": { +"$ref": "Write", +"description": "Like insert, except that if the row already exists, then its column values are overwritten with the ones provided. Any column values not explicitly written are preserved. When using insert_or_update, just as when using insert, all `NOT NULL` columns in the table must be given a value. This holds true even when the row already exists and will therefore actually be updated." +}, +"replace": { +"$ref": "Write", +"description": "Like insert, except that if the row already exists, it is deleted, and the column values provided are inserted instead. Unlike insert_or_update, this means any values not explicitly written become `NULL`. In an interleaved table, if you create the child table with the `ON DELETE CASCADE` annotation, then replacing a parent row also deletes the child rows. Otherwise, you must delete the child rows before you replace the parent row." +}, +"update": { +"$ref": "Write", +"description": "Update existing rows in a table. If any of the rows does not already exist, the transaction fails with error `NOT_FOUND`." +} +}, +"type": "object" +}, +"MutationGroup": { +"description": "A group of mutations to be committed together. Related mutations should be placed in a group. For example, two mutations inserting rows with the same primary key prefix in both parent and child tables are related.", +"id": "MutationGroup", +"properties": { +"mutations": { +"description": "Required. The mutations in this group.", +"items": { +"$ref": "Mutation" +}, +"type": "array" +} +}, +"type": "object" +}, +"Operation": { +"description": "This resource represents a long-running operation that is the result of a network API call.", +"id": "Operation", +"properties": { +"done": { +"description": "If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.", +"type": "boolean" +}, +"error": { +"$ref": "Status", +"description": "The error result of the operation in case of failure or cancellation." +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.", +"type": "object" +}, +"name": { +"description": "The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.", +"type": "string" +}, +"response": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.", +"type": "object" +} +}, +"type": "object" +}, +"OperationProgress": { +"description": "Encapsulates progress related information for a Cloud Spanner long running operation.", +"id": "OperationProgress", +"properties": { +"endTime": { +"description": "If set, the time at which this operation failed or was completed successfully.", +"format": "google-datetime", +"type": "string" +}, +"progressPercent": { +"description": "Percent completion of the operation. Values are between 0 and 100 inclusive.", +"format": "int32", +"type": "integer" +}, +"startTime": { +"description": "Time the request was received.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"OptimizeRestoredDatabaseMetadata": { +"description": "Metadata type for the long-running operation used to track the progress of optimizations performed on a newly restored database. This long-running operation is automatically created by the system after the successful completion of a database restore, and cannot be cancelled.", +"id": "OptimizeRestoredDatabaseMetadata", +"properties": { +"name": { +"description": "Name of the restored database being optimized.", +"type": "string" +}, +"progress": { +"$ref": "OperationProgress", +"description": "The progress of the post-restore optimizations." +} +}, +"type": "object" +}, +"PartialResultSet": { +"description": "Partial results from a streaming read or SQL query. Streaming reads and SQL queries better tolerate large result sets, large rows, and large values, but are a little trickier to consume.", +"id": "PartialResultSet", +"properties": { +"chunkedValue": { +"description": "If true, then the final value in values is chunked, and must be combined with more values from subsequent `PartialResultSet`s to obtain a complete field value.", +"type": "boolean" +}, +"metadata": { +"$ref": "ResultSetMetadata", +"description": "Metadata about the result set, such as row type information. Only present in the first response." +}, +"precommitToken": { +"$ref": "MultiplexedSessionPrecommitToken", +"description": "Optional. A precommit token will be included if the read-write transaction is on a multiplexed session. The precommit token with the highest sequence number from this transaction attempt should be passed to the Commit request for this transaction." +}, +"resumeToken": { +"description": "Streaming calls might be interrupted for a variety of reasons, such as TCP connection loss. If this occurs, the stream of results can be resumed by re-sending the original request and including `resume_token`. Note that executing any other transaction in the same session invalidates the token.", +"format": "byte", +"type": "string" +}, +"stats": { +"$ref": "ResultSetStats", +"description": "Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting ExecuteSqlRequest.query_mode and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements." +}, +"values": { +"description": "A streamed result set consists of a stream of values, which might be split into many `PartialResultSet` messages to accommodate large rows and/or large values. Every N complete values defines a row, where N is equal to the number of entries in metadata.row_type.fields. Most values are encoded based on type as described here. It is possible that the last value in values is \"chunked\", meaning that the rest of the value is sent in subsequent `PartialResultSet`(s). This is denoted by the chunked_value field. Two or more chunked values can be merged to form a complete value as follows: * `bool/number/null`: cannot be chunked * `string`: concatenate the strings * `list`: concatenate the lists. If the last element in a list is a `string`, `list`, or `object`, merge it with the first element in the next list by applying these rules recursively. * `object`: concatenate the (field name, field value) pairs. If a field name is duplicated, then apply these rules recursively to merge the field values. Some examples of merging: # Strings are concatenated. \"foo\", \"bar\" => \"foobar\" # Lists of non-strings are concatenated. [2, 3], [4] => [2, 3, 4] # Lists are concatenated, but the last and first elements are merged # because they are strings. [\"a\", \"b\"], [\"c\", \"d\"] => [\"a\", \"bc\", \"d\"] # Lists are concatenated, but the last and first elements are merged # because they are lists. Recursively, the last and first elements # of the inner lists are merged because they are strings. [\"a\", [\"b\", \"c\"]], [[\"d\"], \"e\"] => [\"a\", [\"b\", \"cd\"], \"e\"] # Non-overlapping object fields are combined. {\"a\": \"1\"}, {\"b\": \"2\"} => {\"a\": \"1\", \"b\": 2\"} # Overlapping object fields are merged. {\"a\": \"1\"}, {\"a\": \"2\"} => {\"a\": \"12\"} # Examples of merging objects containing lists of strings. {\"a\": [\"1\"]}, {\"a\": [\"2\"]} => {\"a\": [\"12\"]} For a more complete example, suppose a streaming SQL query is yielding a result set whose rows contain a single string field. The following `PartialResultSet`s might be yielded: { \"metadata\": { ... } \"values\": [\"Hello\", \"W\"] \"chunked_value\": true \"resume_token\": \"Af65...\" } { \"values\": [\"orl\"] \"chunked_value\": true } { \"values\": [\"d\"] \"resume_token\": \"Zx1B...\" } This sequence of `PartialResultSet`s encodes two rows, one containing the field value `\"Hello\"`, and a second containing the field value `\"World\" = \"W\" + \"orl\" + \"d\"`. Not all `PartialResultSet`s contain a `resume_token`. Execution can only be resumed from a previously yielded `resume_token`. For the above sequence of `PartialResultSet`s, resuming the query with `\"resume_token\": \"Af65...\"` will yield results from the `PartialResultSet` with value `[\"orl\"]`.", +"items": { +"type": "any" +}, +"type": "array" +} +}, +"type": "object" +}, +"Partition": { +"description": "Information returned for each partition returned in a PartitionResponse.", +"id": "Partition", +"properties": { +"partitionToken": { +"description": "This token can be passed to Read, StreamingRead, ExecuteSql, or ExecuteStreamingSql requests to restrict the results to those identified by this partition token.", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"PartitionOptions": { +"description": "Options for a PartitionQueryRequest and PartitionReadRequest.", +"id": "PartitionOptions", +"properties": { +"maxPartitions": { +"description": "**Note:** This hint is currently ignored by PartitionQuery and PartitionRead requests. The desired maximum number of partitions to return. For example, this may be set to the number of workers available. The default for this option is currently 10,000. The maximum value is currently 200,000. This is only a hint. The actual number of partitions returned may be smaller or larger than this maximum count request.", +"format": "int64", +"type": "string" +}, +"partitionSizeBytes": { +"description": "**Note:** This hint is currently ignored by PartitionQuery and PartitionRead requests. The desired data size for each partition generated. The default for this option is currently 1 GiB. This is only a hint. The actual size of each partition may be smaller or larger than this size request.", +"format": "int64", +"type": "string" +} +}, +"type": "object" +}, +"PartitionQueryRequest": { +"description": "The request for PartitionQuery", +"id": "PartitionQueryRequest", +"properties": { +"paramTypes": { +"additionalProperties": { +"$ref": "Type" +}, +"description": "It is not always possible for Cloud Spanner to infer the right SQL type from a JSON value. For example, values of type `BYTES` and values of type `STRING` both appear in params as JSON strings. In these cases, `param_types` can be used to specify the exact SQL type for some or all of the SQL query parameters. See the definition of Type for more information about SQL types.", +"type": "object" +}, +"params": { +"additionalProperties": { +"description": "Properties of the object.", +"type": "any" +}, +"description": "Parameter names and values that bind to placeholders in the SQL string. A parameter placeholder consists of the `@` character followed by the parameter name (for example, `@firstName`). Parameter names can contain letters, numbers, and underscores. Parameters can appear anywhere that a literal value is expected. The same parameter name can be used more than once, for example: `\"WHERE id > @msg_id AND id < @msg_id + 100\"` It is an error to execute a SQL statement with unbound parameters.", +"type": "object" +}, +"partitionOptions": { +"$ref": "PartitionOptions", +"description": "Additional options that affect how many partitions are created." +}, +"sql": { +"description": "Required. The query request to generate partitions for. The request fails if the query is not root partitionable. For a query to be root partitionable, it needs to satisfy a few conditions. For example, if the query execution plan contains a distributed union operator, then it must be the first operator in the plan. For more information about other conditions, see [Read data in parallel](https://cloud.google.com/spanner/docs/reads#read_data_in_parallel). The query request must not contain DML commands, such as `INSERT`, `UPDATE`, or `DELETE`. Use `ExecuteStreamingSql` with a PartitionedDml transaction for large, partition-friendly DML operations.", +"type": "string" +}, +"transaction": { +"$ref": "TransactionSelector", +"description": "Read only snapshot transactions are supported, read/write and single use transactions are not." +} +}, +"type": "object" +}, +"PartitionReadRequest": { +"description": "The request for PartitionRead", +"id": "PartitionReadRequest", +"properties": { +"columns": { +"description": "The columns of table to be returned for each row matching this request.", +"items": { +"type": "string" +}, +"type": "array" +}, +"index": { +"description": "If non-empty, the name of an index on table. This index is used instead of the table primary key when interpreting key_set and sorting result rows. See key_set for further information.", +"type": "string" +}, +"keySet": { +"$ref": "KeySet", +"description": "Required. `key_set` identifies the rows to be yielded. `key_set` names the primary keys of the rows in table to be yielded, unless index is present. If index is present, then key_set instead names index keys in index. It is not an error for the `key_set` to name rows that do not exist in the database. Read yields nothing for nonexistent rows." +}, +"partitionOptions": { +"$ref": "PartitionOptions", +"description": "Additional options that affect how many partitions are created." +}, +"table": { +"description": "Required. The name of the table in the database to be read.", +"type": "string" +}, +"transaction": { +"$ref": "TransactionSelector", +"description": "Read only snapshot transactions are supported, read/write and single use transactions are not." +} +}, +"type": "object" +}, +"PartitionResponse": { +"description": "The response for PartitionQuery or PartitionRead", +"id": "PartitionResponse", +"properties": { +"partitions": { +"description": "Partitions created by this request.", +"items": { +"$ref": "Partition" +}, +"type": "array" +}, +"transaction": { +"$ref": "Transaction", +"description": "Transaction created by this request." +} +}, +"type": "object" +}, +"PartitionedDml": { +"description": "Message type to initiate a Partitioned DML transaction.", +"id": "PartitionedDml", +"properties": {}, +"type": "object" +}, +"PlanNode": { +"description": "Node information for nodes appearing in a QueryPlan.plan_nodes.", +"id": "PlanNode", +"properties": { +"childLinks": { +"description": "List of child node `index`es and their relationship to this parent.", +"items": { +"$ref": "ChildLink" +}, +"type": "array" +}, +"displayName": { +"description": "The display name for the node.", +"type": "string" +}, +"executionStats": { +"additionalProperties": { +"description": "Properties of the object.", +"type": "any" +}, +"description": "The execution statistics associated with the node, contained in a group of key-value pairs. Only present if the plan was returned as a result of a profile query. For example, number of executions, number of rows/time per execution etc.", +"type": "object" +}, +"index": { +"description": "The `PlanNode`'s index in node list.", +"format": "int32", +"type": "integer" +}, +"kind": { +"description": "Used to determine the type of node. May be needed for visualizing different kinds of nodes differently. For example, If the node is a SCALAR node, it will have a condensed representation which can be used to directly embed a description of the node in its parent.", +"enum": [ +"KIND_UNSPECIFIED", +"RELATIONAL", +"SCALAR" +], +"enumDescriptions": [ +"Not specified.", +"Denotes a Relational operator node in the expression tree. Relational operators represent iterative processing of rows during query execution. For example, a `TableScan` operation that reads rows from a table.", +"Denotes a Scalar node in the expression tree. Scalar nodes represent non-iterable entities in the query plan. For example, constants or arithmetic operators appearing inside predicate expressions or references to column names." +], +"type": "string" +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object.", +"type": "any" +}, +"description": "Attributes relevant to the node contained in a group of key-value pairs. For example, a Parameter Reference node could have the following information in its metadata: { \"parameter_reference\": \"param1\", \"parameter_type\": \"array\" }", +"type": "object" +}, +"shortRepresentation": { +"$ref": "ShortRepresentation", +"description": "Condensed representation for SCALAR nodes." +} +}, +"type": "object" +}, +"Policy": { +"description": "An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** ``` { \"bindings\": [ { \"role\": \"roles/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike@example.com\", \"group:admins@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles/resourcemanager.organizationViewer\", \"members\": [ \"user:eve@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time < timestamp('2020-10-01T00:00:00.000Z')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 } ``` **YAML example:** ``` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 ``` For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).", +"id": "Policy", +"properties": { +"bindings": { +"description": "Associates a list of `members`, or principals, with a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one principal. The `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of these principals can be Google groups. Each occurrence of a principal counts towards these limits. For example, if the `bindings` grant 50 different roles to `user:alice@example.com`, and not to any other principal, then you can add another 1,450 principals to the `bindings` in the `Policy`.", +"items": { +"$ref": "Binding" +}, +"type": "array" +}, +"etag": { +"description": "`etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.", +"format": "byte", +"type": "string" +}, +"version": { +"description": "Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"PrefixNode": { +"description": "A message representing a key prefix node in the key prefix hierarchy. for eg. Bigtable keyspaces are lexicographically ordered mappings of keys to values. Keys often have a shared prefix structure where users use the keys to organize data. Eg ///employee In this case Keysight will possibly use one node for a company and reuse it for all employees that fall under the company. Doing so improves legibility in the UI.", +"id": "PrefixNode", +"properties": { +"dataSourceNode": { +"description": "Whether this corresponds to a data_source name.", +"type": "boolean" +}, +"depth": { +"description": "The depth in the prefix hierarchy.", +"format": "int32", +"type": "integer" +}, +"endIndex": { +"description": "The index of the end key bucket of the range that this node spans.", +"format": "int32", +"type": "integer" +}, +"startIndex": { +"description": "The index of the start key bucket of the range that this node spans.", +"format": "int32", +"type": "integer" +}, +"word": { +"description": "The string represented by the prefix node.", +"type": "string" +} +}, +"type": "object" +}, +"QueryAdvisorResult": { +"description": "Output of query advisor analysis.", +"id": "QueryAdvisorResult", +"properties": { +"indexAdvice": { +"description": "Optional. Index Recommendation for a query. This is an optional field and the recommendation will only be available when the recommendation guarantees significant improvement in query performance.", +"items": { +"$ref": "IndexAdvice" +}, +"type": "array" +} +}, +"type": "object" +}, +"QueryOptions": { +"description": "Query optimizer configuration.", +"id": "QueryOptions", +"properties": { +"optimizerStatisticsPackage": { +"description": "An option to control the selection of optimizer statistics package. This parameter allows individual queries to use a different query optimizer statistics package. Specifying `latest` as a value instructs Cloud Spanner to use the latest generated statistics package. If not specified, Cloud Spanner uses the statistics package set at the database level options, or the latest package if the database option is not set. The statistics package requested by the query has to be exempt from garbage collection. This can be achieved with the following DDL statement: ``` ALTER STATISTICS SET OPTIONS (allow_gc=false) ``` The list of available statistics packages can be queried from `INFORMATION_SCHEMA.SPANNER_STATISTICS`. Executing a SQL statement with an invalid optimizer statistics package or with a statistics package that allows garbage collection fails with an `INVALID_ARGUMENT` error.", +"type": "string" +}, +"optimizerVersion": { +"description": "An option to control the selection of optimizer version. This parameter allows individual queries to pick different query optimizer versions. Specifying `latest` as a value instructs Cloud Spanner to use the latest supported query optimizer version. If not specified, Cloud Spanner uses the optimizer version set at the database level options. Any other positive integer (from the list of supported optimizer versions) overrides the default optimizer version for query execution. The list of supported optimizer versions can be queried from SPANNER_SYS.SUPPORTED_OPTIMIZER_VERSIONS. Executing a SQL statement with an invalid optimizer version fails with an `INVALID_ARGUMENT` error. See https://cloud.google.com/spanner/docs/query-optimizer/manage-query-optimizer for more information on managing the query optimizer. The `optimizer_version` statement hint has precedence over this setting.", +"type": "string" +} +}, +"type": "object" +}, +"QueryPlan": { +"description": "Contains an ordered list of nodes appearing in the query plan.", +"id": "QueryPlan", +"properties": { +"planNodes": { +"description": "The nodes in the query plan. Plan nodes are returned in pre-order starting with the plan root. Each PlanNode's `id` corresponds to its index in `plan_nodes`.", +"items": { +"$ref": "PlanNode" +}, +"type": "array" +}, +"queryAdvice": { +"$ref": "QueryAdvisorResult", +"description": "Optional. The advise/recommendations for a query. Currently this field will be serving index recommendations for a query." +} +}, +"type": "object" +}, +"QuorumInfo": { +"description": "Information about the dual-region quorum.", +"id": "QuorumInfo", +"properties": { +"etag": { +"description": "Output only. The etag is used for optimistic concurrency control as a way to help prevent simultaneous `ChangeQuorum` requests that might create a race condition.", +"readOnly": true, +"type": "string" +}, +"initiator": { +"description": "Output only. Whether this `ChangeQuorum` is Google or User initiated.", +"enum": [ +"INITIATOR_UNSPECIFIED", +"GOOGLE", +"USER" +], +"enumDescriptions": [ +"Unspecified.", +"`ChangeQuorum` initiated by Google.", +"`ChangeQuorum` initiated by User." +], +"readOnly": true, +"type": "string" +}, +"quorumType": { +"$ref": "QuorumType", +"description": "Output only. The type of this quorum. See QuorumType for more information about quorum type specifications.", +"readOnly": true +}, +"startTime": { +"description": "Output only. The timestamp when the request was triggered.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"QuorumType": { +"description": "Information about the database quorum type. This only applies to dual-region instance configs.", +"id": "QuorumType", +"properties": { +"dualRegion": { +"$ref": "DualRegionQuorum", +"description": "Dual-region quorum type." +}, +"singleRegion": { +"$ref": "SingleRegionQuorum", +"description": "Single-region quorum type." +} +}, +"type": "object" +}, +"ReadOnly": { +"description": "Message type to initiate a read-only transaction.", +"id": "ReadOnly", +"properties": { +"exactStaleness": { +"description": "Executes all reads at a timestamp that is `exact_staleness` old. The timestamp is chosen soon after the read is started. Guarantees that all writes that have committed more than the specified number of seconds ago are visible. Because Cloud Spanner chooses the exact timestamp, this mode works even if the client's local clock is substantially skewed from Cloud Spanner commit timestamps. Useful for reading at nearby replicas without the distributed timestamp negotiation overhead of `max_staleness`.", +"format": "google-duration", +"type": "string" +}, +"maxStaleness": { +"description": "Read data at a timestamp >= `NOW - max_staleness` seconds. Guarantees that all writes that have committed more than the specified number of seconds ago are visible. Because Cloud Spanner chooses the exact timestamp, this mode works even if the client's local clock is substantially skewed from Cloud Spanner commit timestamps. Useful for reading the freshest data available at a nearby replica, while bounding the possible staleness if the local replica has fallen behind. Note that this option can only be used in single-use transactions.", +"format": "google-duration", +"type": "string" +}, +"minReadTimestamp": { +"description": "Executes all reads at a timestamp >= `min_read_timestamp`. This is useful for requesting fresher data than some previous read, or data that is fresh enough to observe the effects of some previously committed transaction whose timestamp is known. Note that this option can only be used in single-use transactions. A timestamp in RFC3339 UTC \\\"Zulu\\\" format, accurate to nanoseconds. Example: `\"2014-10-02T15:01:23.045123456Z\"`.", +"format": "google-datetime", +"type": "string" +}, +"readTimestamp": { +"description": "Executes all reads at the given timestamp. Unlike other modes, reads at a specific timestamp are repeatable; the same read at the same timestamp always returns the same data. If the timestamp is in the future, the read will block until the specified timestamp, modulo the read's deadline. Useful for large scale consistent reads such as mapreduces, or for coordinating many reads against a consistent snapshot of the data. A timestamp in RFC3339 UTC \\\"Zulu\\\" format, accurate to nanoseconds. Example: `\"2014-10-02T15:01:23.045123456Z\"`.", +"format": "google-datetime", +"type": "string" +}, +"returnReadTimestamp": { +"description": "If true, the Cloud Spanner-selected read timestamp is included in the Transaction message that describes the transaction.", +"type": "boolean" +}, +"strong": { +"description": "Read at a timestamp where all previously committed transactions are visible.", +"type": "boolean" +} +}, +"type": "object" +}, +"ReadRequest": { +"description": "The request for Read and StreamingRead.", +"id": "ReadRequest", +"properties": { +"columns": { +"description": "Required. The columns of table to be returned for each row matching this request.", +"items": { +"type": "string" +}, +"type": "array" +}, +"dataBoostEnabled": { +"description": "If this is for a partitioned read and this field is set to `true`, the request is executed with Spanner Data Boost independent compute resources. If the field is set to `true` but the request does not set `partition_token`, the API returns an `INVALID_ARGUMENT` error.", +"type": "boolean" +}, +"directedReadOptions": { +"$ref": "DirectedReadOptions", +"description": "Directed read options for this request." +}, +"index": { +"description": "If non-empty, the name of an index on table. This index is used instead of the table primary key when interpreting key_set and sorting result rows. See key_set for further information.", +"type": "string" +}, +"keySet": { +"$ref": "KeySet", +"description": "Required. `key_set` identifies the rows to be yielded. `key_set` names the primary keys of the rows in table to be yielded, unless index is present. If index is present, then key_set instead names index keys in index. If the partition_token field is empty, rows are yielded in table primary key order (if index is empty) or index key order (if index is non-empty). If the partition_token field is not empty, rows will be yielded in an unspecified order. It is not an error for the `key_set` to name rows that do not exist in the database. Read yields nothing for nonexistent rows." +}, +"limit": { +"description": "If greater than zero, only the first `limit` rows are yielded. If `limit` is zero, the default is no limit. A limit cannot be specified if `partition_token` is set.", +"format": "int64", +"type": "string" +}, +"lockHint": { +"description": "Optional. Lock Hint for the request, it can only be used with read-write transactions.", +"enum": [ +"LOCK_HINT_UNSPECIFIED", +"LOCK_HINT_SHARED", +"LOCK_HINT_EXCLUSIVE" +], +"enumDescriptions": [ +"Default value. LOCK_HINT_UNSPECIFIED is equivalent to LOCK_HINT_SHARED.", +"Acquire shared locks. By default when you perform a read as part of a read-write transaction, Spanner acquires shared read locks, which allows other reads to still access the data until your transaction is ready to commit. When your transaction is committing and writes are being applied, the transaction attempts to upgrade to an exclusive lock for any data you are writing. For more information about locks, see [Lock modes](https://cloud.google.com/spanner/docs/introspection/lock-statistics#explain-lock-modes).", +"Acquire exclusive locks. Requesting exclusive locks is beneficial if you observe high write contention, which means you notice that multiple transactions are concurrently trying to read and write to the same data, resulting in a large number of aborts. This problem occurs when two transactions initially acquire shared locks and then both try to upgrade to exclusive locks at the same time. In this situation both transactions are waiting for the other to give up their lock, resulting in a deadlocked situation. Spanner is able to detect this occurring and force one of the transactions to abort. However, this is a slow and expensive operation and results in lower performance. In this case it makes sense to acquire exclusive locks at the start of the transaction because then when multiple transactions try to act on the same data, they automatically get serialized. Each transaction waits its turn to acquire the lock and avoids getting into deadlock situations. Because the exclusive lock hint is just a hint, it should not be considered equivalent to a mutex. In other words, you should not use Spanner exclusive locks as a mutual exclusion mechanism for the execution of code outside of Spanner. **Note:** Request exclusive locks judiciously because they block others from reading that data for the entire transaction, rather than just when the writes are being performed. Unless you observe high write contention, you should use the default of shared read locks so you don't prematurely block other clients from reading the data that you're writing to." +], +"type": "string" +}, +"orderBy": { +"description": "Optional. Order for the returned rows. By default, Spanner will return result rows in primary key order except for PartitionRead requests. For applications that do not require rows to be returned in primary key (`ORDER_BY_PRIMARY_KEY`) order, setting `ORDER_BY_NO_ORDER` option allows Spanner to optimize row retrieval, resulting in lower latencies in certain cases (e.g. bulk point lookups).", +"enum": [ +"ORDER_BY_UNSPECIFIED", +"ORDER_BY_PRIMARY_KEY", +"ORDER_BY_NO_ORDER" +], +"enumDescriptions": [ +"Default value. ORDER_BY_UNSPECIFIED is equivalent to ORDER_BY_PRIMARY_KEY.", +"Read rows are returned in primary key order. In the event that this option is used in conjunction with the `partition_token` field, the API will return an `INVALID_ARGUMENT` error.", +"Read rows are returned in any order." +], +"type": "string" +}, +"partitionToken": { +"description": "If present, results will be restricted to the specified partition previously created using PartitionRead(). There must be an exact match for the values of fields common to this message and the PartitionReadRequest message used to create this partition_token.", +"format": "byte", +"type": "string" +}, +"requestOptions": { +"$ref": "RequestOptions", +"description": "Common options for this request." +}, +"resumeToken": { +"description": "If this request is resuming a previously interrupted read, `resume_token` should be copied from the last PartialResultSet yielded before the interruption. Doing this enables the new read to resume where the last read left off. The rest of the request parameters must exactly match the request that yielded this token.", +"format": "byte", +"type": "string" +}, +"table": { +"description": "Required. The name of the table in the database to be read.", +"type": "string" +}, +"transaction": { +"$ref": "TransactionSelector", +"description": "The transaction to use. If none is provided, the default is a temporary read-only transaction with strong concurrency." +} +}, +"type": "object" +}, +"ReadWrite": { +"description": "Message type to initiate a read-write transaction. Currently this transaction type has no options.", +"id": "ReadWrite", +"properties": { +"multiplexedSessionPreviousTransactionId": { +"description": "Optional. Clients should pass the transaction ID of the previous transaction attempt that was aborted if this transaction is being executed on a multiplexed session.", +"format": "byte", +"type": "string" +}, +"readLockMode": { +"description": "Read lock mode for the transaction.", +"enum": [ +"READ_LOCK_MODE_UNSPECIFIED", +"PESSIMISTIC", +"OPTIMISTIC" +], +"enumDescriptions": [ +"Default value. If the value is not specified, the pessimistic read lock is used.", +"Pessimistic lock mode. Read locks are acquired immediately on read.", +"Optimistic lock mode. Locks for reads within the transaction are not acquired on read. Instead the locks are acquired on a commit to validate that read/queried data has not changed since the transaction started." +], +"type": "string" +} +}, +"type": "object" +}, +"ReplicaComputeCapacity": { +"description": "ReplicaComputeCapacity describes the amount of server resources that are allocated to each replica identified by the replica selection.", +"id": "ReplicaComputeCapacity", +"properties": { +"nodeCount": { +"description": "The number of nodes allocated to each replica. This may be zero in API responses for instances that are not yet in state `READY`.", +"format": "int32", +"type": "integer" +}, +"processingUnits": { +"description": "The number of processing units allocated to each replica. This may be zero in API responses for instances that are not yet in state `READY`.", +"format": "int32", +"type": "integer" +}, +"replicaSelection": { +"$ref": "InstanceReplicaSelection", +"description": "Required. Identifies replicas by specified properties. All replicas in the selection have the same amount of compute capacity." +} +}, +"type": "object" +}, +"ReplicaInfo": { +"id": "ReplicaInfo", +"properties": { +"defaultLeaderLocation": { +"description": "If true, this location is designated as the default leader location where leader replicas are placed. See the [region types documentation](https://cloud.google.com/spanner/docs/instances#region_types) for more details.", +"type": "boolean" +}, +"location": { +"description": "The location of the serving resources, e.g., \"us-central1\".", +"type": "string" +}, +"type": { +"description": "The type of replica.", +"enum": [ +"TYPE_UNSPECIFIED", +"READ_WRITE", +"READ_ONLY", +"WITNESS" +], +"enumDescriptions": [ +"Not specified.", +"Read-write replicas support both reads and writes. These replicas: * Maintain a full copy of your data. * Serve reads. * Can vote whether to commit a write. * Participate in leadership election. * Are eligible to become a leader.", +"Read-only replicas only support reads (not writes). Read-only replicas: * Maintain a full copy of your data. * Serve reads. * Do not participate in voting to commit writes. * Are not eligible to become a leader.", +"Witness replicas don't support reads but do participate in voting to commit writes. Witness replicas: * Do not maintain a full copy of data. * Do not serve reads. * Vote whether to commit writes. * Participate in leader election but are not eligible to become leader." +], +"type": "string" +} +}, +"type": "object" +}, +"ReplicaSelection": { +"description": "The directed read replica selector. Callers must provide one or more of the following fields for replica selection: * `location` - The location must be one of the regions within the multi-region configuration of your database. * `type` - The type of the replica. Some examples of using replica_selectors are: * `location:us-east1` --> The \"us-east1\" replica(s) of any available type will be used to process the request. * `type:READ_ONLY` --> The \"READ_ONLY\" type replica(s) in nearest available location will be used to process the request. * `location:us-east1 type:READ_ONLY` --> The \"READ_ONLY\" type replica(s) in location \"us-east1\" will be used to process the request.", +"id": "ReplicaSelection", +"properties": { +"location": { +"description": "The location or region of the serving requests, e.g. \"us-east1\".", +"type": "string" +}, +"type": { +"description": "The type of replica.", +"enum": [ +"TYPE_UNSPECIFIED", +"READ_WRITE", +"READ_ONLY" +], +"enumDescriptions": [ +"Not specified.", +"Read-write replicas support both reads and writes.", +"Read-only replicas only support reads (not writes)." +], +"type": "string" +} +}, +"type": "object" +}, +"RequestOptions": { +"description": "Common request options for various APIs.", +"id": "RequestOptions", +"properties": { +"priority": { +"description": "Priority for the request.", +"enum": [ +"PRIORITY_UNSPECIFIED", +"PRIORITY_LOW", +"PRIORITY_MEDIUM", +"PRIORITY_HIGH" +], +"enumDescriptions": [ +"`PRIORITY_UNSPECIFIED` is equivalent to `PRIORITY_HIGH`.", +"This specifies that the request is low priority.", +"This specifies that the request is medium priority.", +"This specifies that the request is high priority." +], +"type": "string" +}, +"requestTag": { +"description": "A per-request tag which can be applied to queries or reads, used for statistics collection. Both request_tag and transaction_tag can be specified for a read or query that belongs to a transaction. This field is ignored for requests where it's not applicable (e.g. CommitRequest). Legal characters for `request_tag` values are all printable characters (ASCII 32 - 126) and the length of a request_tag is limited to 50 characters. Values that exceed this limit are truncated. Any leading underscore (_) characters will be removed from the string.", +"type": "string" +}, +"transactionTag": { +"description": "A tag used for statistics collection about this transaction. Both request_tag and transaction_tag can be specified for a read or query that belongs to a transaction. The value of transaction_tag should be the same for all requests belonging to the same transaction. If this request doesn't belong to any transaction, transaction_tag will be ignored. Legal characters for `transaction_tag` values are all printable characters (ASCII 32 - 126) and the length of a transaction_tag is limited to 50 characters. Values that exceed this limit are truncated. Any leading underscore (_) characters will be removed from the string.", +"type": "string" +} +}, +"type": "object" +}, +"RestoreDatabaseEncryptionConfig": { +"description": "Encryption configuration for the restored database.", +"id": "RestoreDatabaseEncryptionConfig", +"properties": { +"encryptionType": { +"description": "Required. The encryption type of the restored database.", +"enum": [ +"ENCRYPTION_TYPE_UNSPECIFIED", +"USE_CONFIG_DEFAULT_OR_BACKUP_ENCRYPTION", +"GOOGLE_DEFAULT_ENCRYPTION", +"CUSTOMER_MANAGED_ENCRYPTION" +], +"enumDescriptions": [ +"Unspecified. Do not use.", +"This is the default option when encryption_config is not specified.", +"Use Google default encryption.", +"Use customer managed encryption. If specified, `kms_key_name` must must contain a valid Cloud KMS key." +], +"type": "string" +}, +"kmsKeyName": { +"description": "Optional. The Cloud KMS key that will be used to encrypt/decrypt the restored database. This field should be set only when encryption_type is `CUSTOMER_MANAGED_ENCRYPTION`. Values are of the form `projects//locations//keyRings//cryptoKeys/`.", +"type": "string" +}, +"kmsKeyNames": { +"description": "Optional. Specifies the KMS configuration for one or more keys used to encrypt the database. Values have the form `projects//locations//keyRings//cryptoKeys/`. The keys referenced by `kms_key_names` must fully cover all regions of the database's instance configuration. Some examples: * For regional (single-region) instance configurations, specify a regional location KMS key. * For multi-region instance configurations of type `GOOGLE_MANAGED`, either specify a multi-region location KMS key or multiple regional location KMS keys that cover all regions in the instance configuration. * For an instance configuration of type `USER_MANAGED`, specify only regional location KMS keys to cover each region in the instance configuration. Multi-region location KMS keys aren't supported for `USER_MANAGED` type instance configurations.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"RestoreDatabaseMetadata": { +"description": "Metadata type for the long-running operation returned by RestoreDatabase.", +"id": "RestoreDatabaseMetadata", +"properties": { +"backupInfo": { +"$ref": "BackupInfo", +"description": "Information about the backup used to restore the database." +}, +"cancelTime": { +"description": "The time at which cancellation of this operation was received. Operations.CancelOperation starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.", +"format": "google-datetime", +"type": "string" +}, +"name": { +"description": "Name of the database being created and restored to.", +"type": "string" +}, +"optimizeDatabaseOperationName": { +"description": "If exists, the name of the long-running operation that will be used to track the post-restore optimization process to optimize the performance of the restored database, and remove the dependency on the restore source. The name is of the form `projects//instances//databases//operations/` where the is the name of database being created and restored to. The metadata type of the long-running operation is OptimizeRestoredDatabaseMetadata. This long-running operation will be automatically created by the system after the RestoreDatabase long-running operation completes successfully. This operation will not be created if the restore was not successful.", +"type": "string" +}, +"progress": { +"$ref": "OperationProgress", +"description": "The progress of the RestoreDatabase operation." +}, +"sourceType": { +"description": "The type of the restore source.", +"enum": [ +"TYPE_UNSPECIFIED", +"BACKUP" +], +"enumDescriptions": [ +"No restore associated.", +"A backup was used as the source of the restore." +], +"type": "string" +} +}, +"type": "object" +}, +"RestoreDatabaseRequest": { +"description": "The request for RestoreDatabase.", +"id": "RestoreDatabaseRequest", +"properties": { +"backup": { +"description": "Name of the backup from which to restore. Values are of the form `projects//instances//backups/`.", +"type": "string" +}, +"databaseId": { +"description": "Required. The id of the database to create and restore to. This database must not already exist. The `database_id` appended to `parent` forms the full database name of the form `projects//instances//databases/`.", +"type": "string" +}, +"encryptionConfig": { +"$ref": "RestoreDatabaseEncryptionConfig", +"description": "Optional. An encryption configuration describing the encryption type and key resources in Cloud KMS used to encrypt/decrypt the database to restore to. If this field is not specified, the restored database will use the same encryption configuration as the backup by default, namely encryption_type = `USE_CONFIG_DEFAULT_OR_BACKUP_ENCRYPTION`." +} +}, +"type": "object" +}, +"RestoreInfo": { +"description": "Information about the database restore.", +"id": "RestoreInfo", +"properties": { +"backupInfo": { +"$ref": "BackupInfo", +"description": "Information about the backup used to restore the database. The backup may no longer exist." +}, +"sourceType": { +"description": "The type of the restore source.", +"enum": [ +"TYPE_UNSPECIFIED", +"BACKUP" +], +"enumDescriptions": [ +"No restore associated.", +"A backup was used as the source of the restore." +], +"type": "string" +} +}, +"type": "object" +}, +"ResultSet": { +"description": "Results from Read or ExecuteSql.", +"id": "ResultSet", +"properties": { +"metadata": { +"$ref": "ResultSetMetadata", +"description": "Metadata about the result set, such as row type information." +}, +"precommitToken": { +"$ref": "MultiplexedSessionPrecommitToken", +"description": "Optional. A precommit token will be included if the read-write transaction is on a multiplexed session. The precommit token with the highest sequence number from this transaction attempt should be passed to the Commit request for this transaction." +}, +"rows": { +"description": "Each element in `rows` is a row whose format is defined by metadata.row_type. The ith element in each row matches the ith field in metadata.row_type. Elements are encoded based on type as described here.", +"items": { +"items": { +"type": "any" +}, +"type": "array" +}, +"type": "array" +}, +"stats": { +"$ref": "ResultSetStats", +"description": "Query plan and execution statistics for the SQL statement that produced this result set. These can be requested by setting ExecuteSqlRequest.query_mode. DML statements always produce stats containing the number of rows modified, unless executed using the ExecuteSqlRequest.QueryMode.PLAN ExecuteSqlRequest.query_mode. Other fields may or may not be populated, based on the ExecuteSqlRequest.query_mode." +} +}, +"type": "object" +}, +"ResultSetMetadata": { +"description": "Metadata about a ResultSet or PartialResultSet.", +"id": "ResultSetMetadata", +"properties": { +"rowType": { +"$ref": "StructType", +"description": "Indicates the field names and types for the rows in the result set. For example, a SQL query like `\"SELECT UserId, UserName FROM Users\"` could return a `row_type` value like: \"fields\": [ { \"name\": \"UserId\", \"type\": { \"code\": \"INT64\" } }, { \"name\": \"UserName\", \"type\": { \"code\": \"STRING\" } }, ]" +}, +"transaction": { +"$ref": "Transaction", +"description": "If the read or SQL query began a transaction as a side-effect, the information about the new transaction is yielded here." +}, +"undeclaredParameters": { +"$ref": "StructType", +"description": "A SQL query can be parameterized. In PLAN mode, these parameters can be undeclared. This indicates the field names and types for those undeclared parameters in the SQL query. For example, a SQL query like `\"SELECT * FROM Users where UserId = @userId and UserName = @userName \"` could return a `undeclared_parameters` value like: \"fields\": [ { \"name\": \"UserId\", \"type\": { \"code\": \"INT64\" } }, { \"name\": \"UserName\", \"type\": { \"code\": \"STRING\" } }, ]" +} +}, +"type": "object" +}, +"ResultSetStats": { +"description": "Additional statistics about a ResultSet or PartialResultSet.", +"id": "ResultSetStats", +"properties": { +"queryPlan": { +"$ref": "QueryPlan", +"description": "QueryPlan for the query associated with this result." +}, +"queryStats": { +"additionalProperties": { +"description": "Properties of the object.", +"type": "any" +}, +"description": "Aggregated statistics from the execution of the query. Only present when the query is profiled. For example, a query could return the statistics as follows: { \"rows_returned\": \"3\", \"elapsed_time\": \"1.22 secs\", \"cpu_time\": \"1.19 secs\" }", +"type": "object" +}, +"rowCountExact": { +"description": "Standard DML returns an exact count of rows that were modified.", +"format": "int64", +"type": "string" +}, +"rowCountLowerBound": { +"description": "Partitioned DML does not offer exactly-once semantics, so it returns a lower bound of the rows modified.", +"format": "int64", +"type": "string" +} +}, +"type": "object" +}, +"RollbackRequest": { +"description": "The request for Rollback.", +"id": "RollbackRequest", +"properties": { +"transactionId": { +"description": "Required. The transaction to roll back.", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"Scan": { +"description": "Scan is a structure which describes Cloud Key Visualizer scan information.", +"id": "Scan", +"properties": { +"details": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Additional information provided by the implementer.", +"type": "object" +}, +"endTime": { +"description": "The upper bound for when the scan is defined.", +"format": "google-datetime", +"type": "string" +}, +"name": { +"description": "The unique name of the scan, specific to the Database service implementing this interface.", +"type": "string" +}, +"scanData": { +"$ref": "ScanData", +"description": "Output only. Cloud Key Visualizer scan data. Note, this field is not available to the ListScans method.", +"readOnly": true +}, +"startTime": { +"description": "A range of time (inclusive) for when the scan is defined. The lower bound for when the scan is defined.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"ScanData": { +"description": "ScanData contains Cloud Key Visualizer scan data used by the caller to construct a visualization.", +"id": "ScanData", +"properties": { +"data": { +"$ref": "VisualizationData", +"description": "Cloud Key Visualizer scan data. The range of time this information covers is captured via the above time range fields. Note, this field is not available to the ListScans method." +}, +"endTime": { +"description": "The upper bound for when the contained data is defined.", +"format": "google-datetime", +"type": "string" +}, +"startTime": { +"description": "A range of time (inclusive) for when the contained data is defined. The lower bound for when the contained data is defined.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"Session": { +"description": "A session in the Cloud Spanner API.", +"id": "Session", +"properties": { +"approximateLastUseTime": { +"description": "Output only. The approximate timestamp when the session is last used. It is typically earlier than the actual last use time.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"createTime": { +"description": "Output only. The timestamp when the session is created.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"creatorRole": { +"description": "The database role which created this session.", +"type": "string" +}, +"labels": { +"additionalProperties": { +"type": "string" +}, +"description": "The labels for the session. * Label keys must be between 1 and 63 characters long and must conform to the following regular expression: `[a-z]([-a-z0-9]*[a-z0-9])?`. * Label values must be between 0 and 63 characters long and must conform to the regular expression `([a-z]([-a-z0-9]*[a-z0-9])?)?`. * No more than 64 labels can be associated with a given session. See https://goo.gl/xmQnxf for more information on and examples of labels.", +"type": "object" +}, +"multiplexed": { +"description": "Optional. If true, specifies a multiplexed session. Use a multiplexed session for multiple, concurrent read-only operations. Don't use them for read-write transactions, partitioned reads, or partitioned queries. Use CreateSession to create multiplexed sessions. Don't use BatchCreateSessions to create a multiplexed session. You can't delete or list multiplexed sessions.", +"type": "boolean" +}, +"name": { +"description": "Output only. The name of the session. This is always system-assigned.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"SetIamPolicyRequest": { +"description": "Request message for `SetIamPolicy` method.", +"id": "SetIamPolicyRequest", +"properties": { +"policy": { +"$ref": "Policy", +"description": "REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them." +} +}, +"type": "object" +}, +"ShortRepresentation": { +"description": "Condensed representation of a node and its subtree. Only present for `SCALAR` PlanNode(s).", +"id": "ShortRepresentation", +"properties": { +"description": { +"description": "A string representation of the expression subtree rooted at this node.", +"type": "string" +}, +"subqueries": { +"additionalProperties": { +"format": "int32", +"type": "integer" +}, +"description": "A mapping of (subquery variable name) -> (subquery node id) for cases where the `description` string of this node references a `SCALAR` subquery contained in the expression subtree rooted at this node. The referenced `SCALAR` subquery may not necessarily be a direct child of this node.", +"type": "object" +} +}, +"type": "object" +}, +"SingleRegionQuorum": { +"description": "Message type for a single-region quorum.", +"id": "SingleRegionQuorum", +"properties": { +"servingLocation": { +"description": "Required. The location of the serving region, e.g. \"us-central1\". The location must be one of the regions within the dual-region instance configuration of your database. The list of valid locations is available using the GetInstanceConfig API. This should only be used if you plan to change quorum to the single-region quorum type.", +"type": "string" +} +}, +"type": "object" +}, +"Statement": { +"description": "A single DML statement.", +"id": "Statement", +"properties": { +"paramTypes": { +"additionalProperties": { +"$ref": "Type" +}, +"description": "It is not always possible for Cloud Spanner to infer the right SQL type from a JSON value. For example, values of type `BYTES` and values of type `STRING` both appear in params as JSON strings. In these cases, `param_types` can be used to specify the exact SQL type for some or all of the SQL statement parameters. See the definition of Type for more information about SQL types.", +"type": "object" +}, +"params": { +"additionalProperties": { +"description": "Properties of the object.", +"type": "any" +}, +"description": "Parameter names and values that bind to placeholders in the DML string. A parameter placeholder consists of the `@` character followed by the parameter name (for example, `@firstName`). Parameter names can contain letters, numbers, and underscores. Parameters can appear anywhere that a literal value is expected. The same parameter name can be used more than once, for example: `\"WHERE id > @msg_id AND id < @msg_id + 100\"` It is an error to execute a SQL statement with unbound parameters.", +"type": "object" +}, +"sql": { +"description": "Required. The DML string.", +"type": "string" +} +}, +"type": "object" +}, +"Status": { +"description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", +"id": "Status", +"properties": { +"code": { +"description": "The status code, which should be an enum value of google.rpc.Code.", +"format": "int32", +"type": "integer" +}, +"details": { +"description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", +"items": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"type": "object" +}, +"type": "array" +}, +"message": { +"description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", +"type": "string" +} +}, +"type": "object" +}, +"StructType": { +"description": "`StructType` defines the fields of a STRUCT type.", +"id": "StructType", +"properties": { +"fields": { +"description": "The list of fields that make up this struct. Order is significant, because values of this struct type are represented as lists, where the order of field values matches the order of fields in the StructType. In turn, the order of fields matches the order of columns in a read request, or the order of fields in the `SELECT` clause of a query.", +"items": { +"$ref": "Field" +}, +"type": "array" +} +}, +"type": "object" +}, +"TestIamPermissionsRequest": { +"description": "Request message for `TestIamPermissions` method.", +"id": "TestIamPermissionsRequest", +"properties": { +"permissions": { +"description": "REQUIRED: The set of permissions to check for 'resource'. Permissions with wildcards (such as '*', 'spanner.*', 'spanner.instances.*') are not allowed.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"TestIamPermissionsResponse": { +"description": "Response message for `TestIamPermissions` method.", +"id": "TestIamPermissionsResponse", +"properties": { +"permissions": { +"description": "A subset of `TestPermissionsRequest.permissions` that the caller is allowed.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Transaction": { +"description": "A transaction.", +"id": "Transaction", +"properties": { +"id": { +"description": "`id` may be used to identify the transaction in subsequent Read, ExecuteSql, Commit, or Rollback calls. Single-use read-only transactions do not have IDs, because single-use transactions do not support multiple requests.", +"format": "byte", +"type": "string" +}, +"precommitToken": { +"$ref": "MultiplexedSessionPrecommitToken", +"description": "A precommit token will be included in the response of a BeginTransaction request if the read-write transaction is on a multiplexed session and a mutation_key was specified in the BeginTransaction. The precommit token with the highest sequence number from this transaction attempt should be passed to the Commit request for this transaction." +}, +"readTimestamp": { +"description": "For snapshot read-only transactions, the read timestamp chosen for the transaction. Not returned by default: see TransactionOptions.ReadOnly.return_read_timestamp. A timestamp in RFC3339 UTC \\\"Zulu\\\" format, accurate to nanoseconds. Example: `\"2014-10-02T15:01:23.045123456Z\"`.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"TransactionOptions": { +"description": "Transactions: Each session can have at most one active transaction at a time (note that standalone reads and queries use a transaction internally and do count towards the one transaction limit). After the active transaction is completed, the session can immediately be re-used for the next transaction. It is not necessary to create a new session for each transaction. Transaction modes: Cloud Spanner supports three transaction modes: 1. Locking read-write. This type of transaction is the only way to write data into Cloud Spanner. These transactions rely on pessimistic locking and, if necessary, two-phase commit. Locking read-write transactions may abort, requiring the application to retry. 2. Snapshot read-only. Snapshot read-only transactions provide guaranteed consistency across several reads, but do not allow writes. Snapshot read-only transactions can be configured to read at timestamps in the past, or configured to perform a strong read (where Spanner will select a timestamp such that the read is guaranteed to see the effects of all transactions that have committed before the start of the read). Snapshot read-only transactions do not need to be committed. Queries on change streams must be performed with the snapshot read-only transaction mode, specifying a strong read. See TransactionOptions.ReadOnly.strong for more details. 3. Partitioned DML. This type of transaction is used to execute a single Partitioned DML statement. Partitioned DML partitions the key space and runs the DML statement over each partition in parallel using separate, internal transactions that commit independently. Partitioned DML transactions do not need to be committed. For transactions that only read, snapshot read-only transactions provide simpler semantics and are almost always faster. In particular, read-only transactions do not take locks, so they do not conflict with read-write transactions. As a consequence of not taking locks, they also do not abort, so retry loops are not needed. Transactions may only read-write data in a single database. They may, however, read-write data in different tables within that database. Locking read-write transactions: Locking transactions may be used to atomically read-modify-write data anywhere in a database. This type of transaction is externally consistent. Clients should attempt to minimize the amount of time a transaction is active. Faster transactions commit with higher probability and cause less contention. Cloud Spanner attempts to keep read locks active as long as the transaction continues to do reads, and the transaction has not been terminated by Commit or Rollback. Long periods of inactivity at the client may cause Cloud Spanner to release a transaction's locks and abort it. Conceptually, a read-write transaction consists of zero or more reads or SQL statements followed by Commit. At any time before Commit, the client can send a Rollback request to abort the transaction. Semantics: Cloud Spanner can commit the transaction if all read locks it acquired are still valid at commit time, and it is able to acquire write locks for all writes. Cloud Spanner can abort the transaction for any reason. If a commit attempt returns `ABORTED`, Cloud Spanner guarantees that the transaction has not modified any user data in Cloud Spanner. Unless the transaction commits, Cloud Spanner makes no guarantees about how long the transaction's locks were held for. It is an error to use Cloud Spanner locks for any sort of mutual exclusion other than between Cloud Spanner transactions themselves. Retrying aborted transactions: When a transaction aborts, the application can choose to retry the whole transaction again. To maximize the chances of successfully committing the retry, the client should execute the retry in the same session as the original attempt. The original session's lock priority increases with each consecutive abort, meaning that each attempt has a slightly better chance of success than the previous. Note that the lock priority is preserved per session (not per transaction). Lock priority is set by the first read or write in the first attempt of a read-write transaction. If the application starts a new session to retry the whole transaction, the transaction loses its original lock priority. Moreover, the lock priority is only preserved if the transaction fails with an `ABORTED` error. Under some circumstances (for example, many transactions attempting to modify the same row(s)), a transaction can abort many times in a short period before successfully committing. Thus, it is not a good idea to cap the number of retries a transaction can attempt; instead, it is better to limit the total amount of time spent retrying. Idle transactions: A transaction is considered idle if it has no outstanding reads or SQL queries and has not started a read or SQL query within the last 10 seconds. Idle transactions can be aborted by Cloud Spanner so that they don't hold on to locks indefinitely. If an idle transaction is aborted, the commit will fail with error `ABORTED`. If this behavior is undesirable, periodically executing a simple SQL query in the transaction (for example, `SELECT 1`) prevents the transaction from becoming idle. Snapshot read-only transactions: Snapshot read-only transactions provides a simpler method than locking read-write transactions for doing several consistent reads. However, this type of transaction does not support writes. Snapshot transactions do not take locks. Instead, they work by choosing a Cloud Spanner timestamp, then executing all reads at that timestamp. Since they do not acquire locks, they do not block concurrent read-write transactions. Unlike locking read-write transactions, snapshot read-only transactions never abort. They can fail if the chosen read timestamp is garbage collected; however, the default garbage collection policy is generous enough that most applications do not need to worry about this in practice. Snapshot read-only transactions do not need to call Commit or Rollback (and in fact are not permitted to do so). To execute a snapshot transaction, the client specifies a timestamp bound, which tells Cloud Spanner how to choose a read timestamp. The types of timestamp bound are: - Strong (the default). - Bounded staleness. - Exact staleness. If the Cloud Spanner database to be read is geographically distributed, stale read-only transactions can execute more quickly than strong or read-write transactions, because they are able to execute far from the leader replica. Each type of timestamp bound is discussed in detail below. Strong: Strong reads are guaranteed to see the effects of all transactions that have committed before the start of the read. Furthermore, all rows yielded by a single read are consistent with each other -- if any part of the read observes a transaction, all parts of the read see the transaction. Strong reads are not repeatable: two consecutive strong read-only transactions might return inconsistent results if there are concurrent writes. If consistency across reads is required, the reads should be executed within a transaction or at an exact read timestamp. Queries on change streams (see below for more details) must also specify the strong read timestamp bound. See TransactionOptions.ReadOnly.strong. Exact staleness: These timestamp bounds execute reads at a user-specified timestamp. Reads at a timestamp are guaranteed to see a consistent prefix of the global transaction history: they observe modifications done by all transactions with a commit timestamp less than or equal to the read timestamp, and observe none of the modifications done by transactions with a larger commit timestamp. They will block until all conflicting transactions that may be assigned commit timestamps <= the read timestamp have finished. The timestamp can either be expressed as an absolute Cloud Spanner commit timestamp or a staleness relative to the current time. These modes do not require a \"negotiation phase\" to pick a timestamp. As a result, they execute slightly faster than the equivalent boundedly stale concurrency modes. On the other hand, boundedly stale reads usually return fresher results. See TransactionOptions.ReadOnly.read_timestamp and TransactionOptions.ReadOnly.exact_staleness. Bounded staleness: Bounded staleness modes allow Cloud Spanner to pick the read timestamp, subject to a user-provided staleness bound. Cloud Spanner chooses the newest timestamp within the staleness bound that allows execution of the reads at the closest available replica without blocking. All rows yielded are consistent with each other -- if any part of the read observes a transaction, all parts of the read see the transaction. Boundedly stale reads are not repeatable: two stale reads, even if they use the same staleness bound, can execute at different timestamps and thus return inconsistent results. Boundedly stale reads execute in two phases: the first phase negotiates a timestamp among all replicas needed to serve the read. In the second phase, reads are executed at the negotiated timestamp. As a result of the two phase execution, bounded staleness reads are usually a little slower than comparable exact staleness reads. However, they are typically able to return fresher results, and are more likely to execute at the closest replica. Because the timestamp negotiation requires up-front knowledge of which rows will be read, it can only be used with single-use read-only transactions. See TransactionOptions.ReadOnly.max_staleness and TransactionOptions.ReadOnly.min_read_timestamp. Old read timestamps and garbage collection: Cloud Spanner continuously garbage collects deleted and overwritten data in the background to reclaim storage space. This process is known as \"version GC\". By default, version GC reclaims versions after they are one hour old. Because of this, Cloud Spanner cannot perform reads at read timestamps more than one hour in the past. This restriction also applies to in-progress reads and/or SQL queries whose timestamp become too old while executing. Reads and SQL queries with too-old read timestamps fail with the error `FAILED_PRECONDITION`. You can configure and extend the `VERSION_RETENTION_PERIOD` of a database up to a period as long as one week, which allows Cloud Spanner to perform reads up to one week in the past. Querying change Streams: A Change Stream is a schema object that can be configured to watch data changes on the entire database, a set of tables, or a set of columns in a database. When a change stream is created, Spanner automatically defines a corresponding SQL Table-Valued Function (TVF) that can be used to query the change records in the associated change stream using the ExecuteStreamingSql API. The name of the TVF for a change stream is generated from the name of the change stream: READ_. All queries on change stream TVFs must be executed using the ExecuteStreamingSql API with a single-use read-only transaction with a strong read-only timestamp_bound. The change stream TVF allows users to specify the start_timestamp and end_timestamp for the time range of interest. All change records within the retention period is accessible using the strong read-only timestamp_bound. All other TransactionOptions are invalid for change stream queries. In addition, if TransactionOptions.read_only.return_read_timestamp is set to true, a special value of 2^63 - 2 will be returned in the Transaction message that describes the transaction, instead of a valid read timestamp. This special value should be discarded and not used for any subsequent queries. Please see https://cloud.google.com/spanner/docs/change-streams for more details on how to query the change stream TVFs. Partitioned DML transactions: Partitioned DML transactions are used to execute DML statements with a different execution strategy that provides different, and often better, scalability properties for large, table-wide operations than DML in a ReadWrite transaction. Smaller scoped statements, such as an OLTP workload, should prefer using ReadWrite transactions. Partitioned DML partitions the keyspace and runs the DML statement on each partition in separate, internal transactions. These transactions commit automatically when complete, and run independently from one another. To reduce lock contention, this execution strategy only acquires read locks on rows that match the WHERE clause of the statement. Additionally, the smaller per-partition transactions hold locks for less time. That said, Partitioned DML is not a drop-in replacement for standard DML used in ReadWrite transactions. - The DML statement must be fully-partitionable. Specifically, the statement must be expressible as the union of many statements which each access only a single row of the table. - The statement is not applied atomically to all rows of the table. Rather, the statement is applied atomically to partitions of the table, in independent transactions. Secondary index rows are updated atomically with the base table rows. - Partitioned DML does not guarantee exactly-once execution semantics against a partition. The statement is applied at least once to each partition. It is strongly recommended that the DML statement should be idempotent to avoid unexpected results. For instance, it is potentially dangerous to run a statement such as `UPDATE table SET column = column + 1` as it could be run multiple times against some rows. - The partitions are committed automatically - there is no support for Commit or Rollback. If the call returns an error, or if the client issuing the ExecuteSql call dies, it is possible that some rows had the statement executed on them successfully. It is also possible that statement was never executed against other rows. - Partitioned DML transactions may only contain the execution of a single DML statement via ExecuteSql or ExecuteStreamingSql. - If any error is encountered during the execution of the partitioned DML operation (for instance, a UNIQUE INDEX violation, division by zero, or a value that cannot be stored due to schema constraints), then the operation is stopped at that point and an error is returned. It is possible that at this point, some partitions have been committed (or even committed multiple times), and other partitions have not been run at all. Given the above, Partitioned DML is good fit for large, database-wide, operations that are idempotent, such as deleting old rows from a very large table.", +"id": "TransactionOptions", +"properties": { +"excludeTxnFromChangeStreams": { +"description": "When `exclude_txn_from_change_streams` is set to `true`: * Modifications from this transaction will not be recorded in change streams with DDL option `allow_txn_exclusion=true` that are tracking columns modified by these transactions. * Modifications from this transaction will be recorded in change streams with DDL option `allow_txn_exclusion=false or not set` that are tracking columns modified by these transactions. When `exclude_txn_from_change_streams` is set to `false` or not set, Modifications from this transaction will be recorded in all change streams that are tracking columns modified by these transactions. `exclude_txn_from_change_streams` may only be specified for read-write or partitioned-dml transactions, otherwise the API will return an `INVALID_ARGUMENT` error.", +"type": "boolean" +}, +"partitionedDml": { +"$ref": "PartitionedDml", +"description": "Partitioned DML transaction. Authorization to begin a Partitioned DML transaction requires `spanner.databases.beginPartitionedDmlTransaction` permission on the `session` resource." +}, +"readOnly": { +"$ref": "ReadOnly", +"description": "Transaction will not write. Authorization to begin a read-only transaction requires `spanner.databases.beginReadOnlyTransaction` permission on the `session` resource." +}, +"readWrite": { +"$ref": "ReadWrite", +"description": "Transaction may write. Authorization to begin a read-write transaction requires `spanner.databases.beginOrRollbackReadWriteTransaction` permission on the `session` resource." +} +}, +"type": "object" +}, +"TransactionSelector": { +"description": "This message is used to select the transaction in which a Read or ExecuteSql call runs. See TransactionOptions for more information about transactions.", +"id": "TransactionSelector", +"properties": { +"begin": { +"$ref": "TransactionOptions", +"description": "Begin a new transaction and execute this read or SQL query in it. The transaction ID of the new transaction is returned in ResultSetMetadata.transaction, which is a Transaction." +}, +"id": { +"description": "Execute the read or SQL query in a previously-started transaction.", +"format": "byte", +"type": "string" +}, +"singleUse": { +"$ref": "TransactionOptions", +"description": "Execute the read or SQL query in a temporary transaction. This is the most efficient way to execute a transaction that consists of a single SQL query." +} +}, +"type": "object" +}, +"Type": { +"description": "`Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query.", +"id": "Type", +"properties": { +"arrayElementType": { +"$ref": "Type", +"description": "If code == ARRAY, then `array_element_type` is the type of the array elements." +}, +"code": { +"description": "Required. The TypeCode for this type.", +"enum": [ +"TYPE_CODE_UNSPECIFIED", +"BOOL", +"INT64", +"FLOAT64", +"FLOAT32", +"TIMESTAMP", +"DATE", +"STRING", +"BYTES", +"ARRAY", +"STRUCT", +"NUMERIC", +"JSON", +"PROTO", +"ENUM", +"INTERVAL" +], +"enumDescriptions": [ +"Not specified.", +"Encoded as JSON `true` or `false`.", +"Encoded as `string`, in decimal format.", +"Encoded as `number`, or the strings `\"NaN\"`, `\"Infinity\"`, or `\"-Infinity\"`.", +"Encoded as `number`, or the strings `\"NaN\"`, `\"Infinity\"`, or `\"-Infinity\"`.", +"Encoded as `string` in RFC 3339 timestamp format. The time zone must be present, and must be `\"Z\"`. If the schema has the column option `allow_commit_timestamp=true`, the placeholder string `\"spanner.commit_timestamp()\"` can be used to instruct the system to insert the commit timestamp associated with the transaction commit.", +"Encoded as `string` in RFC 3339 date format.", +"Encoded as `string`.", +"Encoded as a base64-encoded `string`, as described in RFC 4648, section 4.", +"Encoded as `list`, where the list elements are represented according to array_element_type.", +"Encoded as `list`, where list element `i` is represented according to [struct_type.fields[i]][google.spanner.v1.StructType.fields].", +"Encoded as `string`, in decimal format or scientific notation format. Decimal format: `[+-]Digits[.[Digits]]` or `+-.Digits` Scientific notation: `[+-]Digits[.[Digits]][ExponentIndicator[+-]Digits]` or `+-.Digits[ExponentIndicator[+-]Digits]` (ExponentIndicator is `\"e\"` or `\"E\"`)", +"Encoded as a JSON-formatted `string` as described in RFC 7159. The following rules are applied when parsing JSON input: - Whitespace characters are not preserved. - If a JSON object has duplicate keys, only the first key is preserved. - Members of a JSON object are not guaranteed to have their order preserved. - JSON array elements will have their order preserved.", +"Encoded as a base64-encoded `string`, as described in RFC 4648, section 4.", +"Encoded as `string`, in decimal format.", +"Encoded as `string`, in `ISO8601` duration format - `P[n]Y[n]M[n]DT[n]H[n]M[n[.fraction]]S` where `n` is an integer. For example, `P1Y2M3DT4H5M6.5S` represents time duration of 1 year, 2 months, 3 days, 4 hours, 5 minutes, and 6.5 seconds." +], +"type": "string" +}, +"protoTypeFqn": { +"description": "If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.", +"type": "string" +}, +"structType": { +"$ref": "StructType", +"description": "If code == STRUCT, then `struct_type` provides type information for the struct's fields." +}, +"typeAnnotation": { +"description": "The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.", +"enum": [ +"TYPE_ANNOTATION_CODE_UNSPECIFIED", +"PG_NUMERIC", +"PG_JSONB" +], +"enumDescriptions": [ +"Not specified.", +"PostgreSQL compatible NUMERIC type. This annotation needs to be applied to Type instances having NUMERIC type code to specify that values of this type should be treated as PostgreSQL NUMERIC values. Currently this annotation is always needed for NUMERIC when a client interacts with PostgreSQL-enabled Spanner databases.", +"PostgreSQL compatible JSONB type. This annotation needs to be applied to Type instances having JSON type code to specify that values of this type should be treated as PostgreSQL JSONB values. Currently this annotation is always needed for JSON when a client interacts with PostgreSQL-enabled Spanner databases." +], +"type": "string" +} +}, +"type": "object" +}, +"UpdateDatabaseDdlMetadata": { +"description": "Metadata type for the operation returned by UpdateDatabaseDdl.", +"id": "UpdateDatabaseDdlMetadata", +"properties": { +"actions": { +"description": "The brief action info for the DDL statements. `actions[i]` is the brief info for `statements[i]`.", +"items": { +"$ref": "DdlStatementActionInfo" +}, +"type": "array" +}, +"commitTimestamps": { +"description": "Reports the commit timestamps of all statements that have succeeded so far, where `commit_timestamps[i]` is the commit timestamp for the statement `statements[i]`.", +"items": { +"format": "google-datetime", +"type": "string" +}, +"type": "array" +}, +"database": { +"description": "The database being modified.", +"type": "string" +}, +"progress": { +"description": "The progress of the UpdateDatabaseDdl operations. All DDL statements will have continuously updating progress, and `progress[i]` is the operation progress for `statements[i]`. Also, `progress[i]` will have start time and end time populated with commit timestamp of operation, as well as a progress of 100% once the operation has completed.", +"items": { +"$ref": "OperationProgress" +}, +"type": "array" +}, +"statements": { +"description": "For an update this list contains all the statements. For an individual statement, this list contains only that statement.", +"items": { +"type": "string" +}, +"type": "array" +}, +"throttled": { +"description": "Output only. When true, indicates that the operation is throttled e.g. due to resource constraints. When resources become available the operation will resume and this field will be false again.", +"readOnly": true, +"type": "boolean" +} +}, +"type": "object" +}, +"UpdateDatabaseDdlRequest": { +"description": "Enqueues the given DDL statements to be applied, in order but not necessarily all at once, to the database schema at some point (or points) in the future. The server checks that the statements are executable (syntactically valid, name tables that exist, etc.) before enqueueing them, but they may still fail upon later execution (e.g., if a statement from another batch of statements is applied first and it conflicts in some way, or if there is some data-related problem like a `NULL` value in a column to which `NOT NULL` would be added). If a statement fails, all subsequent statements in the batch are automatically cancelled. Each batch of statements is assigned a name which can be used with the Operations API to monitor progress. See the operation_id field for more details.", +"id": "UpdateDatabaseDdlRequest", +"properties": { +"operationId": { +"description": "If empty, the new update request is assigned an automatically-generated operation ID. Otherwise, `operation_id` is used to construct the name of the resulting Operation. Specifying an explicit operation ID simplifies determining whether the statements were executed in the event that the UpdateDatabaseDdl call is replayed, or the return value is otherwise lost: the database and `operation_id` fields can be combined to form the `name` of the resulting longrunning.Operation: `/operations/`. `operation_id` should be unique within the database, and must be a valid identifier: `a-z*`. Note that automatically-generated operation IDs always begin with an underscore. If the named operation already exists, UpdateDatabaseDdl returns `ALREADY_EXISTS`.", +"type": "string" +}, +"protoDescriptors": { +"description": "Optional. Proto descriptors used by CREATE/ALTER PROTO BUNDLE statements. Contains a protobuf-serialized [google.protobufFileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). To generate it, [install](https://grpc.io/docs/protoc-installation/) and run `protoc` with --include_imports and --descriptor_set_out. For example, to generate for moon/shot/app.proto, run ``` $protoc --proto_path=/app_path --proto_path=/lib_path \\ --include_imports \\ --descriptor_set_out=descriptors.data \\ moon/shot/app.proto ``` For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).", +"format": "byte", +"type": "string" +}, +"statements": { +"description": "Required. DDL statements to be applied to the database.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"UpdateDatabaseMetadata": { +"description": "Metadata type for the operation returned by UpdateDatabase.", +"id": "UpdateDatabaseMetadata", +"properties": { +"cancelTime": { +"description": "The time at which this operation was cancelled. If set, this operation is in the process of undoing itself (which is best-effort).", +"format": "google-datetime", +"type": "string" +}, +"progress": { +"$ref": "OperationProgress", +"description": "The progress of the UpdateDatabase operation." +}, +"request": { +"$ref": "UpdateDatabaseRequest", +"description": "The request for UpdateDatabase." +} +}, +"type": "object" +}, +"UpdateDatabaseRequest": { +"description": "The request for UpdateDatabase.", +"id": "UpdateDatabaseRequest", +"properties": { +"database": { +"$ref": "Database", +"description": "Required. The database to update. The `name` field of the database is of the form `projects//instances//databases/`." +}, +"updateMask": { +"description": "Required. The list of fields to update. Currently, only `enable_drop_protection` field can be updated.", +"format": "google-fieldmask", +"type": "string" +} +}, +"type": "object" +}, +"UpdateInstanceConfigMetadata": { +"description": "Metadata type for the operation returned by UpdateInstanceConfig.", +"id": "UpdateInstanceConfigMetadata", +"properties": { +"cancelTime": { +"description": "The time at which this operation was cancelled.", +"format": "google-datetime", +"type": "string" +}, +"instanceConfig": { +"$ref": "InstanceConfig", +"description": "The desired instance configuration after updating." +}, +"progress": { +"$ref": "InstanceOperationProgress", +"description": "The progress of the UpdateInstanceConfig operation." +} +}, +"type": "object" +}, +"UpdateInstanceConfigRequest": { +"description": "The request for UpdateInstanceConfig.", +"id": "UpdateInstanceConfigRequest", +"properties": { +"instanceConfig": { +"$ref": "InstanceConfig", +"description": "Required. The user instance configuration to update, which must always include the instance configuration name. Otherwise, only fields mentioned in update_mask need be included. To prevent conflicts of concurrent updates, etag can be used." +}, +"updateMask": { +"description": "Required. A mask specifying which fields in InstanceConfig should be updated. The field mask must always be specified; this prevents any future fields in InstanceConfig from being erased accidentally by clients that do not know about them. Only display_name and labels can be updated.", +"format": "google-fieldmask", +"type": "string" +}, +"validateOnly": { +"description": "An option to validate, but not actually execute, a request, and provide the same response.", +"type": "boolean" +} +}, +"type": "object" +}, +"UpdateInstanceMetadata": { +"description": "Metadata type for the operation returned by UpdateInstance.", +"id": "UpdateInstanceMetadata", +"properties": { +"cancelTime": { +"description": "The time at which this operation was cancelled. If set, this operation is in the process of undoing itself (which is guaranteed to succeed) and cannot be cancelled again.", +"format": "google-datetime", +"type": "string" +}, +"endTime": { +"description": "The time at which this operation failed or was completed successfully.", +"format": "google-datetime", +"type": "string" +}, +"expectedFulfillmentPeriod": { +"description": "The expected fulfillment period of this update operation.", +"enum": [ +"FULFILLMENT_PERIOD_UNSPECIFIED", +"FULFILLMENT_PERIOD_NORMAL", +"FULFILLMENT_PERIOD_EXTENDED" +], +"enumDescriptions": [ +"Not specified.", +"Normal fulfillment period. The operation is expected to complete within minutes.", +"Extended fulfillment period. It can take up to an hour for the operation to complete." +], +"type": "string" +}, +"instance": { +"$ref": "Instance", +"description": "The desired end state of the update." +}, +"startTime": { +"description": "The time at which UpdateInstance request was received.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"UpdateInstancePartitionMetadata": { +"description": "Metadata type for the operation returned by UpdateInstancePartition.", +"id": "UpdateInstancePartitionMetadata", +"properties": { +"cancelTime": { +"description": "The time at which this operation was cancelled. If set, this operation is in the process of undoing itself (which is guaranteed to succeed) and cannot be cancelled again.", +"format": "google-datetime", +"type": "string" +}, +"endTime": { +"description": "The time at which this operation failed or was completed successfully.", +"format": "google-datetime", +"type": "string" +}, +"instancePartition": { +"$ref": "InstancePartition", +"description": "The desired end state of the update." +}, +"startTime": { +"description": "The time at which UpdateInstancePartition request was received.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"UpdateInstancePartitionRequest": { +"description": "The request for UpdateInstancePartition.", +"id": "UpdateInstancePartitionRequest", +"properties": { +"fieldMask": { +"description": "Required. A mask specifying which fields in InstancePartition should be updated. The field mask must always be specified; this prevents any future fields in InstancePartition from being erased accidentally by clients that do not know about them.", +"format": "google-fieldmask", +"type": "string" +}, +"instancePartition": { +"$ref": "InstancePartition", +"description": "Required. The instance partition to update, which must always include the instance partition name. Otherwise, only fields mentioned in field_mask need be included." +} +}, +"type": "object" +}, +"UpdateInstanceRequest": { +"description": "The request for UpdateInstance.", +"id": "UpdateInstanceRequest", +"properties": { +"fieldMask": { +"description": "Required. A mask specifying which fields in Instance should be updated. The field mask must always be specified; this prevents any future fields in Instance from being erased accidentally by clients that do not know about them.", +"format": "google-fieldmask", +"type": "string" +}, +"instance": { +"$ref": "Instance", +"description": "Required. The instance to update, which must always include the instance name. Otherwise, only fields mentioned in field_mask need be included." +} +}, +"type": "object" +}, +"VisualizationData": { +"id": "VisualizationData", +"properties": { +"dataSourceEndToken": { +"description": "The token signifying the end of a data_source.", +"type": "string" +}, +"dataSourceSeparatorToken": { +"description": "The token delimiting a datasource name from the rest of a key in a data_source.", +"type": "string" +}, +"diagnosticMessages": { +"description": "The list of messages (info, alerts, ...)", +"items": { +"$ref": "DiagnosticMessage" +}, +"type": "array" +}, +"endKeyStrings": { +"description": "We discretize the entire keyspace into buckets. Assuming each bucket has an inclusive keyrange and covers keys from k(i) ... k(n). In this case k(n) would be an end key for a given range. end_key_string is the collection of all such end keys", +"items": { +"type": "string" +}, +"type": "array" +}, +"hasPii": { +"description": "Whether this scan contains PII.", +"type": "boolean" +}, +"indexedKeys": { +"description": "Keys of key ranges that contribute significantly to a given metric Can be thought of as heavy hitters.", +"items": { +"type": "string" +}, +"type": "array" +}, +"keySeparator": { +"description": "The token delimiting the key prefixes.", +"type": "string" +}, +"keyUnit": { +"description": "The unit for the key: e.g. 'key' or 'chunk'.", +"enum": [ +"KEY_UNIT_UNSPECIFIED", +"KEY", +"CHUNK" +], +"enumDescriptions": [ +"Required default value", +"Each entry corresponds to one key", +"Each entry corresponds to a chunk of keys" +], +"type": "string" +}, +"metrics": { +"description": "The list of data objects for each metric.", +"items": { +"$ref": "Metric" +}, +"type": "array" +}, +"prefixNodes": { +"description": "The list of extracted key prefix nodes used in the key prefix hierarchy.", +"items": { +"$ref": "PrefixNode" +}, +"type": "array" +} +}, +"type": "object" +}, +"Write": { +"description": "Arguments to insert, update, insert_or_update, and replace operations.", +"id": "Write", +"properties": { +"columns": { +"description": "The names of the columns in table to be written. The list of columns must contain enough columns to allow Cloud Spanner to derive values for all primary key columns in the row(s) to be modified.", +"items": { +"type": "string" +}, +"type": "array" +}, +"table": { +"description": "Required. The table whose rows will be written.", +"type": "string" +}, +"values": { +"description": "The values to be written. `values` can contain more than one list of values. If it does, then multiple rows are written, one for each entry in `values`. Each list in `values` must have exactly as many entries as there are entries in columns above. Sending multiple lists is equivalent to sending multiple `Mutation`s, each containing one `values` entry and repeating table and columns. Individual values in each list are encoded as described here.", +"items": { +"items": { +"type": "any" +}, +"type": "array" +}, +"type": "array" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Cloud Spanner API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/speech.v2beta1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/speech.v2beta1.json new file mode 100644 index 0000000000000000000000000000000000000000..7f7e753e91ef6a7d08cb292fcc32dd35e2e35928 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/speech.v2beta1.json @@ -0,0 +1,407 @@ +{ + "auth": { + "oauth2": { + "scopes": { + "https://www.googleapis.com/auth/cloud-platform": { + "description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." + } + } + } + }, + "basePath": "", + "baseUrl": "https://speech.googleapis.com/", + "batchPath": "batch", + "canonicalName": "Speech", + "description": "Converts audio to text by applying powerful neural network models.", + "discoveryVersion": "v1", + "documentationLink": "https://cloud.google.com/speech-to-text/docs/quickstart-protocol", + "fullyEncodeReservedExpansion": true, + "icons": { + "x16": "http://www.google.com/images/icons/product/search-16.gif", + "x32": "http://www.google.com/images/icons/product/search-32.gif" + }, + "id": "speech:v2beta1", + "kind": "discovery#restDescription", + "mtlsRootUrl": "https://speech.mtls.googleapis.com/", + "name": "speech", + "ownerDomain": "google.com", + "ownerName": "Google", + "parameters": { + "$.xgafv": { + "description": "V1 error format.", + "enum": [ + "1", + "2" + ], + "enumDescriptions": [ + "v1 error format", + "v2 error format" + ], + "location": "query", + "type": "string" + }, + "access_token": { + "description": "OAuth access token.", + "location": "query", + "type": "string" + }, + "alt": { + "default": "json", + "description": "Data format for response.", + "enum": [ + "json", + "media", + "proto" + ], + "enumDescriptions": [ + "Responses with Content-Type of application/json", + "Media download with context-dependent Content-Type", + "Responses with Content-Type of application/x-protobuf" + ], + "location": "query", + "type": "string" + }, + "callback": { + "description": "JSONP", + "location": "query", + "type": "string" + }, + "fields": { + "description": "Selector specifying which fields to include in a partial response.", + "location": "query", + "type": "string" + }, + "key": { + "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", + "location": "query", + "type": "string" + }, + "oauth_token": { + "description": "OAuth 2.0 token for the current user.", + "location": "query", + "type": "string" + }, + "prettyPrint": { + "default": "true", + "description": "Returns response with indentations and line breaks.", + "location": "query", + "type": "boolean" + }, + "quotaUser": { + "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", + "location": "query", + "type": "string" + }, + "uploadType": { + "description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", + "location": "query", + "type": "string" + }, + "upload_protocol": { + "description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", + "location": "query", + "type": "string" + } + }, + "protocol": "rest", + "resources": { + "projects": { + "resources": { + "locations": { + "resources": { + "operations": { + "methods": { + "get": { + "description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", + "flatPath": "v2beta1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}", + "httpMethod": "GET", + "id": "speech.projects.locations.operations.get", + "parameterOrder": [ + "name" + ], + "parameters": { + "name": { + "description": "The name of the operation resource.", + "location": "path", + "pattern": "^projects/[^/]+/locations/[^/]+/operations/[^/]+$", + "required": true, + "type": "string" + } + }, + "path": "v2beta1/{+name}", + "response": { + "$ref": "Operation" + }, + "scopes": [ + "https://www.googleapis.com/auth/cloud-platform" + ] + }, + "list": { + "description": "Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the `name` binding allows API services to override the binding to use different resource name schemes, such as `users/*/operations`. To override the binding, API services can add a binding such as `\"/v1/{name=users/*}/operations\"` to their service configuration. For backwards compatibility, the default name includes the operations collection id, however overriding users must ensure the name binding is the parent resource, without the operations collection id.", + "flatPath": "v2beta1/projects/{projectsId}/locations/{locationsId}/operations", + "httpMethod": "GET", + "id": "speech.projects.locations.operations.list", + "parameterOrder": [ + "name" + ], + "parameters": { + "filter": { + "description": "The standard list filter.", + "location": "query", + "type": "string" + }, + "name": { + "description": "The name of the operation's parent resource.", + "location": "path", + "pattern": "^projects/[^/]+/locations/[^/]+$", + "required": true, + "type": "string" + }, + "pageSize": { + "description": "The standard list page size.", + "format": "int32", + "location": "query", + "type": "integer" + }, + "pageToken": { + "description": "The standard list page token.", + "location": "query", + "type": "string" + } + }, + "path": "v2beta1/{+name}/operations", + "response": { + "$ref": "ListOperationsResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/cloud-platform" + ] + } + } + } + } + } + } + } + }, + "revision": "20220728", + "rootUrl": "https://speech.googleapis.com/", + "schemas": { + "ListOperationsResponse": { + "description": "The response message for Operations.ListOperations.", + "id": "ListOperationsResponse", + "properties": { + "nextPageToken": { + "description": "The standard List next-page token.", + "type": "string" + }, + "operations": { + "description": "A list of operations that matches the specified filter in the request.", + "items": { + "$ref": "Operation" + }, + "type": "array" + } + }, + "type": "object" + }, + "LongRunningRecognizeMetadata": { + "description": "Describes the progress of a long-running `LongRunningRecognize` call. It is included in the `metadata` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", + "id": "LongRunningRecognizeMetadata", + "properties": { + "lastUpdateTime": { + "description": "Output only. Time of the most recent processing update.", + "format": "google-datetime", + "readOnly": true, + "type": "string" + }, + "progressPercent": { + "description": "Output only. Approximate percentage of audio processed thus far. Guaranteed to be 100 when the audio is fully processed and the results are available.", + "format": "int32", + "readOnly": true, + "type": "integer" + }, + "startTime": { + "description": "Output only. Time when the request was received.", + "format": "google-datetime", + "readOnly": true, + "type": "string" + }, + "uri": { + "description": "The URI of the audio file being transcribed. Empty if the audio was sent as byte content.", + "type": "string" + } + }, + "type": "object" + }, + "LongRunningRecognizeResponse": { + "description": "The only message returned to the client by the `LongRunningRecognize` method. It contains the result as zero or more sequential SpeechRecognitionResult messages. It is included in the `result.response` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", + "id": "LongRunningRecognizeResponse", + "properties": { + "results": { + "description": "Output only. Sequential list of transcription results corresponding to sequential portions of audio.", + "items": { + "$ref": "SpeechRecognitionResult" + }, + "readOnly": true, + "type": "array" + } + }, + "type": "object" + }, + "Operation": { + "description": "This resource represents a long-running operation that is the result of a network API call.", + "id": "Operation", + "properties": { + "done": { + "description": "If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.", + "type": "boolean" + }, + "error": { + "$ref": "Status", + "description": "The error result of the operation in case of failure or cancellation." + }, + "metadata": { + "additionalProperties": { + "description": "Properties of the object. Contains field @type with type URL.", + "type": "any" + }, + "description": "Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.", + "type": "object" + }, + "name": { + "description": "The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.", + "type": "string" + }, + "response": { + "additionalProperties": { + "description": "Properties of the object. Contains field @type with type URL.", + "type": "any" + }, + "description": "The normal response of the operation in case of success. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.", + "type": "object" + } + }, + "type": "object" + }, + "SpeechRecognitionAlternative": { + "description": "Alternative hypotheses (a.k.a. n-best list).", + "id": "SpeechRecognitionAlternative", + "properties": { + "confidence": { + "description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative of a non-streaming result or, of a streaming result where `is_final=true`. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", + "format": "float", + "readOnly": true, + "type": "number" + }, + "transcript": { + "description": "Output only. Transcript text representing the words that the user spoke.", + "readOnly": true, + "type": "string" + }, + "words": { + "description": "Output only. A list of word-specific information for each recognized word. Note: When `enable_speaker_diarization` is true, you will see all the words from the beginning of the audio.", + "items": { + "$ref": "WordInfo" + }, + "readOnly": true, + "type": "array" + } + }, + "type": "object" + }, + "SpeechRecognitionResult": { + "description": "A speech recognition result corresponding to a portion of the audio.", + "id": "SpeechRecognitionResult", + "properties": { + "alternatives": { + "description": "Output only. May contain one or more recognition hypotheses (up to the maximum specified in `max_alternatives`). These alternatives are ordered in terms of accuracy, with the top (first) alternative being the most probable, as ranked by the recognizer.", + "items": { + "$ref": "SpeechRecognitionAlternative" + }, + "readOnly": true, + "type": "array" + }, + "channelTag": { + "description": "Output only. For multi-channel audio, this is the channel number corresponding to the recognized result for the audio from that channel. For `audio_channel_count` = N, its output values can range from `1` to `N`.", + "format": "int32", + "readOnly": true, + "type": "integer" + }, + "languageCode": { + "description": "Output only. The [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag of the language in this result. This language code was detected to have the most likelihood of being spoken in the audio.", + "readOnly": true, + "type": "string" + } + }, + "type": "object" + }, + "Status": { + "description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", + "id": "Status", + "properties": { + "code": { + "description": "The status code, which should be an enum value of google.rpc.Code.", + "format": "int32", + "type": "integer" + }, + "details": { + "description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", + "items": { + "additionalProperties": { + "description": "Properties of the object. Contains field @type with type URL.", + "type": "any" + }, + "type": "object" + }, + "type": "array" + }, + "message": { + "description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", + "type": "string" + } + }, + "type": "object" + }, + "WordInfo": { + "description": "Word-specific information for recognized words.", + "id": "WordInfo", + "properties": { + "confidence": { + "description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative of a non-streaming result or, of a streaming result where `is_final=true`. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", + "format": "float", + "readOnly": true, + "type": "number" + }, + "endOffset": { + "description": "Output only. Time offset relative to the beginning of the audio, and corresponding to the end of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", + "format": "google-duration", + "readOnly": true, + "type": "string" + }, + "speakerTag": { + "description": "Output only. A distinct integer value is assigned for every speaker within the audio. This field specifies which one of those speakers was detected to have spoken this word. Value ranges from `1` to `diarization_config.max_speaker_count` . `speaker_tag` is set if `diarization_config.enable_speaker_diarization` = `true` and only in the top alternative.", + "format": "int32", + "readOnly": true, + "type": "integer" + }, + "startOffset": { + "description": "Output only. Time offset relative to the beginning of the audio, and corresponding to the start of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", + "format": "google-duration", + "readOnly": true, + "type": "string" + }, + "word": { + "description": "Output only. The word corresponding to this set of information.", + "readOnly": true, + "type": "string" + } + }, + "type": "object" + } + }, + "servicePath": "", + "title": "Cloud Speech-to-Text API", + "version": "v2beta1", + "version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/streetviewpublish.v1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/streetviewpublish.v1.json new file mode 100644 index 0000000000000000000000000000000000000000..bcfbf0662073314a467a0f2aa8a8b5ba84fc7d77 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/streetviewpublish.v1.json @@ -0,0 +1,1333 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/streetviewpublish": { +"description": "Publish and manage your 360 photos on Google Street View" +} +} +} +}, +"basePath": "", +"baseUrl": "https://streetviewpublish.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Street View Publish", +"description": "Publishes 360 photos to Google Maps, along with position, orientation, and connectivity metadata. Apps can offer an interface for positioning, connecting, and uploading user-generated Street View images. ", +"discoveryVersion": "v1", +"documentationLink": "https://developers.google.com/streetview/publish/", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "streetviewpublish:v1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://streetviewpublish.mtls.googleapis.com/", +"name": "streetviewpublish", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"photo": { +"methods": { +"create": { +"description": "After the client finishes uploading the photo with the returned UploadRef, CreatePhoto publishes the uploaded Photo to Street View on Google Maps. Currently, the only way to set heading, pitch, and roll in CreatePhoto is through the [Photo Sphere XMP metadata](https://developers.google.com/streetview/spherical-metadata) in the photo bytes. CreatePhoto ignores the `pose.heading`, `pose.pitch`, `pose.roll`, `pose.altitude`, and `pose.level` fields in Pose. This method returns the following error codes: * google.rpc.Code.INVALID_ARGUMENT if the request is malformed or if the uploaded photo is not a 360 photo. * google.rpc.Code.NOT_FOUND if the upload reference does not exist. * google.rpc.Code.RESOURCE_EXHAUSTED if the account has reached the storage limit.", +"flatPath": "v1/photo", +"httpMethod": "POST", +"id": "streetviewpublish.photo.create", +"parameterOrder": [], +"parameters": {}, +"path": "v1/photo", +"request": { +"$ref": "Photo" +}, +"response": { +"$ref": "Photo" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"delete": { +"description": "Deletes a Photo and its metadata. This method returns the following error codes: * google.rpc.Code.PERMISSION_DENIED if the requesting user did not create the requested photo. * google.rpc.Code.NOT_FOUND if the photo ID does not exist.", +"flatPath": "v1/photo/{photoId}", +"httpMethod": "DELETE", +"id": "streetviewpublish.photo.delete", +"parameterOrder": [ +"photoId" +], +"parameters": { +"photoId": { +"description": "Required. ID of the Photo.", +"location": "path", +"required": true, +"type": "string" +} +}, +"path": "v1/photo/{photoId}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"get": { +"description": "Gets the metadata of the specified Photo. This method returns the following error codes: * google.rpc.Code.PERMISSION_DENIED if the requesting user did not create the requested Photo. * google.rpc.Code.NOT_FOUND if the requested Photo does not exist. * google.rpc.Code.UNAVAILABLE if the requested Photo is still being indexed.", +"flatPath": "v1/photo/{photoId}", +"httpMethod": "GET", +"id": "streetviewpublish.photo.get", +"parameterOrder": [ +"photoId" +], +"parameters": { +"languageCode": { +"description": "The BCP-47 language code, such as \"en-US\" or \"sr-Latn\". For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier. If language_code is unspecified, the user's language preference for Google services is used.", +"location": "query", +"type": "string" +}, +"photoId": { +"description": "Required. ID of the Photo.", +"location": "path", +"required": true, +"type": "string" +}, +"view": { +"description": "Required. Specifies if a download URL for the photo bytes should be returned in the Photo response.", +"enum": [ +"BASIC", +"INCLUDE_DOWNLOAD_URL" +], +"enumDescriptions": [ +"Server responses do not include the download URL for the photo bytes. The default value.", +"Server responses include the download URL for the photo bytes." +], +"location": "query", +"type": "string" +} +}, +"path": "v1/photo/{photoId}", +"response": { +"$ref": "Photo" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"startUpload": { +"description": "Creates an upload session to start uploading photo bytes. The method uses the upload URL of the returned UploadRef to upload the bytes for the Photo. In addition to the photo requirements shown in https://support.google.com/maps/answer/7012050?ref_topic=6275604, the photo must meet the following requirements: * Photo Sphere XMP metadata must be included in the photo metadata. See https://developers.google.com/streetview/spherical-metadata for the required fields. * The pixel size of the photo must meet the size requirements listed in https://support.google.com/maps/answer/7012050?ref_topic=6275604, and the photo must be a full 360 horizontally. After the upload completes, the method uses UploadRef with CreatePhoto to create the Photo object entry.", +"flatPath": "v1/photo:startUpload", +"httpMethod": "POST", +"id": "streetviewpublish.photo.startUpload", +"parameterOrder": [], +"parameters": {}, +"path": "v1/photo:startUpload", +"request": { +"$ref": "Empty" +}, +"response": { +"$ref": "UploadRef" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"update": { +"description": "Updates the metadata of a Photo, such as pose, place association, connections, etc. Changing the pixels of a photo is not supported. Only the fields specified in the updateMask field are used. If `updateMask` is not present, the update applies to all fields. This method returns the following error codes: * google.rpc.Code.PERMISSION_DENIED if the requesting user did not create the requested photo. * google.rpc.Code.INVALID_ARGUMENT if the request is malformed. * google.rpc.Code.NOT_FOUND if the requested photo does not exist. * google.rpc.Code.UNAVAILABLE if the requested Photo is still being indexed.", +"flatPath": "v1/photo/{id}", +"httpMethod": "PUT", +"id": "streetviewpublish.photo.update", +"parameterOrder": [ +"id" +], +"parameters": { +"id": { +"description": "A unique identifier for a photo.", +"location": "path", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. Mask that identifies fields on the photo metadata to update. If not present, the old Photo metadata is entirely replaced with the new Photo metadata in this request. The update fails if invalid fields are specified. Multiple fields can be specified in a comma-delimited list. The following fields are valid: * `pose.heading` * `pose.lat_lng_pair` * `pose.pitch` * `pose.roll` * `pose.level` * `pose.altitude` * `connections` * `places` > Note: When updateMask contains repeated fields, the entire set of repeated values get replaced with the new contents. For example, if updateMask contains `connections` and `UpdatePhotoRequest.photo.connections` is empty, all connections are removed.", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1/photo/{id}", +"request": { +"$ref": "Photo" +}, +"response": { +"$ref": "Photo" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +} +} +}, +"photoSequence": { +"methods": { +"create": { +"description": "After the client finishes uploading the PhotoSequence with the returned UploadRef, CreatePhotoSequence extracts a sequence of 360 photos from a video or Extensible Device Metadata (XDM, http://www.xdm.org/) to be published to Street View on Google Maps. `CreatePhotoSequence` returns an Operation, with the PhotoSequence Id set in the `Operation.name` field. This method returns the following error codes: * google.rpc.Code.INVALID_ARGUMENT if the request is malformed. * google.rpc.Code.NOT_FOUND if the upload reference does not exist.", +"flatPath": "v1/photoSequence", +"httpMethod": "POST", +"id": "streetviewpublish.photoSequence.create", +"parameterOrder": [], +"parameters": { +"inputType": { +"description": "Required. The input form of PhotoSequence.", +"enum": [ +"INPUT_TYPE_UNSPECIFIED", +"VIDEO", +"XDM" +], +"enumDescriptions": [ +"Not specified. Server will return google.rpc.Code.INVALID_ARGUMENT.", +"360 Video.", +"Extensible Device Metadata, http://www.xdm.org" +], +"location": "query", +"type": "string" +} +}, +"path": "v1/photoSequence", +"request": { +"$ref": "PhotoSequence" +}, +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"delete": { +"description": "Deletes a PhotoSequence and its metadata. This method returns the following error codes: * google.rpc.Code.PERMISSION_DENIED if the requesting user did not create the requested photo sequence. * google.rpc.Code.NOT_FOUND if the photo sequence ID does not exist. * google.rpc.Code.FAILED_PRECONDITION if the photo sequence ID is not yet finished processing.", +"flatPath": "v1/photoSequence/{sequenceId}", +"httpMethod": "DELETE", +"id": "streetviewpublish.photoSequence.delete", +"parameterOrder": [ +"sequenceId" +], +"parameters": { +"sequenceId": { +"description": "Required. ID of the PhotoSequence.", +"location": "path", +"required": true, +"type": "string" +} +}, +"path": "v1/photoSequence/{sequenceId}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"get": { +"description": "Gets the metadata of the specified PhotoSequence via the Operation interface. This method returns the following three types of responses: * `Operation.done` = false, if the processing of PhotoSequence is not finished yet. * `Operation.done` = true and `Operation.error` is populated, if there was an error in processing. * `Operation.done` = true and `Operation.response` is poulated, which contains a PhotoSequence message. This method returns the following error codes: * google.rpc.Code.PERMISSION_DENIED if the requesting user did not create the requested PhotoSequence. * google.rpc.Code.NOT_FOUND if the requested PhotoSequence does not exist.", +"flatPath": "v1/photoSequence/{sequenceId}", +"httpMethod": "GET", +"id": "streetviewpublish.photoSequence.get", +"parameterOrder": [ +"sequenceId" +], +"parameters": { +"filter": { +"description": "Optional. The filter expression. For example: `published_status=PUBLISHED`. The filters supported are: `published_status`. See https://google.aip.dev/160 for more information.", +"location": "query", +"type": "string" +}, +"sequenceId": { +"description": "Required. ID of the photo sequence.", +"location": "path", +"required": true, +"type": "string" +}, +"view": { +"deprecated": true, +"description": "Specifies if a download URL for the photo sequence should be returned in `download_url` of individual photos in the PhotoSequence response. > Note: Currently not implemented.", +"enum": [ +"BASIC", +"INCLUDE_DOWNLOAD_URL" +], +"enumDescriptions": [ +"Server responses do not include the download URL for the photo bytes. The default value.", +"Server responses include the download URL for the photo bytes." +], +"location": "query", +"type": "string" +} +}, +"path": "v1/photoSequence/{sequenceId}", +"response": { +"$ref": "Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"startUpload": { +"description": "Creates an upload session to start uploading photo sequence data. The upload URL of the returned UploadRef is used to upload the data for the `photoSequence`. After the upload is complete, the UploadRef is used with CreatePhotoSequence to create the PhotoSequence object entry.", +"flatPath": "v1/photoSequence:startUpload", +"httpMethod": "POST", +"id": "streetviewpublish.photoSequence.startUpload", +"parameterOrder": [], +"parameters": {}, +"path": "v1/photoSequence:startUpload", +"request": { +"$ref": "Empty" +}, +"response": { +"$ref": "UploadRef" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +} +} +}, +"photoSequences": { +"methods": { +"list": { +"description": "Lists all the PhotoSequences that belong to the user, in descending CreatePhotoSequence timestamp order.", +"flatPath": "v1/photoSequences", +"httpMethod": "GET", +"id": "streetviewpublish.photoSequences.list", +"parameterOrder": [], +"parameters": { +"filter": { +"description": "Optional. The filter expression. For example: `imagery_type=SPHERICAL`. The filters supported are: `imagery_type`, `processing_state`, `min_latitude`, `max_latitude`, `min_longitude`, `max_longitude`, `filename_query`, `min_capture_time_seconds`, `max_capture_time_seconds. See https://google.aip.dev/160 for more information. Filename queries should sent as a Phrase in order to support multiple words and special characters by adding escaped quotes. Ex: filename_query=\"example of a phrase.mp4\"", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of photo sequences to return. `pageSize` must be non-negative. If `pageSize` is zero or is not provided, the default page size of 100 is used. The number of photo sequences returned in the response may be less than `pageSize` if the number of matches is less than `pageSize`. This is currently unimplemented but is in process.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The nextPageToken value returned from a previous ListPhotoSequences request, if any.", +"location": "query", +"type": "string" +} +}, +"path": "v1/photoSequences", +"response": { +"$ref": "ListPhotoSequencesResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +} +} +}, +"photos": { +"methods": { +"batchDelete": { +"description": "Deletes a list of Photos and their metadata. Note that if BatchDeletePhotos fails, either critical fields are missing or there is an authentication error. Even if BatchDeletePhotos succeeds, individual photos in the batch may have failures. These failures are specified in each PhotoResponse.status in BatchDeletePhotosResponse.results. See DeletePhoto for specific failures that can occur per photo.", +"flatPath": "v1/photos:batchDelete", +"httpMethod": "POST", +"id": "streetviewpublish.photos.batchDelete", +"parameterOrder": [], +"parameters": {}, +"path": "v1/photos:batchDelete", +"request": { +"$ref": "BatchDeletePhotosRequest" +}, +"response": { +"$ref": "BatchDeletePhotosResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"batchGet": { +"description": "Gets the metadata of the specified Photo batch. Note that if BatchGetPhotos fails, either critical fields are missing or there is an authentication error. Even if BatchGetPhotos succeeds, individual photos in the batch may have failures. These failures are specified in each PhotoResponse.status in BatchGetPhotosResponse.results. See GetPhoto for specific failures that can occur per photo.", +"flatPath": "v1/photos:batchGet", +"httpMethod": "GET", +"id": "streetviewpublish.photos.batchGet", +"parameterOrder": [], +"parameters": { +"languageCode": { +"description": "Optional. The BCP-47 language code, such as \"en-US\" or \"sr-Latn\". For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier. If language_code is unspecified, the user's language preference for Google services is used.", +"location": "query", +"type": "string" +}, +"photoIds": { +"description": "Required. IDs of the Photos. For HTTP GET requests, the URL query parameter should be `photoIds=&photoIds=&...`.", +"location": "query", +"repeated": true, +"type": "string" +}, +"view": { +"description": "Required. Specifies if a download URL for the photo bytes should be returned in the Photo response.", +"enum": [ +"BASIC", +"INCLUDE_DOWNLOAD_URL" +], +"enumDescriptions": [ +"Server responses do not include the download URL for the photo bytes. The default value.", +"Server responses include the download URL for the photo bytes." +], +"location": "query", +"type": "string" +} +}, +"path": "v1/photos:batchGet", +"response": { +"$ref": "BatchGetPhotosResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"batchUpdate": { +"description": "Updates the metadata of Photos, such as pose, place association, connections, etc. Changing the pixels of photos is not supported. Note that if BatchUpdatePhotos fails, either critical fields are missing or there is an authentication error. Even if BatchUpdatePhotos succeeds, individual photos in the batch may have failures. These failures are specified in each PhotoResponse.status in BatchUpdatePhotosResponse.results. See UpdatePhoto for specific failures that can occur per photo. Only the fields specified in updateMask field are used. If `updateMask` is not present, the update applies to all fields. The number of UpdatePhotoRequest messages in a BatchUpdatePhotosRequest must not exceed 20. > Note: To update Pose.altitude, Pose.latLngPair has to be filled as well. Otherwise, the request will fail.", +"flatPath": "v1/photos:batchUpdate", +"httpMethod": "POST", +"id": "streetviewpublish.photos.batchUpdate", +"parameterOrder": [], +"parameters": {}, +"path": "v1/photos:batchUpdate", +"request": { +"$ref": "BatchUpdatePhotosRequest" +}, +"response": { +"$ref": "BatchUpdatePhotosResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +}, +"list": { +"description": "Lists all the Photos that belong to the user. > Note: Recently created photos that are still being indexed are not returned in the response.", +"flatPath": "v1/photos", +"httpMethod": "GET", +"id": "streetviewpublish.photos.list", +"parameterOrder": [], +"parameters": { +"filter": { +"description": "Optional. The filter expression. For example: `placeId=ChIJj61dQgK6j4AR4GeTYWZsKWw`. The filters supported are: `placeId`, `min_latitude`, `max_latitude`, `min_longitude`, `max_longitude`. See https://google.aip.dev/160 for more information.", +"location": "query", +"type": "string" +}, +"languageCode": { +"description": "Optional. The BCP-47 language code, such as \"en-US\" or \"sr-Latn\". For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier. If language_code is unspecified, the user's language preference for Google services is used.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "Optional. The maximum number of photos to return. `pageSize` must be non-negative. If `pageSize` is zero or is not provided, the default page size of 100 is used. The number of photos returned in the response may be less than `pageSize` if the number of photos that belong to the user is less than `pageSize`.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "Optional. The nextPageToken value returned from a previous ListPhotos request, if any.", +"location": "query", +"type": "string" +}, +"view": { +"description": "Required. Specifies if a download URL for the photos bytes should be returned in the Photos response.", +"enum": [ +"BASIC", +"INCLUDE_DOWNLOAD_URL" +], +"enumDescriptions": [ +"Server responses do not include the download URL for the photo bytes. The default value.", +"Server responses include the download URL for the photo bytes." +], +"location": "query", +"type": "string" +} +}, +"path": "v1/photos", +"response": { +"$ref": "ListPhotosResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/streetviewpublish" +] +} +} +} +}, +"revision": "20240625", +"rootUrl": "https://streetviewpublish.googleapis.com/", +"schemas": { +"BatchDeletePhotosRequest": { +"description": "Request to delete multiple Photos.", +"id": "BatchDeletePhotosRequest", +"properties": { +"photoIds": { +"description": "Required. IDs of the Photos. HTTP GET requests require the following syntax for the URL query parameter: `photoIds=&photoIds=&...`.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"BatchDeletePhotosResponse": { +"description": "Response to batch delete of one or more Photos.", +"id": "BatchDeletePhotosResponse", +"properties": { +"status": { +"description": "The status for the operation to delete a single Photo in the batch request.", +"items": { +"$ref": "Status" +}, +"type": "array" +} +}, +"type": "object" +}, +"BatchGetPhotosResponse": { +"description": "Response to batch get of Photos.", +"id": "BatchGetPhotosResponse", +"properties": { +"results": { +"description": "List of results for each individual Photo requested, in the same order as the requests in BatchGetPhotos.", +"items": { +"$ref": "PhotoResponse" +}, +"type": "array" +} +}, +"type": "object" +}, +"BatchUpdatePhotosRequest": { +"description": "Request to update the metadata of photos. Updating the pixels of photos is not supported.", +"id": "BatchUpdatePhotosRequest", +"properties": { +"updatePhotoRequests": { +"description": "Required. List of UpdatePhotoRequests.", +"items": { +"$ref": "UpdatePhotoRequest" +}, +"type": "array" +} +}, +"type": "object" +}, +"BatchUpdatePhotosResponse": { +"description": "Response to batch update of metadata of one or more Photos.", +"id": "BatchUpdatePhotosResponse", +"properties": { +"results": { +"description": "List of results for each individual Photo updated, in the same order as the request.", +"items": { +"$ref": "PhotoResponse" +}, +"type": "array" +} +}, +"type": "object" +}, +"Connection": { +"description": "A connection is the link from a source photo to a destination photo.", +"id": "Connection", +"properties": { +"target": { +"$ref": "PhotoId", +"description": "Required. The destination of the connection from the containing photo to another photo." +} +}, +"type": "object" +}, +"Empty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "Empty", +"properties": {}, +"type": "object" +}, +"GpsDataGapFailureDetails": { +"description": "Details related to ProcessingFailureReason#GPS_DATA_GAP. If there are multiple GPS data gaps, only the one with the largest duration is reported here.", +"id": "GpsDataGapFailureDetails", +"properties": { +"gapDuration": { +"description": "The duration of the gap in GPS data that was found.", +"format": "google-duration", +"type": "string" +}, +"gapStartTime": { +"description": "Relative time (from the start of the video stream) when the gap started.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"Imu": { +"description": "IMU data from the device sensors.", +"id": "Imu", +"properties": { +"accelMpsps": { +"description": "The accelerometer measurements in meters/sec^2 with increasing timestamps from devices.", +"items": { +"$ref": "Measurement3d" +}, +"type": "array" +}, +"gyroRps": { +"description": "The gyroscope measurements in radians/sec with increasing timestamps from devices.", +"items": { +"$ref": "Measurement3d" +}, +"type": "array" +}, +"magUt": { +"description": "The magnetometer measurements of the magnetic field in microtesla (uT) with increasing timestamps from devices.", +"items": { +"$ref": "Measurement3d" +}, +"type": "array" +} +}, +"type": "object" +}, +"ImuDataGapFailureDetails": { +"description": "Details related to ProcessingFailureReason#IMU_DATA_GAP. If there are multiple IMU data gaps, only the one with the largest duration is reported here.", +"id": "ImuDataGapFailureDetails", +"properties": { +"gapDuration": { +"description": "The duration of the gap in IMU data that was found.", +"format": "google-duration", +"type": "string" +}, +"gapStartTime": { +"description": "Relative time (from the start of the video stream) when the gap started.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"InsufficientGpsFailureDetails": { +"description": "Details related to ProcessingFailureReason#INSUFFICIENT_GPS.", +"id": "InsufficientGpsFailureDetails", +"properties": { +"gpsPointsFound": { +"description": "The number of GPS points that were found in the video.", +"format": "int32", +"type": "integer" +} +}, +"type": "object" +}, +"LatLng": { +"description": "An object that represents a latitude/longitude pair. This is expressed as a pair of doubles to represent degrees latitude and degrees longitude. Unless specified otherwise, this object must conform to the WGS84 standard. Values must be within normalized ranges.", +"id": "LatLng", +"properties": { +"latitude": { +"description": "The latitude in degrees. It must be in the range [-90.0, +90.0].", +"format": "double", +"type": "number" +}, +"longitude": { +"description": "The longitude in degrees. It must be in the range [-180.0, +180.0].", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"LatLngBounds": { +"description": "A rectangle in geographical coordinates.", +"id": "LatLngBounds", +"properties": { +"northeast": { +"$ref": "LatLng", +"description": "The northeast corner of these bounds." +}, +"southwest": { +"$ref": "LatLng", +"description": "The southwest corner of these bounds." +} +}, +"type": "object" +}, +"Level": { +"description": "Level information containing level number and its corresponding name.", +"id": "Level", +"properties": { +"name": { +"description": "Required. A name assigned to this Level, restricted to 3 characters. Consider how the elevator buttons would be labeled for this level if there was an elevator.", +"type": "string" +}, +"number": { +"description": "Optional. Floor number, used for ordering. 0 indicates the ground level, 1 indicates the first level above ground level, -1 indicates the first level under ground level. Non-integer values are OK.", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"ListPhotoSequencesResponse": { +"description": "Response to list all photo sequences that belong to a user.", +"id": "ListPhotoSequencesResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"photoSequences": { +"description": "List of photo sequences via Operation interface. The maximum number of items returned is based on the pageSize field in the request. Each item in the list can have three possible states, * `Operation.done` = false, if the processing of PhotoSequence is not finished yet. * `Operation.done` = true and `Operation.error` is populated, if there was an error in processing. * `Operation.done` = true and `Operation.response` contains a PhotoSequence message, In each sequence, only Id is populated.", +"items": { +"$ref": "Operation" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListPhotosResponse": { +"description": "Response to list all photos that belong to a user.", +"id": "ListPhotosResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"photos": { +"description": "List of photos. The pageSize field in the request determines the number of items returned.", +"items": { +"$ref": "Photo" +}, +"type": "array" +} +}, +"type": "object" +}, +"Measurement3d": { +"description": "A Generic 3d measurement sample.", +"id": "Measurement3d", +"properties": { +"captureTime": { +"description": "The timestamp of the IMU measurement.", +"format": "google-datetime", +"type": "string" +}, +"x": { +"description": "The sensor measurement in the x axis.", +"format": "float", +"type": "number" +}, +"y": { +"description": "The sensor measurement in the y axis.", +"format": "float", +"type": "number" +}, +"z": { +"description": "The sensor measurement in the z axis.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"NoOverlapGpsFailureDetails": { +"description": "Details related to PhotoSequenceProcessingFailureReason#NO_OVERLAP_GPS.", +"id": "NoOverlapGpsFailureDetails", +"properties": { +"gpsEndTime": { +"description": "Time of last recorded GPS point.", +"format": "google-datetime", +"type": "string" +}, +"gpsStartTime": { +"description": "Time of first recorded GPS point.", +"format": "google-datetime", +"type": "string" +}, +"videoEndTime": { +"description": "End time of video.", +"format": "google-datetime", +"type": "string" +}, +"videoStartTime": { +"description": "Start time of video.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"NotOutdoorsFailureDetails": { +"description": "Details related to ProcessingFailureReason#NOT_OUTDOORS. If there are multiple indoor frames found, the first frame is recorded here.", +"id": "NotOutdoorsFailureDetails", +"properties": { +"startTime": { +"description": "Relative time (from the start of the video stream) when an indoor frame was found.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"Operation": { +"description": "This resource represents a long-running operation that is the result of a network API call.", +"id": "Operation", +"properties": { +"done": { +"description": "If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.", +"type": "boolean" +}, +"error": { +"$ref": "Status", +"description": "The error result of the operation in case of failure or cancellation." +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.", +"type": "object" +}, +"name": { +"description": "The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.", +"type": "string" +}, +"response": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.", +"type": "object" +} +}, +"type": "object" +}, +"Photo": { +"description": "Photo is used to store 360 photos along with photo metadata.", +"id": "Photo", +"properties": { +"captureTime": { +"description": "Optional. Absolute time when the photo was captured. When the photo has no exif timestamp, this is used to set a timestamp in the photo metadata.", +"format": "google-datetime", +"type": "string" +}, +"connections": { +"description": "Optional. Connections to other photos. A connection represents the link from this photo to another photo.", +"items": { +"$ref": "Connection" +}, +"type": "array" +}, +"downloadUrl": { +"description": "Output only. The download URL for the photo bytes. This field is set only when GetPhotoRequest.view is set to PhotoView.INCLUDE_DOWNLOAD_URL.", +"readOnly": true, +"type": "string" +}, +"mapsPublishStatus": { +"description": "Output only. Status in Google Maps, whether this photo was published or rejected.", +"enum": [ +"UNSPECIFIED_MAPS_PUBLISH_STATUS", +"PUBLISHED", +"REJECTED_UNKNOWN" +], +"enumDescriptions": [ +"The status of the photo is unknown.", +"The photo is published to the public through Google Maps.", +"The photo has been rejected for an unknown reason." +], +"readOnly": true, +"type": "string" +}, +"photoId": { +"$ref": "PhotoId", +"description": "Required. Output only. Required when updating a photo. Output only when creating a photo. Identifier for the photo, which is unique among all photos in Google.", +"readOnly": true +}, +"places": { +"description": "Optional. Places where this photo belongs.", +"items": { +"$ref": "Place" +}, +"type": "array" +}, +"pose": { +"$ref": "Pose", +"description": "Optional. Pose of the photo." +}, +"shareLink": { +"description": "Output only. The share link for the photo.", +"readOnly": true, +"type": "string" +}, +"thumbnailUrl": { +"description": "Output only. The thumbnail URL for showing a preview of the given photo.", +"readOnly": true, +"type": "string" +}, +"transferStatus": { +"description": "Output only. Status of rights transfer on this photo.", +"enum": [ +"TRANSFER_STATUS_UNKNOWN", +"NEVER_TRANSFERRED", +"PENDING", +"COMPLETED", +"REJECTED", +"EXPIRED", +"CANCELLED", +"RECEIVED_VIA_TRANSFER" +], +"enumDescriptions": [ +"The status of this transfer is unspecified.", +"This photo has never been in a transfer.", +"This photo transfer has been initiated, but the receiver has not yet responded.", +"The photo transfer has been completed, and this photo has been transferred to the recipient.", +"The recipient rejected this photo transfer.", +"The photo transfer expired before the recipient took any action.", +"The sender cancelled this photo transfer.", +"The recipient owns this photo due to a rights transfer." +], +"readOnly": true, +"type": "string" +}, +"uploadReference": { +"$ref": "UploadRef", +"description": "Input only. Required when creating a photo. Input only. The resource URL where the photo bytes are uploaded to." +}, +"uploadTime": { +"description": "Output only. Time when the image was uploaded.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"viewCount": { +"description": "Output only. View count of the photo.", +"format": "int64", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"PhotoId": { +"description": "Identifier for a Photo.", +"id": "PhotoId", +"properties": { +"id": { +"description": "A unique identifier for a photo.", +"type": "string" +} +}, +"type": "object" +}, +"PhotoResponse": { +"description": "Response payload for a single Photo in batch operations including BatchGetPhotos and BatchUpdatePhotos.", +"id": "PhotoResponse", +"properties": { +"photo": { +"$ref": "Photo", +"description": "The Photo resource, if the request was successful." +}, +"status": { +"$ref": "Status", +"description": "The status for the operation to get or update a single photo in the batch request." +} +}, +"type": "object" +}, +"PhotoSequence": { +"description": "A sequence of 360 photos along with metadata.", +"id": "PhotoSequence", +"properties": { +"captureTimeOverride": { +"description": "Optional. Absolute time when the photo sequence starts to be captured. If the photo sequence is a video, this is the start time of the video. If this field is populated in input, it overrides the capture time in the video or XDM file.", +"format": "google-datetime", +"type": "string" +}, +"distanceMeters": { +"description": "Output only. The computed distance of the photo sequence in meters.", +"format": "double", +"readOnly": true, +"type": "number" +}, +"failureDetails": { +"$ref": "ProcessingFailureDetails", +"description": "Output only. If this sequence has `failure_reason` set, this may contain additional details about the failure.", +"readOnly": true +}, +"failureReason": { +"description": "Output only. If this sequence has processing_state = FAILED, this will contain the reason why it failed. If the processing_state is any other value, this field will be unset.", +"enum": [ +"PROCESSING_FAILURE_REASON_UNSPECIFIED", +"LOW_RESOLUTION", +"DUPLICATE", +"INSUFFICIENT_GPS", +"NO_OVERLAP_GPS", +"INVALID_GPS", +"FAILED_TO_REFINE_POSITIONS", +"TAKEDOWN", +"CORRUPT_VIDEO", +"INTERNAL", +"INVALID_VIDEO_FORMAT", +"INVALID_VIDEO_DIMENSIONS", +"INVALID_CAPTURE_TIME", +"GPS_DATA_GAP", +"JUMPY_GPS", +"INVALID_IMU", +"INSUFFICIENT_IMU", +"INSUFFICIENT_OVERLAP_TIME_SERIES", +"IMU_DATA_GAP", +"UNSUPPORTED_CAMERA", +"NOT_OUTDOORS", +"INSUFFICIENT_VIDEO_FRAMES", +"INSUFFICIENT_MOVEMENT", +"MAST_DOWN", +"CAMERA_COVERED" +], +"enumDescriptions": [ +"The failure reason is unspecified, this is the default value.", +"Video frame's resolution is too small.", +"This video has been uploaded before.", +"Too few GPS points.", +"No overlap between the time frame of GPS track and the time frame of video.", +"GPS is invalid (e.x. all GPS points are at (0,0))", +"The sequence of photos could not be accurately located in the world.", +"The sequence was taken down for policy reasons.", +"The video file was corrupt or could not be decoded.", +"A permanent failure in the underlying system occurred.", +"The video format is invalid or unsupported.", +"Invalid image aspect ratio found.", +"Invalid capture time. Timestamps were from the future.", +"GPS data contains a gap greater than 5 seconds in duration.", +"GPS data is too erratic to be processed.", +"IMU (Accelerometer, Gyroscope, etc.) data are not valid. They may be missing required fields (x, y, z or time), may not be formatted correctly, or any other issue that prevents our systems from parsing it.", +"Too few IMU points.", +"Insufficient overlap in the time frame between GPS, IMU, and other time series data.", +"IMU (Accelerometer, Gyroscope, etc.) data contain gaps greater than 0.1 seconds in duration.", +"The camera is not supported.", +"Some frames were indoors, which is unsupported.", +"Not enough video frames.", +"Not enough moving data.", +"Mast is down.", +"Camera is covered." +], +"readOnly": true, +"type": "string" +}, +"filename": { +"description": "Output only. The filename of the upload. Does not include the directory path. Only available if the sequence was uploaded on a platform that provides the filename.", +"readOnly": true, +"type": "string" +}, +"gpsSource": { +"description": "Input only. If both raw_gps_timeline and the Camera Motion Metadata Track (CAMM) contain GPS measurements, indicate which takes precedence.", +"enum": [ +"PHOTO_SEQUENCE", +"CAMERA_MOTION_METADATA_TRACK" +], +"enumDescriptions": [ +"GPS in raw_gps_timeline takes precedence if it exists.", +"GPS in Camera Motion Metadata Track (CAMM) takes precedence if it exists." +], +"type": "string" +}, +"id": { +"description": "Output only. Unique identifier for the photo sequence. This also acts as a long running operation ID if uploading is performed asynchronously.", +"readOnly": true, +"type": "string" +}, +"imu": { +"$ref": "Imu", +"description": "Input only. Three axis IMU data for the collection. If this data is too large to put in the request, then it should be put in the CAMM track for the video. This data always takes precedence over the equivalent CAMM data, if it exists." +}, +"photos": { +"description": "Output only. Photos with increasing timestamps.", +"items": { +"$ref": "Photo" +}, +"readOnly": true, +"type": "array" +}, +"processingState": { +"description": "Output only. The processing state of this sequence.", +"enum": [ +"PROCESSING_STATE_UNSPECIFIED", +"PENDING", +"PROCESSING", +"PROCESSED", +"FAILED" +], +"enumDescriptions": [ +"The state is unspecified, this is the default value.", +"The sequence has not yet started processing.", +"The sequence is currently in processing.", +"The sequence has finished processing including refining position.", +"The sequence failed processing. See FailureReason for more details." +], +"readOnly": true, +"type": "string" +}, +"rawGpsTimeline": { +"description": "Input only. Raw GPS measurements with increasing timestamps from the device that aren't time synced with each photo. These raw measurements will be used to infer the pose of each frame. Required in input when InputType is VIDEO and raw GPS measurements are not in Camera Motion Metadata Track (CAMM). User can indicate which takes precedence using gps_source if raw GPS measurements are provided in both raw_gps_timeline and Camera Motion Metadata Track (CAMM).", +"items": { +"$ref": "Pose" +}, +"type": "array" +}, +"sequenceBounds": { +"$ref": "LatLngBounds", +"description": "Output only. A rectangular box that encapsulates every image in this photo sequence.", +"readOnly": true +}, +"uploadReference": { +"$ref": "UploadRef", +"description": "Input only. Required when creating photo sequence. The resource name where the bytes of the photo sequence (in the form of video) are uploaded." +}, +"uploadTime": { +"description": "Output only. The time this photo sequence was created in uSV Store service.", +"format": "google-datetime", +"readOnly": true, +"type": "string" +}, +"viewCount": { +"description": "Output only. The total number of views that all the published images in this PhotoSequence have received.", +"format": "int64", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"Place": { +"description": "Place metadata for an entity.", +"id": "Place", +"properties": { +"languageCode": { +"description": "Output only. The language_code that the name is localized with. This should be the language_code specified in the request, but may be a fallback.", +"readOnly": true, +"type": "string" +}, +"name": { +"description": "Output only. The name of the place, localized to the language_code.", +"readOnly": true, +"type": "string" +}, +"placeId": { +"description": "Place identifier, as described in https://developers.google.com/places/place-id.", +"type": "string" +} +}, +"type": "object" +}, +"Pose": { +"description": "Raw pose measurement for an entity.", +"id": "Pose", +"properties": { +"accuracyMeters": { +"description": "The estimated horizontal accuracy of this pose in meters with 68% confidence (one standard deviation). For example, on Android, this value is available from this method: https://developer.android.com/reference/android/location/Location#getAccuracy(). Other platforms have different methods of obtaining similar accuracy estimations.", +"format": "float", +"type": "number" +}, +"altitude": { +"description": "Altitude of the pose in meters above WGS84 ellipsoid. NaN indicates an unmeasured quantity.", +"format": "double", +"type": "number" +}, +"gpsRecordTimestampUnixEpoch": { +"description": "Time of the GPS record since UTC epoch.", +"format": "google-datetime", +"type": "string" +}, +"heading": { +"description": "The following pose parameters pertain to the center of the photo. They match https://developers.google.com/streetview/spherical-metadata. Compass heading, measured at the center of the photo in degrees clockwise from North. Value must be >=0 and <360. NaN indicates an unmeasured quantity.", +"format": "double", +"type": "number" +}, +"latLngPair": { +"$ref": "LatLng", +"description": "Latitude and longitude pair of the pose, as explained here: https://cloud.google.com/datastore/docs/reference/rest/Shared.Types/LatLng When creating a Photo, if the latitude and longitude pair are not provided, the geolocation from the exif header is used. A latitude and longitude pair not provided in the photo or exif header causes the photo process to fail." +}, +"level": { +"$ref": "Level", +"description": "Level (the floor in a building) used to configure vertical navigation." +}, +"pitch": { +"description": "Pitch, measured at the center of the photo in degrees. Value must be >=-90 and <= 90. A value of -90 means looking directly down, and a value of 90 means looking directly up. NaN indicates an unmeasured quantity.", +"format": "double", +"type": "number" +}, +"roll": { +"description": "Roll, measured in degrees. Value must be >= 0 and <360. A value of 0 means level with the horizon. NaN indicates an unmeasured quantity.", +"format": "double", +"type": "number" +} +}, +"type": "object" +}, +"ProcessingFailureDetails": { +"description": "Additional details to accompany the ProcessingFailureReason enum. This message is always expected to be used in conjunction with ProcessingFailureReason, and the oneof value set in this message should match the FailureReason.", +"id": "ProcessingFailureDetails", +"properties": { +"gpsDataGapDetails": { +"$ref": "GpsDataGapFailureDetails", +"description": "See GpsDataGapFailureDetails." +}, +"imuDataGapDetails": { +"$ref": "ImuDataGapFailureDetails", +"description": "See ImuDataGapFailureDetails." +}, +"insufficientGpsDetails": { +"$ref": "InsufficientGpsFailureDetails", +"description": "See InsufficientGpsFailureDetails." +}, +"noOverlapGpsDetails": { +"$ref": "NoOverlapGpsFailureDetails", +"description": "See NoOverlapGpsFailureDetails." +}, +"notOutdoorsDetails": { +"$ref": "NotOutdoorsFailureDetails", +"description": "See NotOutdoorsFailureDetails." +} +}, +"type": "object" +}, +"Status": { +"description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", +"id": "Status", +"properties": { +"code": { +"description": "The status code, which should be an enum value of google.rpc.Code.", +"format": "int32", +"type": "integer" +}, +"details": { +"description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", +"items": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"type": "object" +}, +"type": "array" +}, +"message": { +"description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", +"type": "string" +} +}, +"type": "object" +}, +"UpdatePhotoRequest": { +"description": "Request to update the metadata of a Photo. Updating the pixels of a photo is not supported.", +"id": "UpdatePhotoRequest", +"properties": { +"photo": { +"$ref": "Photo", +"description": "Required. Photo object containing the new metadata." +}, +"updateMask": { +"description": "Required. Mask that identifies fields on the photo metadata to update. If not present, the old Photo metadata is entirely replaced with the new Photo metadata in this request. The update fails if invalid fields are specified. Multiple fields can be specified in a comma-delimited list. The following fields are valid: * `pose.heading` * `pose.lat_lng_pair` * `pose.pitch` * `pose.roll` * `pose.level` * `pose.altitude` * `connections` * `places` > Note: When updateMask contains repeated fields, the entire set of repeated values get replaced with the new contents. For example, if updateMask contains `connections` and `UpdatePhotoRequest.photo.connections` is empty, all connections are removed.", +"format": "google-fieldmask", +"type": "string" +} +}, +"type": "object" +}, +"UploadRef": { +"description": "Upload reference for media files.", +"id": "UploadRef", +"properties": { +"uploadUrl": { +"description": "An upload reference should be unique for each user. It follows the form: \"https://streetviewpublish.googleapis.com/media/user/{account_id}/photo/{upload_reference}\"", +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Street View Publish API", +"version": "v1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/translate.v2.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/translate.v2.json new file mode 100644 index 0000000000000000000000000000000000000000..ae15acce060d46df929057365fd53531d135ede9 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/translate.v2.json @@ -0,0 +1,440 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "View and manage your data across Google Cloud Platform services" +}, +"https://www.googleapis.com/auth/cloud-translation": { +"description": "Translate text from one language to another using Google Translate" +} +} +} +}, +"basePath": "/language/translate/", +"baseUrl": "https://translation.googleapis.com/language/translate/", +"batchPath": "batch/translate", +"canonicalName": "Translate", +"description": "The Google Cloud Translation API lets websites and programs integrate with\n Google Translate programmatically.", +"discoveryVersion": "v1", +"documentationLink": "https://code.google.com/apis/language/translate/v2/getting_started.html", +"features": [ +"dataWrapper" +], +"icons": { +"x16": "https://www.google.com/images/icons/product/translate-16.png", +"x32": "https://www.google.com/images/icons/product/translate-32.png" +}, +"id": "translate:v2", +"kind": "discovery#restDescription", +"name": "translate", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"bearer_token": { +"description": "OAuth bearer token.", +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"pp": { +"default": "true", +"description": "Pretty-print response.", +"location": "query", +"type": "boolean" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters. Overrides userIp if both are provided.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"detections": { +"methods": { +"detect": { +"description": "Detects the language of text within a request.", +"httpMethod": "POST", +"id": "language.detections.detect", +"parameterOrder": [], +"parameters": {}, +"path": "v2/detect", +"request": { +"$ref": "DetectLanguageRequest" +}, +"response": { +"$ref": "DetectionsListResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-translation", +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Detects the language of text within a request.", +"httpMethod": "GET", +"id": "language.detections.list", +"parameterOrder": [ +"q" +], +"parameters": { +"q": { +"description": "The input text upon which to perform language detection. Repeat this\nparameter to perform language detection on multiple text inputs.", +"location": "query", +"repeated": true, +"required": true, +"type": "string" +} +}, +"path": "v2/detect", +"response": { +"$ref": "DetectionsListResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-translation", +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"languages": { +"methods": { +"list": { +"description": "Returns a list of supported languages for translation.", +"httpMethod": "GET", +"id": "language.languages.list", +"parameters": { +"model": { +"description": "The model type for which supported languages should be returned.", +"location": "query", +"type": "string" +}, +"target": { +"description": "The language to use to return localized, human readable names of supported\nlanguages.", +"location": "query", +"type": "string" +} +}, +"path": "v2/languages", +"response": { +"$ref": "LanguagesListResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-translation", +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"translations": { +"methods": { +"list": { +"description": "Translates input text, returning translated text.", +"httpMethod": "GET", +"id": "language.translations.list", +"parameterOrder": [ +"q", +"target" +], +"parameters": { +"cid": { +"description": "The customization id for translate", +"location": "query", +"repeated": true, +"type": "string" +}, +"format": { +"description": "The format of the source text, in either HTML (default) or plain-text. A\nvalue of \"html\" indicates HTML and a value of \"text\" indicates plain-text.", +"enum": [ +"html", +"text" +], +"enumDescriptions": [ +"Specifies the input is in HTML", +"Specifies the input is in plain textual format" +], +"location": "query", +"type": "string" +}, +"model": { +"description": "The `model` type requested for this translation. Valid values are\nlisted in public documentation.", +"location": "query", +"type": "string" +}, +"q": { +"description": "The input text to translate. Repeat this parameter to perform translation\noperations on multiple text inputs.", +"location": "query", +"repeated": true, +"required": true, +"type": "string" +}, +"source": { +"description": "The language of the source text, set to one of the language codes listed in\nLanguage Support. If the source language is not specified, the API will\nattempt to identify the source language automatically and return it within\nthe response.", +"location": "query", +"type": "string" +}, +"target": { +"description": "The language to use for translation of the input text, set to one of the\nlanguage codes listed in Language Support.", +"location": "query", +"required": true, +"type": "string" +} +}, +"path": "v2", +"response": { +"$ref": "TranslationsListResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-translation", +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"translate": { +"description": "Translates input text, returning translated text.", +"httpMethod": "POST", +"id": "language.translations.translate", +"parameterOrder": [], +"parameters": {}, +"path": "v2", +"request": { +"$ref": "TranslateTextRequest" +}, +"response": { +"$ref": "TranslationsListResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-translation", +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +}, +"revision": "20170525", +"rootUrl": "https://translation.googleapis.com/", +"schemas": { +"DetectLanguageRequest": { +"description": "The request message for language detection.", +"id": "DetectLanguageRequest", +"properties": { +"q": { +"description": "The input text upon which to perform language detection. Repeat this\nparameter to perform language detection on multiple text inputs.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"DetectionsListResponse": { +"id": "DetectionsListResponse", +"properties": { +"detections": { +"description": "A detections contains detection results of several text", +"items": { +"$ref": "DetectionsResource" +}, +"type": "array" +} +}, +"type": "object" +}, +"DetectionsResource": { +"description": "An array of languages which we detect for the given text The most likely language list first.", +"id": "DetectionsResource", +"items": { +"properties": { +"confidence": { +"description": "The confidence of the detection result of this language.", +"format": "float", +"type": "number" +}, +"isReliable": { +"description": "A boolean to indicate is the language detection result reliable.", +"type": "boolean" +}, +"language": { +"description": "The language we detected.", +"type": "string" +} +}, +"type": "object" +}, +"type": "array" +}, +"GetSupportedLanguagesRequest": { +"description": "The request message for discovering supported languages.", +"id": "GetSupportedLanguagesRequest", +"properties": { +"target": { +"description": "The language to use to return localized, human readable names of supported\nlanguages.", +"type": "string" +} +}, +"type": "object" +}, +"LanguagesListResponse": { +"id": "LanguagesListResponse", +"properties": { +"languages": { +"description": "List of source/target languages supported by the translation API. If target parameter is unspecified, the list is sorted by the ASCII code point order of the language code. If target parameter is specified, the list is sorted by the collation order of the language name in the target language.", +"items": { +"$ref": "LanguagesResource" +}, +"type": "array" +} +}, +"type": "object" +}, +"LanguagesResource": { +"id": "LanguagesResource", +"properties": { +"language": { +"description": "Supported language code, generally consisting of its ISO 639-1\nidentifier. (E.g. 'en', 'ja'). In certain cases, BCP-47 codes including\nlanguage + region identifiers are returned (e.g. 'zh-TW' and 'zh-CH')", +"type": "string" +}, +"name": { +"description": "Human readable name of the language localized to the target language.", +"type": "string" +} +}, +"type": "object" +}, +"TranslateTextRequest": { +"description": "The main translation request message for the Cloud Translation API.", +"id": "TranslateTextRequest", +"properties": { +"format": { +"description": "The format of the source text, in either HTML (default) or plain-text. A\nvalue of \"html\" indicates HTML and a value of \"text\" indicates plain-text.", +"type": "string" +}, +"model": { +"description": "The `model` type requested for this translation. Valid values are\nlisted in public documentation.", +"type": "string" +}, +"q": { +"description": "The input text to translate. Repeat this parameter to perform translation\noperations on multiple text inputs.", +"items": { +"type": "string" +}, +"type": "array" +}, +"source": { +"description": "The language of the source text, set to one of the language codes listed in\nLanguage Support. If the source language is not specified, the API will\nattempt to identify the source language automatically and return it within\nthe response.", +"type": "string" +}, +"target": { +"description": "The language to use for translation of the input text, set to one of the\nlanguage codes listed in Language Support.", +"type": "string" +} +}, +"type": "object" +}, +"TranslationsListResponse": { +"description": "The main language translation response message.", +"id": "TranslationsListResponse", +"properties": { +"translations": { +"description": "Translations contains list of translation results of given text", +"items": { +"$ref": "TranslationsResource" +}, +"type": "array" +} +}, +"type": "object" +}, +"TranslationsResource": { +"id": "TranslationsResource", +"properties": { +"detectedSourceLanguage": { +"description": "The source language of the initial request, detected automatically, if\nno source language was passed within the initial request. If the\nsource language was passed, auto-detection of the language will not\noccur and this field will be empty.", +"type": "string" +}, +"model": { +"description": "The `model` type used for this translation. Valid values are\nlisted in public documentation. Can be different from requested `model`.\nPresent only if specific model type was explicitly requested.", +"type": "string" +}, +"translatedText": { +"description": "Text translated into the target language.", +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "language/translate/", +"title": "Google Cloud Translation API", +"version": "v2" +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/videointelligence.v1p1beta1.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/videointelligence.v1p1beta1.json new file mode 100644 index 0000000000000000000000000000000000000000..bd4af4562119788055f1d254811864c59ab34f38 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/videointelligence.v1p1beta1.json @@ -0,0 +1,4775 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +} +} +} +}, +"basePath": "", +"baseUrl": "https://videointelligence.googleapis.com/", +"batchPath": "batch", +"canonicalName": "Cloud Video Intelligence", +"description": "Detects objects, explicit content, and scene changes in videos. It also specifies the region for annotation and transcribes speech to text. Supports both asynchronous API and streaming API.", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/video-intelligence/docs/", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "videointelligence:v1p1beta1", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://videointelligence.mtls.googleapis.com/", +"name": "videointelligence", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"videos": { +"methods": { +"annotate": { +"description": "Performs asynchronous video annotation. Progress and results can be retrieved through the `google.longrunning.Operations` interface. `Operation.metadata` contains `AnnotateVideoProgress` (progress). `Operation.response` contains `AnnotateVideoResponse` (results).", +"flatPath": "v1p1beta1/videos:annotate", +"httpMethod": "POST", +"id": "videointelligence.videos.annotate", +"parameterOrder": [], +"parameters": {}, +"path": "v1p1beta1/videos:annotate", +"request": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_AnnotateVideoRequest" +}, +"response": { +"$ref": "GoogleLongrunning_Operation" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +}, +"revision": "20240704", +"rootUrl": "https://videointelligence.googleapis.com/", +"schemas": { +"GoogleCloudVideointelligenceV1_AnnotateVideoProgress": { +"description": "Video annotation progress. Included in the `metadata` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1_AnnotateVideoProgress", +"properties": { +"annotationProgress": { +"description": "Progress metadata for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_VideoAnnotationProgress" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_AnnotateVideoResponse": { +"description": "Video annotation response. Included in the `response` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1_AnnotateVideoResponse", +"properties": { +"annotationResults": { +"description": "Annotation results for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_VideoAnnotationResults" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_DetectedAttribute": { +"description": "A generic detected attribute represented by name in string format.", +"id": "GoogleCloudVideointelligenceV1_DetectedAttribute", +"properties": { +"confidence": { +"description": "Detected attribute confidence. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of the attribute, for example, glasses, dark_glasses, mouth_open. A full list of supported type names will be provided in the document.", +"type": "string" +}, +"value": { +"description": "Text value of the detection result. For example, the value for \"HairColor\" can be \"black\", \"blonde\", etc.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_DetectedLandmark": { +"description": "A generic detected landmark represented by name in string format and a 2D location.", +"id": "GoogleCloudVideointelligenceV1_DetectedLandmark", +"properties": { +"confidence": { +"description": "The confidence score of the detected landmark. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of this landmark, for example, left_hand, right_shoulder.", +"type": "string" +}, +"point": { +"$ref": "GoogleCloudVideointelligenceV1_NormalizedVertex", +"description": "The 2D point of the detected landmark using the normalized image coordindate system. The normalized coordinates have the range from 0 to 1." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_Entity": { +"description": "Detected entity from video analysis.", +"id": "GoogleCloudVideointelligenceV1_Entity", +"properties": { +"description": { +"description": "Textual description, e.g., `Fixed-gear bicycle`.", +"type": "string" +}, +"entityId": { +"description": "Opaque entity ID. Some IDs may be available in [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).", +"type": "string" +}, +"languageCode": { +"description": "Language code for `description` in BCP-47 format.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_ExplicitContentAnnotation": { +"description": "Explicit content annotation (based on per-frame visual signals only). If no explicit content has been detected in a frame, no annotations are present for that frame.", +"id": "GoogleCloudVideointelligenceV1_ExplicitContentAnnotation", +"properties": { +"frames": { +"description": "All video frames where explicit content was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_ExplicitContentFrame" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_ExplicitContentFrame": { +"description": "Video frame level annotation results for explicit content.", +"id": "GoogleCloudVideointelligenceV1_ExplicitContentFrame", +"properties": { +"pornographyLikelihood": { +"description": "Likelihood of the pornography content..", +"enum": [ +"LIKELIHOOD_UNSPECIFIED", +"VERY_UNLIKELY", +"UNLIKELY", +"POSSIBLE", +"LIKELY", +"VERY_LIKELY" +], +"enumDescriptions": [ +"Unspecified likelihood.", +"Very unlikely.", +"Unlikely.", +"Possible.", +"Likely.", +"Very likely." +], +"type": "string" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_FaceAnnotation": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1_FaceAnnotation", +"properties": { +"frames": { +"description": "All video frames where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_FaceFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_FaceSegment" +}, +"type": "array" +}, +"thumbnail": { +"description": "Thumbnail of a representative face view (in JPEG format).", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_FaceDetectionAnnotation": { +"description": "Face detection annotation.", +"id": "GoogleCloudVideointelligenceV1_FaceDetectionAnnotation", +"properties": { +"thumbnail": { +"description": "The thumbnail of a person's face.", +"format": "byte", +"type": "string" +}, +"tracks": { +"description": "The face tracks with attributes.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_FaceFrame": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1_FaceFrame", +"properties": { +"normalizedBoundingBoxes": { +"description": "Normalized Bounding boxes in a frame. There can be more than one boxes if the same face is detected in multiple locations within the current frame.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_NormalizedBoundingBox" +}, +"type": "array" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_FaceSegment": { +"description": "Video segment level annotation results for face detection.", +"id": "GoogleCloudVideointelligenceV1_FaceSegment", +"properties": { +"segment": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment", +"description": "Video segment where a face was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_LabelAnnotation": { +"description": "Label annotation.", +"id": "GoogleCloudVideointelligenceV1_LabelAnnotation", +"properties": { +"categoryEntities": { +"description": "Common categories for the detected entity. For example, when the label is `Terrier`, the category is likely `dog`. And in some cases there might be more than one categories e.g., `Terrier` could also be a `pet`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_Entity" +}, +"type": "array" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1_Entity", +"description": "Detected entity." +}, +"frames": { +"description": "All video frames where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_LabelFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_LabelSegment" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_LabelFrame": { +"description": "Video frame level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1_LabelFrame", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_LabelSegment": { +"description": "Video segment level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1_LabelSegment", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment", +"description": "Video segment where a label was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_LogoRecognitionAnnotation": { +"description": "Annotation corresponding to one detected, tracked and recognized logo class.", +"id": "GoogleCloudVideointelligenceV1_LogoRecognitionAnnotation", +"properties": { +"entity": { +"$ref": "GoogleCloudVideointelligenceV1_Entity", +"description": "Entity category information to specify the logo class that all the logo tracks within this LogoRecognitionAnnotation are recognized as." +}, +"segments": { +"description": "All video segments where the recognized logo appears. There might be multiple instances of the same logo class appearing in one VideoSegment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment" +}, +"type": "array" +}, +"tracks": { +"description": "All logo tracks where the recognized logo appears. Each track corresponds to one logo instance appearing in consecutive frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_Track" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_NormalizedBoundingBox": { +"description": "Normalized bounding box. The normalized vertex coordinates are relative to the original image. Range: [0, 1].", +"id": "GoogleCloudVideointelligenceV1_NormalizedBoundingBox", +"properties": { +"bottom": { +"description": "Bottom Y coordinate.", +"format": "float", +"type": "number" +}, +"left": { +"description": "Left X coordinate.", +"format": "float", +"type": "number" +}, +"right": { +"description": "Right X coordinate.", +"format": "float", +"type": "number" +}, +"top": { +"description": "Top Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_NormalizedBoundingPoly": { +"description": "Normalized bounding polygon for text (that might not be aligned with axis). Contains list of the corner points in clockwise order starting from top-left corner. For example, for a rectangular bounding box: When the text is horizontal it might look like: 0----1 | | 3----2 When it's clockwise rotated 180 degrees around the top-left corner it becomes: 2----3 | | 1----0 and the vertex order will still be (0, 1, 2, 3). Note that values can be less than 0, or greater than 1 due to trignometric calculations for location of the box.", +"id": "GoogleCloudVideointelligenceV1_NormalizedBoundingPoly", +"properties": { +"vertices": { +"description": "Normalized vertices of the bounding polygon.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_NormalizedVertex" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_NormalizedVertex": { +"description": "A vertex represents a 2D point in the image. NOTE: the normalized vertex coordinates are relative to the original image and range from 0 to 1.", +"id": "GoogleCloudVideointelligenceV1_NormalizedVertex", +"properties": { +"x": { +"description": "X coordinate.", +"format": "float", +"type": "number" +}, +"y": { +"description": "Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_ObjectTrackingAnnotation": { +"description": "Annotations corresponding to one tracked object.", +"id": "GoogleCloudVideointelligenceV1_ObjectTrackingAnnotation", +"properties": { +"confidence": { +"description": "Object category's labeling confidence of this track.", +"format": "float", +"type": "number" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1_Entity", +"description": "Entity to specify the object category that this track is labeled as." +}, +"frames": { +"description": "Information corresponding to all frames where this object track appears. Non-streaming batch mode: it may be one or multiple ObjectTrackingFrame messages in frames. Streaming mode: it can only be one ObjectTrackingFrame message in frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_ObjectTrackingFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment", +"description": "Non-streaming batch mode ONLY. Each object track corresponds to one video segment where it appears." +}, +"trackId": { +"description": "Streaming mode ONLY. In streaming mode, we do not know the end time of a tracked object before it is completed. Hence, there is no VideoSegment info returned. Instead, we provide a unique identifiable integer track_id so that the customers can correlate the results of the ongoing ObjectTrackAnnotation of the same track_id over time.", +"format": "int64", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_ObjectTrackingFrame": { +"description": "Video frame level annotations for object detection and tracking. This field stores per frame location, time offset, and confidence.", +"id": "GoogleCloudVideointelligenceV1_ObjectTrackingFrame", +"properties": { +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1_NormalizedBoundingBox", +"description": "The normalized bounding box location of this object track for the frame." +}, +"timeOffset": { +"description": "The timestamp of the frame in microseconds.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_PersonDetectionAnnotation": { +"description": "Person detection annotation per video.", +"id": "GoogleCloudVideointelligenceV1_PersonDetectionAnnotation", +"properties": { +"tracks": { +"description": "The detected tracks of a person.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_SpeechRecognitionAlternative": { +"description": "Alternative hypotheses (a.k.a. n-best list).", +"id": "GoogleCloudVideointelligenceV1_SpeechRecognitionAlternative", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"transcript": { +"description": "Transcript text representing the words that the user spoke.", +"type": "string" +}, +"words": { +"description": "Output only. A list of word-specific information for each recognized word. Note: When `enable_speaker_diarization` is set to true, you will see all the words from the beginning of the audio.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_WordInfo" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_SpeechTranscription": { +"description": "A speech recognition result corresponding to a portion of the audio.", +"id": "GoogleCloudVideointelligenceV1_SpeechTranscription", +"properties": { +"alternatives": { +"description": "May contain one or more recognition hypotheses (up to the maximum specified in `max_alternatives`). These alternatives are ordered in terms of accuracy, with the top (first) alternative being the most probable, as ranked by the recognizer.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_SpeechRecognitionAlternative" +}, +"type": "array" +}, +"languageCode": { +"description": "Output only. The [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag of the language in this result. This language code was detected to have the most likelihood of being spoken in the audio.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_TextAnnotation": { +"description": "Annotations related to one detected OCR text snippet. This will contain the corresponding text, confidence value, and frame level information for each detection.", +"id": "GoogleCloudVideointelligenceV1_TextAnnotation", +"properties": { +"segments": { +"description": "All video segments where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_TextSegment" +}, +"type": "array" +}, +"text": { +"description": "The detected text.", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_TextFrame": { +"description": "Video frame level annotation results for text annotation (OCR). Contains information regarding timestamp and bounding box locations for the frames containing detected OCR text snippets.", +"id": "GoogleCloudVideointelligenceV1_TextFrame", +"properties": { +"rotatedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1_NormalizedBoundingPoly", +"description": "Bounding polygon of the detected text for this frame." +}, +"timeOffset": { +"description": "Timestamp of this frame.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_TextSegment": { +"description": "Video segment level annotation results for text detection.", +"id": "GoogleCloudVideointelligenceV1_TextSegment", +"properties": { +"confidence": { +"description": "Confidence for the track of detected text. It is calculated as the highest over all frames where OCR detected text appears.", +"format": "float", +"type": "number" +}, +"frames": { +"description": "Information related to the frames where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_TextFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment", +"description": "Video segment where a text snippet was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_TimestampedObject": { +"description": "For tracking related features. An object at time_offset with attributes, and located with normalized_bounding_box.", +"id": "GoogleCloudVideointelligenceV1_TimestampedObject", +"properties": { +"attributes": { +"description": "Optional. The attributes of the object in the bounding box.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_DetectedAttribute" +}, +"type": "array" +}, +"landmarks": { +"description": "Optional. The detected landmarks.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_DetectedLandmark" +}, +"type": "array" +}, +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1_NormalizedBoundingBox", +"description": "Normalized Bounding box in a frame, where the object is located." +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this object.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_Track": { +"description": "A track of an object instance.", +"id": "GoogleCloudVideointelligenceV1_Track", +"properties": { +"attributes": { +"description": "Optional. Attributes in the track level.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_DetectedAttribute" +}, +"type": "array" +}, +"confidence": { +"description": "Optional. The confidence score of the tracked object.", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment", +"description": "Video segment of a track." +}, +"timestampedObjects": { +"description": "The object with timestamp and attributes per frame in the track.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_TimestampedObject" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_VideoAnnotationProgress": { +"description": "Annotation progress for a single video.", +"id": "GoogleCloudVideointelligenceV1_VideoAnnotationProgress", +"properties": { +"feature": { +"description": "Specifies which feature is being tracked if the request contains more than one feature.", +"enum": [ +"FEATURE_UNSPECIFIED", +"LABEL_DETECTION", +"SHOT_CHANGE_DETECTION", +"EXPLICIT_CONTENT_DETECTION", +"FACE_DETECTION", +"SPEECH_TRANSCRIPTION", +"TEXT_DETECTION", +"OBJECT_TRACKING", +"LOGO_RECOGNITION", +"PERSON_DETECTION" +], +"enumDescriptions": [ +"Unspecified.", +"Label detection. Detect objects, such as dog or flower.", +"Shot change detection.", +"Explicit content detection.", +"Human face detection.", +"Speech transcription.", +"OCR text detection and tracking.", +"Object detection and tracking.", +"Logo detection, tracking, and recognition.", +"Person detection." +], +"type": "string" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"progressPercent": { +"description": "Approximate percentage processed thus far. Guaranteed to be 100 when fully processed.", +"format": "int32", +"type": "integer" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment", +"description": "Specifies which segment is being tracked if the request contains more than one segment." +}, +"startTime": { +"description": "Time when the request was received.", +"format": "google-datetime", +"type": "string" +}, +"updateTime": { +"description": "Time of the most recent update.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_VideoAnnotationResults": { +"description": "Annotation results for a single video.", +"id": "GoogleCloudVideointelligenceV1_VideoAnnotationResults", +"properties": { +"error": { +"$ref": "GoogleRpc_Status", +"description": "If set, indicates an error. Note that for a single `AnnotateVideoRequest` some videos may succeed and some may fail." +}, +"explicitAnnotation": { +"$ref": "GoogleCloudVideointelligenceV1_ExplicitContentAnnotation", +"description": "Explicit content annotation." +}, +"faceAnnotations": { +"deprecated": true, +"description": "Deprecated. Please use `face_detection_annotations` instead.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_FaceAnnotation" +}, +"type": "array" +}, +"faceDetectionAnnotations": { +"description": "Face detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_FaceDetectionAnnotation" +}, +"type": "array" +}, +"frameLabelAnnotations": { +"description": "Label annotations on frame level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_LabelAnnotation" +}, +"type": "array" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"logoRecognitionAnnotations": { +"description": "Annotations for list of logos detected, tracked and recognized in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_LogoRecognitionAnnotation" +}, +"type": "array" +}, +"objectAnnotations": { +"description": "Annotations for list of objects detected and tracked in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_ObjectTrackingAnnotation" +}, +"type": "array" +}, +"personDetectionAnnotations": { +"description": "Person detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_PersonDetectionAnnotation" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment", +"description": "Video segment on which the annotation is run." +}, +"segmentLabelAnnotations": { +"description": "Topical label annotations on video level or user-specified segment level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_LabelAnnotation" +}, +"type": "array" +}, +"segmentPresenceLabelAnnotations": { +"description": "Presence label annotations on video level or user-specified segment level. There is exactly one element for each unique label. Compared to the existing topical `segment_label_annotations`, this field presents more fine-grained, segment-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_LabelAnnotation" +}, +"type": "array" +}, +"shotAnnotations": { +"description": "Shot annotations. Each shot is represented as a video segment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_VideoSegment" +}, +"type": "array" +}, +"shotLabelAnnotations": { +"description": "Topical label annotations on shot level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_LabelAnnotation" +}, +"type": "array" +}, +"shotPresenceLabelAnnotations": { +"description": "Presence label annotations on shot level. There is exactly one element for each unique label. Compared to the existing topical `shot_label_annotations`, this field presents more fine-grained, shot-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_LabelAnnotation" +}, +"type": "array" +}, +"speechTranscriptions": { +"description": "Speech transcription.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_SpeechTranscription" +}, +"type": "array" +}, +"textAnnotations": { +"description": "OCR text detection and tracking. Annotations for list of detected text snippets. Each will have list of frame information associated with it.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1_TextAnnotation" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_VideoSegment": { +"description": "Video segment.", +"id": "GoogleCloudVideointelligenceV1_VideoSegment", +"properties": { +"endTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the end of the segment (inclusive).", +"format": "google-duration", +"type": "string" +}, +"startTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the start of the segment (inclusive).", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1_WordInfo": { +"description": "Word-specific information for recognized words. Word information is only included in the response when certain request parameters are set, such as `enable_word_time_offsets`.", +"id": "GoogleCloudVideointelligenceV1_WordInfo", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"endTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the end of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"speakerTag": { +"description": "Output only. A distinct integer value is assigned for every speaker within the audio. This field specifies which one of those speakers was detected to have spoken this word. Value ranges from 1 up to diarization_speaker_count, and is only set if speaker diarization is enabled.", +"format": "int32", +"readOnly": true, +"type": "integer" +}, +"startTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the start of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"word": { +"description": "The word corresponding to this set of information.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_AnnotateVideoProgress": { +"description": "Video annotation progress. Included in the `metadata` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1beta2_AnnotateVideoProgress", +"properties": { +"annotationProgress": { +"description": "Progress metadata for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoAnnotationProgress" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_AnnotateVideoResponse": { +"description": "Video annotation response. Included in the `response` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1beta2_AnnotateVideoResponse", +"properties": { +"annotationResults": { +"description": "Annotation results for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoAnnotationResults" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_DetectedAttribute": { +"description": "A generic detected attribute represented by name in string format.", +"id": "GoogleCloudVideointelligenceV1beta2_DetectedAttribute", +"properties": { +"confidence": { +"description": "Detected attribute confidence. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of the attribute, for example, glasses, dark_glasses, mouth_open. A full list of supported type names will be provided in the document.", +"type": "string" +}, +"value": { +"description": "Text value of the detection result. For example, the value for \"HairColor\" can be \"black\", \"blonde\", etc.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_DetectedLandmark": { +"description": "A generic detected landmark represented by name in string format and a 2D location.", +"id": "GoogleCloudVideointelligenceV1beta2_DetectedLandmark", +"properties": { +"confidence": { +"description": "The confidence score of the detected landmark. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of this landmark, for example, left_hand, right_shoulder.", +"type": "string" +}, +"point": { +"$ref": "GoogleCloudVideointelligenceV1beta2_NormalizedVertex", +"description": "The 2D point of the detected landmark using the normalized image coordindate system. The normalized coordinates have the range from 0 to 1." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_Entity": { +"description": "Detected entity from video analysis.", +"id": "GoogleCloudVideointelligenceV1beta2_Entity", +"properties": { +"description": { +"description": "Textual description, e.g., `Fixed-gear bicycle`.", +"type": "string" +}, +"entityId": { +"description": "Opaque entity ID. Some IDs may be available in [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).", +"type": "string" +}, +"languageCode": { +"description": "Language code for `description` in BCP-47 format.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_ExplicitContentAnnotation": { +"description": "Explicit content annotation (based on per-frame visual signals only). If no explicit content has been detected in a frame, no annotations are present for that frame.", +"id": "GoogleCloudVideointelligenceV1beta2_ExplicitContentAnnotation", +"properties": { +"frames": { +"description": "All video frames where explicit content was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_ExplicitContentFrame" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_ExplicitContentFrame": { +"description": "Video frame level annotation results for explicit content.", +"id": "GoogleCloudVideointelligenceV1beta2_ExplicitContentFrame", +"properties": { +"pornographyLikelihood": { +"description": "Likelihood of the pornography content..", +"enum": [ +"LIKELIHOOD_UNSPECIFIED", +"VERY_UNLIKELY", +"UNLIKELY", +"POSSIBLE", +"LIKELY", +"VERY_LIKELY" +], +"enumDescriptions": [ +"Unspecified likelihood.", +"Very unlikely.", +"Unlikely.", +"Possible.", +"Likely.", +"Very likely." +], +"type": "string" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_FaceAnnotation": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1beta2_FaceAnnotation", +"properties": { +"frames": { +"description": "All video frames where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_FaceFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_FaceSegment" +}, +"type": "array" +}, +"thumbnail": { +"description": "Thumbnail of a representative face view (in JPEG format).", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_FaceDetectionAnnotation": { +"description": "Face detection annotation.", +"id": "GoogleCloudVideointelligenceV1beta2_FaceDetectionAnnotation", +"properties": { +"thumbnail": { +"description": "The thumbnail of a person's face.", +"format": "byte", +"type": "string" +}, +"tracks": { +"description": "The face tracks with attributes.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_FaceFrame": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1beta2_FaceFrame", +"properties": { +"normalizedBoundingBoxes": { +"description": "Normalized Bounding boxes in a frame. There can be more than one boxes if the same face is detected in multiple locations within the current frame.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_NormalizedBoundingBox" +}, +"type": "array" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_FaceSegment": { +"description": "Video segment level annotation results for face detection.", +"id": "GoogleCloudVideointelligenceV1beta2_FaceSegment", +"properties": { +"segment": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment", +"description": "Video segment where a face was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_LabelAnnotation": { +"description": "Label annotation.", +"id": "GoogleCloudVideointelligenceV1beta2_LabelAnnotation", +"properties": { +"categoryEntities": { +"description": "Common categories for the detected entity. For example, when the label is `Terrier`, the category is likely `dog`. And in some cases there might be more than one categories e.g., `Terrier` could also be a `pet`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_Entity" +}, +"type": "array" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1beta2_Entity", +"description": "Detected entity." +}, +"frames": { +"description": "All video frames where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_LabelFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_LabelSegment" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_LabelFrame": { +"description": "Video frame level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1beta2_LabelFrame", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_LabelSegment": { +"description": "Video segment level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1beta2_LabelSegment", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment", +"description": "Video segment where a label was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_LogoRecognitionAnnotation": { +"description": "Annotation corresponding to one detected, tracked and recognized logo class.", +"id": "GoogleCloudVideointelligenceV1beta2_LogoRecognitionAnnotation", +"properties": { +"entity": { +"$ref": "GoogleCloudVideointelligenceV1beta2_Entity", +"description": "Entity category information to specify the logo class that all the logo tracks within this LogoRecognitionAnnotation are recognized as." +}, +"segments": { +"description": "All video segments where the recognized logo appears. There might be multiple instances of the same logo class appearing in one VideoSegment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment" +}, +"type": "array" +}, +"tracks": { +"description": "All logo tracks where the recognized logo appears. Each track corresponds to one logo instance appearing in consecutive frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_Track" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_NormalizedBoundingBox": { +"description": "Normalized bounding box. The normalized vertex coordinates are relative to the original image. Range: [0, 1].", +"id": "GoogleCloudVideointelligenceV1beta2_NormalizedBoundingBox", +"properties": { +"bottom": { +"description": "Bottom Y coordinate.", +"format": "float", +"type": "number" +}, +"left": { +"description": "Left X coordinate.", +"format": "float", +"type": "number" +}, +"right": { +"description": "Right X coordinate.", +"format": "float", +"type": "number" +}, +"top": { +"description": "Top Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_NormalizedBoundingPoly": { +"description": "Normalized bounding polygon for text (that might not be aligned with axis). Contains list of the corner points in clockwise order starting from top-left corner. For example, for a rectangular bounding box: When the text is horizontal it might look like: 0----1 | | 3----2 When it's clockwise rotated 180 degrees around the top-left corner it becomes: 2----3 | | 1----0 and the vertex order will still be (0, 1, 2, 3). Note that values can be less than 0, or greater than 1 due to trignometric calculations for location of the box.", +"id": "GoogleCloudVideointelligenceV1beta2_NormalizedBoundingPoly", +"properties": { +"vertices": { +"description": "Normalized vertices of the bounding polygon.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_NormalizedVertex" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_NormalizedVertex": { +"description": "A vertex represents a 2D point in the image. NOTE: the normalized vertex coordinates are relative to the original image and range from 0 to 1.", +"id": "GoogleCloudVideointelligenceV1beta2_NormalizedVertex", +"properties": { +"x": { +"description": "X coordinate.", +"format": "float", +"type": "number" +}, +"y": { +"description": "Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_ObjectTrackingAnnotation": { +"description": "Annotations corresponding to one tracked object.", +"id": "GoogleCloudVideointelligenceV1beta2_ObjectTrackingAnnotation", +"properties": { +"confidence": { +"description": "Object category's labeling confidence of this track.", +"format": "float", +"type": "number" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1beta2_Entity", +"description": "Entity to specify the object category that this track is labeled as." +}, +"frames": { +"description": "Information corresponding to all frames where this object track appears. Non-streaming batch mode: it may be one or multiple ObjectTrackingFrame messages in frames. Streaming mode: it can only be one ObjectTrackingFrame message in frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_ObjectTrackingFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment", +"description": "Non-streaming batch mode ONLY. Each object track corresponds to one video segment where it appears." +}, +"trackId": { +"description": "Streaming mode ONLY. In streaming mode, we do not know the end time of a tracked object before it is completed. Hence, there is no VideoSegment info returned. Instead, we provide a unique identifiable integer track_id so that the customers can correlate the results of the ongoing ObjectTrackAnnotation of the same track_id over time.", +"format": "int64", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_ObjectTrackingFrame": { +"description": "Video frame level annotations for object detection and tracking. This field stores per frame location, time offset, and confidence.", +"id": "GoogleCloudVideointelligenceV1beta2_ObjectTrackingFrame", +"properties": { +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1beta2_NormalizedBoundingBox", +"description": "The normalized bounding box location of this object track for the frame." +}, +"timeOffset": { +"description": "The timestamp of the frame in microseconds.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_PersonDetectionAnnotation": { +"description": "Person detection annotation per video.", +"id": "GoogleCloudVideointelligenceV1beta2_PersonDetectionAnnotation", +"properties": { +"tracks": { +"description": "The detected tracks of a person.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_SpeechRecognitionAlternative": { +"description": "Alternative hypotheses (a.k.a. n-best list).", +"id": "GoogleCloudVideointelligenceV1beta2_SpeechRecognitionAlternative", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"transcript": { +"description": "Transcript text representing the words that the user spoke.", +"type": "string" +}, +"words": { +"description": "Output only. A list of word-specific information for each recognized word. Note: When `enable_speaker_diarization` is set to true, you will see all the words from the beginning of the audio.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_WordInfo" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_SpeechTranscription": { +"description": "A speech recognition result corresponding to a portion of the audio.", +"id": "GoogleCloudVideointelligenceV1beta2_SpeechTranscription", +"properties": { +"alternatives": { +"description": "May contain one or more recognition hypotheses (up to the maximum specified in `max_alternatives`). These alternatives are ordered in terms of accuracy, with the top (first) alternative being the most probable, as ranked by the recognizer.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_SpeechRecognitionAlternative" +}, +"type": "array" +}, +"languageCode": { +"description": "Output only. The [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag of the language in this result. This language code was detected to have the most likelihood of being spoken in the audio.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_TextAnnotation": { +"description": "Annotations related to one detected OCR text snippet. This will contain the corresponding text, confidence value, and frame level information for each detection.", +"id": "GoogleCloudVideointelligenceV1beta2_TextAnnotation", +"properties": { +"segments": { +"description": "All video segments where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_TextSegment" +}, +"type": "array" +}, +"text": { +"description": "The detected text.", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_TextFrame": { +"description": "Video frame level annotation results for text annotation (OCR). Contains information regarding timestamp and bounding box locations for the frames containing detected OCR text snippets.", +"id": "GoogleCloudVideointelligenceV1beta2_TextFrame", +"properties": { +"rotatedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1beta2_NormalizedBoundingPoly", +"description": "Bounding polygon of the detected text for this frame." +}, +"timeOffset": { +"description": "Timestamp of this frame.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_TextSegment": { +"description": "Video segment level annotation results for text detection.", +"id": "GoogleCloudVideointelligenceV1beta2_TextSegment", +"properties": { +"confidence": { +"description": "Confidence for the track of detected text. It is calculated as the highest over all frames where OCR detected text appears.", +"format": "float", +"type": "number" +}, +"frames": { +"description": "Information related to the frames where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_TextFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment", +"description": "Video segment where a text snippet was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_TimestampedObject": { +"description": "For tracking related features. An object at time_offset with attributes, and located with normalized_bounding_box.", +"id": "GoogleCloudVideointelligenceV1beta2_TimestampedObject", +"properties": { +"attributes": { +"description": "Optional. The attributes of the object in the bounding box.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_DetectedAttribute" +}, +"type": "array" +}, +"landmarks": { +"description": "Optional. The detected landmarks.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_DetectedLandmark" +}, +"type": "array" +}, +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1beta2_NormalizedBoundingBox", +"description": "Normalized Bounding box in a frame, where the object is located." +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this object.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_Track": { +"description": "A track of an object instance.", +"id": "GoogleCloudVideointelligenceV1beta2_Track", +"properties": { +"attributes": { +"description": "Optional. Attributes in the track level.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_DetectedAttribute" +}, +"type": "array" +}, +"confidence": { +"description": "Optional. The confidence score of the tracked object.", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment", +"description": "Video segment of a track." +}, +"timestampedObjects": { +"description": "The object with timestamp and attributes per frame in the track.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_TimestampedObject" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_VideoAnnotationProgress": { +"description": "Annotation progress for a single video.", +"id": "GoogleCloudVideointelligenceV1beta2_VideoAnnotationProgress", +"properties": { +"feature": { +"description": "Specifies which feature is being tracked if the request contains more than one feature.", +"enum": [ +"FEATURE_UNSPECIFIED", +"LABEL_DETECTION", +"SHOT_CHANGE_DETECTION", +"EXPLICIT_CONTENT_DETECTION", +"FACE_DETECTION", +"SPEECH_TRANSCRIPTION", +"TEXT_DETECTION", +"OBJECT_TRACKING", +"LOGO_RECOGNITION", +"PERSON_DETECTION" +], +"enumDescriptions": [ +"Unspecified.", +"Label detection. Detect objects, such as dog or flower.", +"Shot change detection.", +"Explicit content detection.", +"Human face detection.", +"Speech transcription.", +"OCR text detection and tracking.", +"Object detection and tracking.", +"Logo detection, tracking, and recognition.", +"Person detection." +], +"type": "string" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"progressPercent": { +"description": "Approximate percentage processed thus far. Guaranteed to be 100 when fully processed.", +"format": "int32", +"type": "integer" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment", +"description": "Specifies which segment is being tracked if the request contains more than one segment." +}, +"startTime": { +"description": "Time when the request was received.", +"format": "google-datetime", +"type": "string" +}, +"updateTime": { +"description": "Time of the most recent update.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_VideoAnnotationResults": { +"description": "Annotation results for a single video.", +"id": "GoogleCloudVideointelligenceV1beta2_VideoAnnotationResults", +"properties": { +"error": { +"$ref": "GoogleRpc_Status", +"description": "If set, indicates an error. Note that for a single `AnnotateVideoRequest` some videos may succeed and some may fail." +}, +"explicitAnnotation": { +"$ref": "GoogleCloudVideointelligenceV1beta2_ExplicitContentAnnotation", +"description": "Explicit content annotation." +}, +"faceAnnotations": { +"deprecated": true, +"description": "Deprecated. Please use `face_detection_annotations` instead.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_FaceAnnotation" +}, +"type": "array" +}, +"faceDetectionAnnotations": { +"description": "Face detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_FaceDetectionAnnotation" +}, +"type": "array" +}, +"frameLabelAnnotations": { +"description": "Label annotations on frame level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_LabelAnnotation" +}, +"type": "array" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"logoRecognitionAnnotations": { +"description": "Annotations for list of logos detected, tracked and recognized in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_LogoRecognitionAnnotation" +}, +"type": "array" +}, +"objectAnnotations": { +"description": "Annotations for list of objects detected and tracked in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_ObjectTrackingAnnotation" +}, +"type": "array" +}, +"personDetectionAnnotations": { +"description": "Person detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_PersonDetectionAnnotation" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment", +"description": "Video segment on which the annotation is run." +}, +"segmentLabelAnnotations": { +"description": "Topical label annotations on video level or user-specified segment level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_LabelAnnotation" +}, +"type": "array" +}, +"segmentPresenceLabelAnnotations": { +"description": "Presence label annotations on video level or user-specified segment level. There is exactly one element for each unique label. Compared to the existing topical `segment_label_annotations`, this field presents more fine-grained, segment-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_LabelAnnotation" +}, +"type": "array" +}, +"shotAnnotations": { +"description": "Shot annotations. Each shot is represented as a video segment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_VideoSegment" +}, +"type": "array" +}, +"shotLabelAnnotations": { +"description": "Topical label annotations on shot level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_LabelAnnotation" +}, +"type": "array" +}, +"shotPresenceLabelAnnotations": { +"description": "Presence label annotations on shot level. There is exactly one element for each unique label. Compared to the existing topical `shot_label_annotations`, this field presents more fine-grained, shot-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_LabelAnnotation" +}, +"type": "array" +}, +"speechTranscriptions": { +"description": "Speech transcription.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_SpeechTranscription" +}, +"type": "array" +}, +"textAnnotations": { +"description": "OCR text detection and tracking. Annotations for list of detected text snippets. Each will have list of frame information associated with it.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1beta2_TextAnnotation" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_VideoSegment": { +"description": "Video segment.", +"id": "GoogleCloudVideointelligenceV1beta2_VideoSegment", +"properties": { +"endTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the end of the segment (inclusive).", +"format": "google-duration", +"type": "string" +}, +"startTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the start of the segment (inclusive).", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1beta2_WordInfo": { +"description": "Word-specific information for recognized words. Word information is only included in the response when certain request parameters are set, such as `enable_word_time_offsets`.", +"id": "GoogleCloudVideointelligenceV1beta2_WordInfo", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"endTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the end of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"speakerTag": { +"description": "Output only. A distinct integer value is assigned for every speaker within the audio. This field specifies which one of those speakers was detected to have spoken this word. Value ranges from 1 up to diarization_speaker_count, and is only set if speaker diarization is enabled.", +"format": "int32", +"readOnly": true, +"type": "integer" +}, +"startTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the start of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"word": { +"description": "The word corresponding to this set of information.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_AnnotateVideoProgress": { +"description": "Video annotation progress. Included in the `metadata` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1p1beta1_AnnotateVideoProgress", +"properties": { +"annotationProgress": { +"description": "Progress metadata for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoAnnotationProgress" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_AnnotateVideoRequest": { +"description": "Video annotation request.", +"id": "GoogleCloudVideointelligenceV1p1beta1_AnnotateVideoRequest", +"properties": { +"features": { +"description": "Required. Requested video annotation features.", +"items": { +"enum": [ +"FEATURE_UNSPECIFIED", +"LABEL_DETECTION", +"SHOT_CHANGE_DETECTION", +"EXPLICIT_CONTENT_DETECTION", +"FACE_DETECTION", +"SPEECH_TRANSCRIPTION", +"TEXT_DETECTION", +"OBJECT_TRACKING", +"LOGO_RECOGNITION", +"PERSON_DETECTION" +], +"enumDescriptions": [ +"Unspecified.", +"Label detection. Detect objects, such as dog or flower.", +"Shot change detection.", +"Explicit content detection.", +"Human face detection.", +"Speech transcription.", +"OCR text detection and tracking.", +"Object detection and tracking.", +"Logo detection, tracking, and recognition.", +"Person detection." +], +"type": "string" +}, +"type": "array" +}, +"inputContent": { +"description": "The video data bytes. If unset, the input video(s) should be specified via the `input_uri`. If set, `input_uri` must be unset.", +"format": "byte", +"type": "string" +}, +"inputUri": { +"description": "Input video location. Currently, only [Cloud Storage](https://cloud.google.com/storage/) URIs are supported. URIs must be specified in the following format: `gs://bucket-id/object-id` (other URI formats return google.rpc.Code.INVALID_ARGUMENT). For more information, see [Request URIs](https://cloud.google.com/storage/docs/request-endpoints). To identify multiple videos, a video URI may include wildcards in the `object-id`. Supported wildcards: '*' to match 0 or more characters; '?' to match 1 character. If unset, the input video should be embedded in the request as `input_content`. If set, `input_content` must be unset.", +"type": "string" +}, +"locationId": { +"description": "Optional. Cloud region where annotation should take place. Supported cloud regions are: `us-east1`, `us-west1`, `europe-west1`, `asia-east1`. If no region is specified, the region will be determined based on video file location.", +"type": "string" +}, +"outputUri": { +"description": "Optional. Location where the output (in JSON format) should be stored. Currently, only [Cloud Storage](https://cloud.google.com/storage/) URIs are supported. These must be specified in the following format: `gs://bucket-id/object-id` (other URI formats return google.rpc.Code.INVALID_ARGUMENT). For more information, see [Request URIs](https://cloud.google.com/storage/docs/request-endpoints).", +"type": "string" +}, +"videoContext": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoContext", +"description": "Additional video context and/or feature-specific parameters." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_AnnotateVideoResponse": { +"description": "Video annotation response. Included in the `response` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1p1beta1_AnnotateVideoResponse", +"properties": { +"annotationResults": { +"description": "Annotation results for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoAnnotationResults" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_DetectedAttribute": { +"description": "A generic detected attribute represented by name in string format.", +"id": "GoogleCloudVideointelligenceV1p1beta1_DetectedAttribute", +"properties": { +"confidence": { +"description": "Detected attribute confidence. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of the attribute, for example, glasses, dark_glasses, mouth_open. A full list of supported type names will be provided in the document.", +"type": "string" +}, +"value": { +"description": "Text value of the detection result. For example, the value for \"HairColor\" can be \"black\", \"blonde\", etc.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_DetectedLandmark": { +"description": "A generic detected landmark represented by name in string format and a 2D location.", +"id": "GoogleCloudVideointelligenceV1p1beta1_DetectedLandmark", +"properties": { +"confidence": { +"description": "The confidence score of the detected landmark. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of this landmark, for example, left_hand, right_shoulder.", +"type": "string" +}, +"point": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_NormalizedVertex", +"description": "The 2D point of the detected landmark using the normalized image coordindate system. The normalized coordinates have the range from 0 to 1." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_Entity": { +"description": "Detected entity from video analysis.", +"id": "GoogleCloudVideointelligenceV1p1beta1_Entity", +"properties": { +"description": { +"description": "Textual description, e.g., `Fixed-gear bicycle`.", +"type": "string" +}, +"entityId": { +"description": "Opaque entity ID. Some IDs may be available in [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).", +"type": "string" +}, +"languageCode": { +"description": "Language code for `description` in BCP-47 format.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_ExplicitContentAnnotation": { +"description": "Explicit content annotation (based on per-frame visual signals only). If no explicit content has been detected in a frame, no annotations are present for that frame.", +"id": "GoogleCloudVideointelligenceV1p1beta1_ExplicitContentAnnotation", +"properties": { +"frames": { +"description": "All video frames where explicit content was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_ExplicitContentFrame" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_ExplicitContentDetectionConfig": { +"description": "Config for EXPLICIT_CONTENT_DETECTION.", +"id": "GoogleCloudVideointelligenceV1p1beta1_ExplicitContentDetectionConfig", +"properties": { +"model": { +"description": "Model to use for explicit content detection. Supported values: \"builtin/stable\" (the default if unset) and \"builtin/latest\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_ExplicitContentFrame": { +"description": "Video frame level annotation results for explicit content.", +"id": "GoogleCloudVideointelligenceV1p1beta1_ExplicitContentFrame", +"properties": { +"pornographyLikelihood": { +"description": "Likelihood of the pornography content..", +"enum": [ +"LIKELIHOOD_UNSPECIFIED", +"VERY_UNLIKELY", +"UNLIKELY", +"POSSIBLE", +"LIKELY", +"VERY_LIKELY" +], +"enumDescriptions": [ +"Unspecified likelihood.", +"Very unlikely.", +"Unlikely.", +"Possible.", +"Likely.", +"Very likely." +], +"type": "string" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_FaceAnnotation": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1p1beta1_FaceAnnotation", +"properties": { +"frames": { +"description": "All video frames where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_FaceFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_FaceSegment" +}, +"type": "array" +}, +"thumbnail": { +"description": "Thumbnail of a representative face view (in JPEG format).", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_FaceDetectionAnnotation": { +"description": "Face detection annotation.", +"id": "GoogleCloudVideointelligenceV1p1beta1_FaceDetectionAnnotation", +"properties": { +"thumbnail": { +"description": "The thumbnail of a person's face.", +"format": "byte", +"type": "string" +}, +"tracks": { +"description": "The face tracks with attributes.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_FaceDetectionConfig": { +"description": "Config for FACE_DETECTION.", +"id": "GoogleCloudVideointelligenceV1p1beta1_FaceDetectionConfig", +"properties": { +"includeAttributes": { +"description": "Whether to enable face attributes detection, such as glasses, dark_glasses, mouth_open etc. Ignored if 'include_bounding_boxes' is set to false.", +"type": "boolean" +}, +"includeBoundingBoxes": { +"description": "Whether bounding boxes are included in the face annotation output.", +"type": "boolean" +}, +"model": { +"description": "Model to use for face detection. Supported values: \"builtin/stable\" (the default if unset) and \"builtin/latest\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_FaceFrame": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1p1beta1_FaceFrame", +"properties": { +"normalizedBoundingBoxes": { +"description": "Normalized Bounding boxes in a frame. There can be more than one boxes if the same face is detected in multiple locations within the current frame.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_NormalizedBoundingBox" +}, +"type": "array" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_FaceSegment": { +"description": "Video segment level annotation results for face detection.", +"id": "GoogleCloudVideointelligenceV1p1beta1_FaceSegment", +"properties": { +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment", +"description": "Video segment where a face was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_LabelAnnotation": { +"description": "Label annotation.", +"id": "GoogleCloudVideointelligenceV1p1beta1_LabelAnnotation", +"properties": { +"categoryEntities": { +"description": "Common categories for the detected entity. For example, when the label is `Terrier`, the category is likely `dog`. And in some cases there might be more than one categories e.g., `Terrier` could also be a `pet`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_Entity" +}, +"type": "array" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_Entity", +"description": "Detected entity." +}, +"frames": { +"description": "All video frames where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LabelFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LabelSegment" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_LabelDetectionConfig": { +"description": "Config for LABEL_DETECTION.", +"id": "GoogleCloudVideointelligenceV1p1beta1_LabelDetectionConfig", +"properties": { +"frameConfidenceThreshold": { +"description": "The confidence threshold we perform filtering on the labels from frame-level detection. If not set, it is set to 0.4 by default. The valid range for this threshold is [0.1, 0.9]. Any value set outside of this range will be clipped. Note: For best results, follow the default threshold. We will update the default threshold everytime when we release a new model.", +"format": "float", +"type": "number" +}, +"labelDetectionMode": { +"description": "What labels should be detected with LABEL_DETECTION, in addition to video-level labels or segment-level labels. If unspecified, defaults to `SHOT_MODE`.", +"enum": [ +"LABEL_DETECTION_MODE_UNSPECIFIED", +"SHOT_MODE", +"FRAME_MODE", +"SHOT_AND_FRAME_MODE" +], +"enumDescriptions": [ +"Unspecified.", +"Detect shot-level labels.", +"Detect frame-level labels.", +"Detect both shot-level and frame-level labels." +], +"type": "string" +}, +"model": { +"description": "Model to use for label detection. Supported values: \"builtin/stable\" (the default if unset) and \"builtin/latest\".", +"type": "string" +}, +"stationaryCamera": { +"description": "Whether the video has been shot from a stationary (i.e., non-moving) camera. When set to true, might improve detection accuracy for moving objects. Should be used with `SHOT_AND_FRAME_MODE` enabled.", +"type": "boolean" +}, +"videoConfidenceThreshold": { +"description": "The confidence threshold we perform filtering on the labels from video-level and shot-level detections. If not set, it's set to 0.3 by default. The valid range for this threshold is [0.1, 0.9]. Any value set outside of this range will be clipped. Note: For best results, follow the default threshold. We will update the default threshold everytime when we release a new model.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_LabelFrame": { +"description": "Video frame level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1p1beta1_LabelFrame", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_LabelSegment": { +"description": "Video segment level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1p1beta1_LabelSegment", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment", +"description": "Video segment where a label was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_LogoRecognitionAnnotation": { +"description": "Annotation corresponding to one detected, tracked and recognized logo class.", +"id": "GoogleCloudVideointelligenceV1p1beta1_LogoRecognitionAnnotation", +"properties": { +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_Entity", +"description": "Entity category information to specify the logo class that all the logo tracks within this LogoRecognitionAnnotation are recognized as." +}, +"segments": { +"description": "All video segments where the recognized logo appears. There might be multiple instances of the same logo class appearing in one VideoSegment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment" +}, +"type": "array" +}, +"tracks": { +"description": "All logo tracks where the recognized logo appears. Each track corresponds to one logo instance appearing in consecutive frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_Track" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_NormalizedBoundingBox": { +"description": "Normalized bounding box. The normalized vertex coordinates are relative to the original image. Range: [0, 1].", +"id": "GoogleCloudVideointelligenceV1p1beta1_NormalizedBoundingBox", +"properties": { +"bottom": { +"description": "Bottom Y coordinate.", +"format": "float", +"type": "number" +}, +"left": { +"description": "Left X coordinate.", +"format": "float", +"type": "number" +}, +"right": { +"description": "Right X coordinate.", +"format": "float", +"type": "number" +}, +"top": { +"description": "Top Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_NormalizedBoundingPoly": { +"description": "Normalized bounding polygon for text (that might not be aligned with axis). Contains list of the corner points in clockwise order starting from top-left corner. For example, for a rectangular bounding box: When the text is horizontal it might look like: 0----1 | | 3----2 When it's clockwise rotated 180 degrees around the top-left corner it becomes: 2----3 | | 1----0 and the vertex order will still be (0, 1, 2, 3). Note that values can be less than 0, or greater than 1 due to trignometric calculations for location of the box.", +"id": "GoogleCloudVideointelligenceV1p1beta1_NormalizedBoundingPoly", +"properties": { +"vertices": { +"description": "Normalized vertices of the bounding polygon.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_NormalizedVertex" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_NormalizedVertex": { +"description": "A vertex represents a 2D point in the image. NOTE: the normalized vertex coordinates are relative to the original image and range from 0 to 1.", +"id": "GoogleCloudVideointelligenceV1p1beta1_NormalizedVertex", +"properties": { +"x": { +"description": "X coordinate.", +"format": "float", +"type": "number" +}, +"y": { +"description": "Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingAnnotation": { +"description": "Annotations corresponding to one tracked object.", +"id": "GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingAnnotation", +"properties": { +"confidence": { +"description": "Object category's labeling confidence of this track.", +"format": "float", +"type": "number" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_Entity", +"description": "Entity to specify the object category that this track is labeled as." +}, +"frames": { +"description": "Information corresponding to all frames where this object track appears. Non-streaming batch mode: it may be one or multiple ObjectTrackingFrame messages in frames. Streaming mode: it can only be one ObjectTrackingFrame message in frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment", +"description": "Non-streaming batch mode ONLY. Each object track corresponds to one video segment where it appears." +}, +"trackId": { +"description": "Streaming mode ONLY. In streaming mode, we do not know the end time of a tracked object before it is completed. Hence, there is no VideoSegment info returned. Instead, we provide a unique identifiable integer track_id so that the customers can correlate the results of the ongoing ObjectTrackAnnotation of the same track_id over time.", +"format": "int64", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingConfig": { +"description": "Config for OBJECT_TRACKING.", +"id": "GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingConfig", +"properties": { +"model": { +"description": "Model to use for object tracking. Supported values: \"builtin/stable\" (the default if unset) and \"builtin/latest\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingFrame": { +"description": "Video frame level annotations for object detection and tracking. This field stores per frame location, time offset, and confidence.", +"id": "GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingFrame", +"properties": { +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_NormalizedBoundingBox", +"description": "The normalized bounding box location of this object track for the frame." +}, +"timeOffset": { +"description": "The timestamp of the frame in microseconds.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_PersonDetectionAnnotation": { +"description": "Person detection annotation per video.", +"id": "GoogleCloudVideointelligenceV1p1beta1_PersonDetectionAnnotation", +"properties": { +"tracks": { +"description": "The detected tracks of a person.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_PersonDetectionConfig": { +"description": "Config for PERSON_DETECTION.", +"id": "GoogleCloudVideointelligenceV1p1beta1_PersonDetectionConfig", +"properties": { +"includeAttributes": { +"description": "Whether to enable person attributes detection, such as cloth color (black, blue, etc), type (coat, dress, etc), pattern (plain, floral, etc), hair, etc. Ignored if 'include_bounding_boxes' is set to false.", +"type": "boolean" +}, +"includeBoundingBoxes": { +"description": "Whether bounding boxes are included in the person detection annotation output.", +"type": "boolean" +}, +"includePoseLandmarks": { +"description": "Whether to enable pose landmarks detection. Ignored if 'include_bounding_boxes' is set to false.", +"type": "boolean" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_ShotChangeDetectionConfig": { +"description": "Config for SHOT_CHANGE_DETECTION.", +"id": "GoogleCloudVideointelligenceV1p1beta1_ShotChangeDetectionConfig", +"properties": { +"model": { +"description": "Model to use for shot change detection. Supported values: \"builtin/stable\" (the default if unset), \"builtin/latest\", and \"builtin/legacy\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_SpeechContext": { +"description": "Provides \"hints\" to the speech recognizer to favor specific words and phrases in the results.", +"id": "GoogleCloudVideointelligenceV1p1beta1_SpeechContext", +"properties": { +"phrases": { +"description": "Optional. A list of strings containing words and phrases \"hints\" so that the speech recognition is more likely to recognize them. This can be used to improve the accuracy for specific words and phrases, for example, if specific commands are typically spoken by the user. This can also be used to add additional words to the vocabulary of the recognizer. See [usage limits](https://cloud.google.com/speech/limits#content).", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_SpeechRecognitionAlternative": { +"description": "Alternative hypotheses (a.k.a. n-best list).", +"id": "GoogleCloudVideointelligenceV1p1beta1_SpeechRecognitionAlternative", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"transcript": { +"description": "Transcript text representing the words that the user spoke.", +"type": "string" +}, +"words": { +"description": "Output only. A list of word-specific information for each recognized word. Note: When `enable_speaker_diarization` is set to true, you will see all the words from the beginning of the audio.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_WordInfo" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_SpeechTranscription": { +"description": "A speech recognition result corresponding to a portion of the audio.", +"id": "GoogleCloudVideointelligenceV1p1beta1_SpeechTranscription", +"properties": { +"alternatives": { +"description": "May contain one or more recognition hypotheses (up to the maximum specified in `max_alternatives`). These alternatives are ordered in terms of accuracy, with the top (first) alternative being the most probable, as ranked by the recognizer.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_SpeechRecognitionAlternative" +}, +"type": "array" +}, +"languageCode": { +"description": "Output only. The [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag of the language in this result. This language code was detected to have the most likelihood of being spoken in the audio.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_SpeechTranscriptionConfig": { +"description": "Config for SPEECH_TRANSCRIPTION.", +"id": "GoogleCloudVideointelligenceV1p1beta1_SpeechTranscriptionConfig", +"properties": { +"audioTracks": { +"description": "Optional. For file formats, such as MXF or MKV, supporting multiple audio tracks, specify up to two tracks. Default: track 0.", +"items": { +"format": "int32", +"type": "integer" +}, +"type": "array" +}, +"diarizationSpeakerCount": { +"description": "Optional. If set, specifies the estimated number of speakers in the conversation. If not set, defaults to '2'. Ignored unless enable_speaker_diarization is set to true.", +"format": "int32", +"type": "integer" +}, +"enableAutomaticPunctuation": { +"description": "Optional. If 'true', adds punctuation to recognition result hypotheses. This feature is only available in select languages. Setting this for requests in other languages has no effect at all. The default 'false' value does not add punctuation to result hypotheses. NOTE: \"This is currently offered as an experimental service, complimentary to all users. In the future this may be exclusively available as a premium feature.\"", +"type": "boolean" +}, +"enableSpeakerDiarization": { +"description": "Optional. If 'true', enables speaker detection for each recognized word in the top alternative of the recognition result using a speaker_tag provided in the WordInfo. Note: When this is true, we send all the words from the beginning of the audio for the top alternative in every consecutive response. This is done in order to improve our speaker tags as our models learn to identify the speakers in the conversation over time.", +"type": "boolean" +}, +"enableWordConfidence": { +"description": "Optional. If `true`, the top result includes a list of words and the confidence for those words. If `false`, no word-level confidence information is returned. The default is `false`.", +"type": "boolean" +}, +"filterProfanity": { +"description": "Optional. If set to `true`, the server will attempt to filter out profanities, replacing all but the initial character in each filtered word with asterisks, e.g. \"f***\". If set to `false` or omitted, profanities won't be filtered out.", +"type": "boolean" +}, +"languageCode": { +"description": "Required. *Required* The language of the supplied audio as a [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag. Example: \"en-US\". See [Language Support](https://cloud.google.com/speech/docs/languages) for a list of the currently supported language codes.", +"type": "string" +}, +"maxAlternatives": { +"description": "Optional. Maximum number of recognition hypotheses to be returned. Specifically, the maximum number of `SpeechRecognitionAlternative` messages within each `SpeechTranscription`. The server may return fewer than `max_alternatives`. Valid values are `0`-`30`. A value of `0` or `1` will return a maximum of one. If omitted, will return a maximum of one.", +"format": "int32", +"type": "integer" +}, +"speechContexts": { +"description": "Optional. A means to provide context to assist the speech recognition.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_SpeechContext" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_TextAnnotation": { +"description": "Annotations related to one detected OCR text snippet. This will contain the corresponding text, confidence value, and frame level information for each detection.", +"id": "GoogleCloudVideointelligenceV1p1beta1_TextAnnotation", +"properties": { +"segments": { +"description": "All video segments where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_TextSegment" +}, +"type": "array" +}, +"text": { +"description": "The detected text.", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_TextDetectionConfig": { +"description": "Config for TEXT_DETECTION.", +"id": "GoogleCloudVideointelligenceV1p1beta1_TextDetectionConfig", +"properties": { +"languageHints": { +"description": "Language hint can be specified if the language to be detected is known a priori. It can increase the accuracy of the detection. Language hint must be language code in BCP-47 format. Automatic language detection is performed if no hint is provided.", +"items": { +"type": "string" +}, +"type": "array" +}, +"model": { +"description": "Model to use for text detection. Supported values: \"builtin/stable\" (the default if unset) and \"builtin/latest\".", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_TextFrame": { +"description": "Video frame level annotation results for text annotation (OCR). Contains information regarding timestamp and bounding box locations for the frames containing detected OCR text snippets.", +"id": "GoogleCloudVideointelligenceV1p1beta1_TextFrame", +"properties": { +"rotatedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_NormalizedBoundingPoly", +"description": "Bounding polygon of the detected text for this frame." +}, +"timeOffset": { +"description": "Timestamp of this frame.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_TextSegment": { +"description": "Video segment level annotation results for text detection.", +"id": "GoogleCloudVideointelligenceV1p1beta1_TextSegment", +"properties": { +"confidence": { +"description": "Confidence for the track of detected text. It is calculated as the highest over all frames where OCR detected text appears.", +"format": "float", +"type": "number" +}, +"frames": { +"description": "Information related to the frames where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_TextFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment", +"description": "Video segment where a text snippet was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_TimestampedObject": { +"description": "For tracking related features. An object at time_offset with attributes, and located with normalized_bounding_box.", +"id": "GoogleCloudVideointelligenceV1p1beta1_TimestampedObject", +"properties": { +"attributes": { +"description": "Optional. The attributes of the object in the bounding box.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_DetectedAttribute" +}, +"type": "array" +}, +"landmarks": { +"description": "Optional. The detected landmarks.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_DetectedLandmark" +}, +"type": "array" +}, +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_NormalizedBoundingBox", +"description": "Normalized Bounding box in a frame, where the object is located." +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this object.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_Track": { +"description": "A track of an object instance.", +"id": "GoogleCloudVideointelligenceV1p1beta1_Track", +"properties": { +"attributes": { +"description": "Optional. Attributes in the track level.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_DetectedAttribute" +}, +"type": "array" +}, +"confidence": { +"description": "Optional. The confidence score of the tracked object.", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment", +"description": "Video segment of a track." +}, +"timestampedObjects": { +"description": "The object with timestamp and attributes per frame in the track.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_TimestampedObject" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_VideoAnnotationProgress": { +"description": "Annotation progress for a single video.", +"id": "GoogleCloudVideointelligenceV1p1beta1_VideoAnnotationProgress", +"properties": { +"feature": { +"description": "Specifies which feature is being tracked if the request contains more than one feature.", +"enum": [ +"FEATURE_UNSPECIFIED", +"LABEL_DETECTION", +"SHOT_CHANGE_DETECTION", +"EXPLICIT_CONTENT_DETECTION", +"FACE_DETECTION", +"SPEECH_TRANSCRIPTION", +"TEXT_DETECTION", +"OBJECT_TRACKING", +"LOGO_RECOGNITION", +"PERSON_DETECTION" +], +"enumDescriptions": [ +"Unspecified.", +"Label detection. Detect objects, such as dog or flower.", +"Shot change detection.", +"Explicit content detection.", +"Human face detection.", +"Speech transcription.", +"OCR text detection and tracking.", +"Object detection and tracking.", +"Logo detection, tracking, and recognition.", +"Person detection." +], +"type": "string" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"progressPercent": { +"description": "Approximate percentage processed thus far. Guaranteed to be 100 when fully processed.", +"format": "int32", +"type": "integer" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment", +"description": "Specifies which segment is being tracked if the request contains more than one segment." +}, +"startTime": { +"description": "Time when the request was received.", +"format": "google-datetime", +"type": "string" +}, +"updateTime": { +"description": "Time of the most recent update.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_VideoAnnotationResults": { +"description": "Annotation results for a single video.", +"id": "GoogleCloudVideointelligenceV1p1beta1_VideoAnnotationResults", +"properties": { +"error": { +"$ref": "GoogleRpc_Status", +"description": "If set, indicates an error. Note that for a single `AnnotateVideoRequest` some videos may succeed and some may fail." +}, +"explicitAnnotation": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_ExplicitContentAnnotation", +"description": "Explicit content annotation." +}, +"faceAnnotations": { +"deprecated": true, +"description": "Deprecated. Please use `face_detection_annotations` instead.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_FaceAnnotation" +}, +"type": "array" +}, +"faceDetectionAnnotations": { +"description": "Face detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_FaceDetectionAnnotation" +}, +"type": "array" +}, +"frameLabelAnnotations": { +"description": "Label annotations on frame level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LabelAnnotation" +}, +"type": "array" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"logoRecognitionAnnotations": { +"description": "Annotations for list of logos detected, tracked and recognized in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LogoRecognitionAnnotation" +}, +"type": "array" +}, +"objectAnnotations": { +"description": "Annotations for list of objects detected and tracked in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingAnnotation" +}, +"type": "array" +}, +"personDetectionAnnotations": { +"description": "Person detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_PersonDetectionAnnotation" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment", +"description": "Video segment on which the annotation is run." +}, +"segmentLabelAnnotations": { +"description": "Topical label annotations on video level or user-specified segment level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LabelAnnotation" +}, +"type": "array" +}, +"segmentPresenceLabelAnnotations": { +"description": "Presence label annotations on video level or user-specified segment level. There is exactly one element for each unique label. Compared to the existing topical `segment_label_annotations`, this field presents more fine-grained, segment-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LabelAnnotation" +}, +"type": "array" +}, +"shotAnnotations": { +"description": "Shot annotations. Each shot is represented as a video segment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment" +}, +"type": "array" +}, +"shotLabelAnnotations": { +"description": "Topical label annotations on shot level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LabelAnnotation" +}, +"type": "array" +}, +"shotPresenceLabelAnnotations": { +"description": "Presence label annotations on shot level. There is exactly one element for each unique label. Compared to the existing topical `shot_label_annotations`, this field presents more fine-grained, shot-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LabelAnnotation" +}, +"type": "array" +}, +"speechTranscriptions": { +"description": "Speech transcription.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_SpeechTranscription" +}, +"type": "array" +}, +"textAnnotations": { +"description": "OCR text detection and tracking. Annotations for list of detected text snippets. Each will have list of frame information associated with it.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_TextAnnotation" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_VideoContext": { +"description": "Video context and/or feature-specific parameters.", +"id": "GoogleCloudVideointelligenceV1p1beta1_VideoContext", +"properties": { +"explicitContentDetectionConfig": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_ExplicitContentDetectionConfig", +"description": "Config for EXPLICIT_CONTENT_DETECTION." +}, +"faceDetectionConfig": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_FaceDetectionConfig", +"description": "Config for FACE_DETECTION." +}, +"labelDetectionConfig": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_LabelDetectionConfig", +"description": "Config for LABEL_DETECTION." +}, +"objectTrackingConfig": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_ObjectTrackingConfig", +"description": "Config for OBJECT_TRACKING." +}, +"personDetectionConfig": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_PersonDetectionConfig", +"description": "Config for PERSON_DETECTION." +}, +"segments": { +"description": "Video segments to annotate. The segments may overlap and are not required to be contiguous or span the whole video. If unspecified, each video is treated as a single segment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment" +}, +"type": "array" +}, +"shotChangeDetectionConfig": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_ShotChangeDetectionConfig", +"description": "Config for SHOT_CHANGE_DETECTION." +}, +"speechTranscriptionConfig": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_SpeechTranscriptionConfig", +"description": "Config for SPEECH_TRANSCRIPTION." +}, +"textDetectionConfig": { +"$ref": "GoogleCloudVideointelligenceV1p1beta1_TextDetectionConfig", +"description": "Config for TEXT_DETECTION." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_VideoSegment": { +"description": "Video segment.", +"id": "GoogleCloudVideointelligenceV1p1beta1_VideoSegment", +"properties": { +"endTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the end of the segment (inclusive).", +"format": "google-duration", +"type": "string" +}, +"startTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the start of the segment (inclusive).", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p1beta1_WordInfo": { +"description": "Word-specific information for recognized words. Word information is only included in the response when certain request parameters are set, such as `enable_word_time_offsets`.", +"id": "GoogleCloudVideointelligenceV1p1beta1_WordInfo", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"endTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the end of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"speakerTag": { +"description": "Output only. A distinct integer value is assigned for every speaker within the audio. This field specifies which one of those speakers was detected to have spoken this word. Value ranges from 1 up to diarization_speaker_count, and is only set if speaker diarization is enabled.", +"format": "int32", +"readOnly": true, +"type": "integer" +}, +"startTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the start of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"word": { +"description": "The word corresponding to this set of information.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_AnnotateVideoProgress": { +"description": "Video annotation progress. Included in the `metadata` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1p2beta1_AnnotateVideoProgress", +"properties": { +"annotationProgress": { +"description": "Progress metadata for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoAnnotationProgress" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_AnnotateVideoResponse": { +"description": "Video annotation response. Included in the `response` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1p2beta1_AnnotateVideoResponse", +"properties": { +"annotationResults": { +"description": "Annotation results for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoAnnotationResults" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_DetectedAttribute": { +"description": "A generic detected attribute represented by name in string format.", +"id": "GoogleCloudVideointelligenceV1p2beta1_DetectedAttribute", +"properties": { +"confidence": { +"description": "Detected attribute confidence. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of the attribute, for example, glasses, dark_glasses, mouth_open. A full list of supported type names will be provided in the document.", +"type": "string" +}, +"value": { +"description": "Text value of the detection result. For example, the value for \"HairColor\" can be \"black\", \"blonde\", etc.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_DetectedLandmark": { +"description": "A generic detected landmark represented by name in string format and a 2D location.", +"id": "GoogleCloudVideointelligenceV1p2beta1_DetectedLandmark", +"properties": { +"confidence": { +"description": "The confidence score of the detected landmark. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of this landmark, for example, left_hand, right_shoulder.", +"type": "string" +}, +"point": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_NormalizedVertex", +"description": "The 2D point of the detected landmark using the normalized image coordindate system. The normalized coordinates have the range from 0 to 1." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_Entity": { +"description": "Detected entity from video analysis.", +"id": "GoogleCloudVideointelligenceV1p2beta1_Entity", +"properties": { +"description": { +"description": "Textual description, e.g., `Fixed-gear bicycle`.", +"type": "string" +}, +"entityId": { +"description": "Opaque entity ID. Some IDs may be available in [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).", +"type": "string" +}, +"languageCode": { +"description": "Language code for `description` in BCP-47 format.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_ExplicitContentAnnotation": { +"description": "Explicit content annotation (based on per-frame visual signals only). If no explicit content has been detected in a frame, no annotations are present for that frame.", +"id": "GoogleCloudVideointelligenceV1p2beta1_ExplicitContentAnnotation", +"properties": { +"frames": { +"description": "All video frames where explicit content was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_ExplicitContentFrame" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_ExplicitContentFrame": { +"description": "Video frame level annotation results for explicit content.", +"id": "GoogleCloudVideointelligenceV1p2beta1_ExplicitContentFrame", +"properties": { +"pornographyLikelihood": { +"description": "Likelihood of the pornography content..", +"enum": [ +"LIKELIHOOD_UNSPECIFIED", +"VERY_UNLIKELY", +"UNLIKELY", +"POSSIBLE", +"LIKELY", +"VERY_LIKELY" +], +"enumDescriptions": [ +"Unspecified likelihood.", +"Very unlikely.", +"Unlikely.", +"Possible.", +"Likely.", +"Very likely." +], +"type": "string" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_FaceAnnotation": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1p2beta1_FaceAnnotation", +"properties": { +"frames": { +"description": "All video frames where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_FaceFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_FaceSegment" +}, +"type": "array" +}, +"thumbnail": { +"description": "Thumbnail of a representative face view (in JPEG format).", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_FaceDetectionAnnotation": { +"description": "Face detection annotation.", +"id": "GoogleCloudVideointelligenceV1p2beta1_FaceDetectionAnnotation", +"properties": { +"thumbnail": { +"description": "The thumbnail of a person's face.", +"format": "byte", +"type": "string" +}, +"tracks": { +"description": "The face tracks with attributes.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_FaceFrame": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1p2beta1_FaceFrame", +"properties": { +"normalizedBoundingBoxes": { +"description": "Normalized Bounding boxes in a frame. There can be more than one boxes if the same face is detected in multiple locations within the current frame.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_NormalizedBoundingBox" +}, +"type": "array" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_FaceSegment": { +"description": "Video segment level annotation results for face detection.", +"id": "GoogleCloudVideointelligenceV1p2beta1_FaceSegment", +"properties": { +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment", +"description": "Video segment where a face was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_LabelAnnotation": { +"description": "Label annotation.", +"id": "GoogleCloudVideointelligenceV1p2beta1_LabelAnnotation", +"properties": { +"categoryEntities": { +"description": "Common categories for the detected entity. For example, when the label is `Terrier`, the category is likely `dog`. And in some cases there might be more than one categories e.g., `Terrier` could also be a `pet`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_Entity" +}, +"type": "array" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_Entity", +"description": "Detected entity." +}, +"frames": { +"description": "All video frames where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_LabelFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_LabelSegment" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_LabelFrame": { +"description": "Video frame level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1p2beta1_LabelFrame", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_LabelSegment": { +"description": "Video segment level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1p2beta1_LabelSegment", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment", +"description": "Video segment where a label was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_LogoRecognitionAnnotation": { +"description": "Annotation corresponding to one detected, tracked and recognized logo class.", +"id": "GoogleCloudVideointelligenceV1p2beta1_LogoRecognitionAnnotation", +"properties": { +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_Entity", +"description": "Entity category information to specify the logo class that all the logo tracks within this LogoRecognitionAnnotation are recognized as." +}, +"segments": { +"description": "All video segments where the recognized logo appears. There might be multiple instances of the same logo class appearing in one VideoSegment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment" +}, +"type": "array" +}, +"tracks": { +"description": "All logo tracks where the recognized logo appears. Each track corresponds to one logo instance appearing in consecutive frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_Track" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_NormalizedBoundingBox": { +"description": "Normalized bounding box. The normalized vertex coordinates are relative to the original image. Range: [0, 1].", +"id": "GoogleCloudVideointelligenceV1p2beta1_NormalizedBoundingBox", +"properties": { +"bottom": { +"description": "Bottom Y coordinate.", +"format": "float", +"type": "number" +}, +"left": { +"description": "Left X coordinate.", +"format": "float", +"type": "number" +}, +"right": { +"description": "Right X coordinate.", +"format": "float", +"type": "number" +}, +"top": { +"description": "Top Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_NormalizedBoundingPoly": { +"description": "Normalized bounding polygon for text (that might not be aligned with axis). Contains list of the corner points in clockwise order starting from top-left corner. For example, for a rectangular bounding box: When the text is horizontal it might look like: 0----1 | | 3----2 When it's clockwise rotated 180 degrees around the top-left corner it becomes: 2----3 | | 1----0 and the vertex order will still be (0, 1, 2, 3). Note that values can be less than 0, or greater than 1 due to trignometric calculations for location of the box.", +"id": "GoogleCloudVideointelligenceV1p2beta1_NormalizedBoundingPoly", +"properties": { +"vertices": { +"description": "Normalized vertices of the bounding polygon.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_NormalizedVertex" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_NormalizedVertex": { +"description": "A vertex represents a 2D point in the image. NOTE: the normalized vertex coordinates are relative to the original image and range from 0 to 1.", +"id": "GoogleCloudVideointelligenceV1p2beta1_NormalizedVertex", +"properties": { +"x": { +"description": "X coordinate.", +"format": "float", +"type": "number" +}, +"y": { +"description": "Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_ObjectTrackingAnnotation": { +"description": "Annotations corresponding to one tracked object.", +"id": "GoogleCloudVideointelligenceV1p2beta1_ObjectTrackingAnnotation", +"properties": { +"confidence": { +"description": "Object category's labeling confidence of this track.", +"format": "float", +"type": "number" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_Entity", +"description": "Entity to specify the object category that this track is labeled as." +}, +"frames": { +"description": "Information corresponding to all frames where this object track appears. Non-streaming batch mode: it may be one or multiple ObjectTrackingFrame messages in frames. Streaming mode: it can only be one ObjectTrackingFrame message in frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_ObjectTrackingFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment", +"description": "Non-streaming batch mode ONLY. Each object track corresponds to one video segment where it appears." +}, +"trackId": { +"description": "Streaming mode ONLY. In streaming mode, we do not know the end time of a tracked object before it is completed. Hence, there is no VideoSegment info returned. Instead, we provide a unique identifiable integer track_id so that the customers can correlate the results of the ongoing ObjectTrackAnnotation of the same track_id over time.", +"format": "int64", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_ObjectTrackingFrame": { +"description": "Video frame level annotations for object detection and tracking. This field stores per frame location, time offset, and confidence.", +"id": "GoogleCloudVideointelligenceV1p2beta1_ObjectTrackingFrame", +"properties": { +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_NormalizedBoundingBox", +"description": "The normalized bounding box location of this object track for the frame." +}, +"timeOffset": { +"description": "The timestamp of the frame in microseconds.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_PersonDetectionAnnotation": { +"description": "Person detection annotation per video.", +"id": "GoogleCloudVideointelligenceV1p2beta1_PersonDetectionAnnotation", +"properties": { +"tracks": { +"description": "The detected tracks of a person.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_SpeechRecognitionAlternative": { +"description": "Alternative hypotheses (a.k.a. n-best list).", +"id": "GoogleCloudVideointelligenceV1p2beta1_SpeechRecognitionAlternative", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"transcript": { +"description": "Transcript text representing the words that the user spoke.", +"type": "string" +}, +"words": { +"description": "Output only. A list of word-specific information for each recognized word. Note: When `enable_speaker_diarization` is set to true, you will see all the words from the beginning of the audio.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_WordInfo" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_SpeechTranscription": { +"description": "A speech recognition result corresponding to a portion of the audio.", +"id": "GoogleCloudVideointelligenceV1p2beta1_SpeechTranscription", +"properties": { +"alternatives": { +"description": "May contain one or more recognition hypotheses (up to the maximum specified in `max_alternatives`). These alternatives are ordered in terms of accuracy, with the top (first) alternative being the most probable, as ranked by the recognizer.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_SpeechRecognitionAlternative" +}, +"type": "array" +}, +"languageCode": { +"description": "Output only. The [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag of the language in this result. This language code was detected to have the most likelihood of being spoken in the audio.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_TextAnnotation": { +"description": "Annotations related to one detected OCR text snippet. This will contain the corresponding text, confidence value, and frame level information for each detection.", +"id": "GoogleCloudVideointelligenceV1p2beta1_TextAnnotation", +"properties": { +"segments": { +"description": "All video segments where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_TextSegment" +}, +"type": "array" +}, +"text": { +"description": "The detected text.", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_TextFrame": { +"description": "Video frame level annotation results for text annotation (OCR). Contains information regarding timestamp and bounding box locations for the frames containing detected OCR text snippets.", +"id": "GoogleCloudVideointelligenceV1p2beta1_TextFrame", +"properties": { +"rotatedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_NormalizedBoundingPoly", +"description": "Bounding polygon of the detected text for this frame." +}, +"timeOffset": { +"description": "Timestamp of this frame.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_TextSegment": { +"description": "Video segment level annotation results for text detection.", +"id": "GoogleCloudVideointelligenceV1p2beta1_TextSegment", +"properties": { +"confidence": { +"description": "Confidence for the track of detected text. It is calculated as the highest over all frames where OCR detected text appears.", +"format": "float", +"type": "number" +}, +"frames": { +"description": "Information related to the frames where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_TextFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment", +"description": "Video segment where a text snippet was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_TimestampedObject": { +"description": "For tracking related features. An object at time_offset with attributes, and located with normalized_bounding_box.", +"id": "GoogleCloudVideointelligenceV1p2beta1_TimestampedObject", +"properties": { +"attributes": { +"description": "Optional. The attributes of the object in the bounding box.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_DetectedAttribute" +}, +"type": "array" +}, +"landmarks": { +"description": "Optional. The detected landmarks.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_DetectedLandmark" +}, +"type": "array" +}, +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_NormalizedBoundingBox", +"description": "Normalized Bounding box in a frame, where the object is located." +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this object.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_Track": { +"description": "A track of an object instance.", +"id": "GoogleCloudVideointelligenceV1p2beta1_Track", +"properties": { +"attributes": { +"description": "Optional. Attributes in the track level.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_DetectedAttribute" +}, +"type": "array" +}, +"confidence": { +"description": "Optional. The confidence score of the tracked object.", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment", +"description": "Video segment of a track." +}, +"timestampedObjects": { +"description": "The object with timestamp and attributes per frame in the track.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_TimestampedObject" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_VideoAnnotationProgress": { +"description": "Annotation progress for a single video.", +"id": "GoogleCloudVideointelligenceV1p2beta1_VideoAnnotationProgress", +"properties": { +"feature": { +"description": "Specifies which feature is being tracked if the request contains more than one feature.", +"enum": [ +"FEATURE_UNSPECIFIED", +"LABEL_DETECTION", +"SHOT_CHANGE_DETECTION", +"EXPLICIT_CONTENT_DETECTION", +"FACE_DETECTION", +"SPEECH_TRANSCRIPTION", +"TEXT_DETECTION", +"OBJECT_TRACKING", +"LOGO_RECOGNITION", +"PERSON_DETECTION" +], +"enumDescriptions": [ +"Unspecified.", +"Label detection. Detect objects, such as dog or flower.", +"Shot change detection.", +"Explicit content detection.", +"Human face detection.", +"Speech transcription.", +"OCR text detection and tracking.", +"Object detection and tracking.", +"Logo detection, tracking, and recognition.", +"Person detection." +], +"type": "string" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"progressPercent": { +"description": "Approximate percentage processed thus far. Guaranteed to be 100 when fully processed.", +"format": "int32", +"type": "integer" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment", +"description": "Specifies which segment is being tracked if the request contains more than one segment." +}, +"startTime": { +"description": "Time when the request was received.", +"format": "google-datetime", +"type": "string" +}, +"updateTime": { +"description": "Time of the most recent update.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_VideoAnnotationResults": { +"description": "Annotation results for a single video.", +"id": "GoogleCloudVideointelligenceV1p2beta1_VideoAnnotationResults", +"properties": { +"error": { +"$ref": "GoogleRpc_Status", +"description": "If set, indicates an error. Note that for a single `AnnotateVideoRequest` some videos may succeed and some may fail." +}, +"explicitAnnotation": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_ExplicitContentAnnotation", +"description": "Explicit content annotation." +}, +"faceAnnotations": { +"deprecated": true, +"description": "Deprecated. Please use `face_detection_annotations` instead.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_FaceAnnotation" +}, +"type": "array" +}, +"faceDetectionAnnotations": { +"description": "Face detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_FaceDetectionAnnotation" +}, +"type": "array" +}, +"frameLabelAnnotations": { +"description": "Label annotations on frame level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_LabelAnnotation" +}, +"type": "array" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"logoRecognitionAnnotations": { +"description": "Annotations for list of logos detected, tracked and recognized in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_LogoRecognitionAnnotation" +}, +"type": "array" +}, +"objectAnnotations": { +"description": "Annotations for list of objects detected and tracked in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_ObjectTrackingAnnotation" +}, +"type": "array" +}, +"personDetectionAnnotations": { +"description": "Person detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_PersonDetectionAnnotation" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment", +"description": "Video segment on which the annotation is run." +}, +"segmentLabelAnnotations": { +"description": "Topical label annotations on video level or user-specified segment level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_LabelAnnotation" +}, +"type": "array" +}, +"segmentPresenceLabelAnnotations": { +"description": "Presence label annotations on video level or user-specified segment level. There is exactly one element for each unique label. Compared to the existing topical `segment_label_annotations`, this field presents more fine-grained, segment-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_LabelAnnotation" +}, +"type": "array" +}, +"shotAnnotations": { +"description": "Shot annotations. Each shot is represented as a video segment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment" +}, +"type": "array" +}, +"shotLabelAnnotations": { +"description": "Topical label annotations on shot level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_LabelAnnotation" +}, +"type": "array" +}, +"shotPresenceLabelAnnotations": { +"description": "Presence label annotations on shot level. There is exactly one element for each unique label. Compared to the existing topical `shot_label_annotations`, this field presents more fine-grained, shot-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_LabelAnnotation" +}, +"type": "array" +}, +"speechTranscriptions": { +"description": "Speech transcription.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_SpeechTranscription" +}, +"type": "array" +}, +"textAnnotations": { +"description": "OCR text detection and tracking. Annotations for list of detected text snippets. Each will have list of frame information associated with it.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p2beta1_TextAnnotation" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_VideoSegment": { +"description": "Video segment.", +"id": "GoogleCloudVideointelligenceV1p2beta1_VideoSegment", +"properties": { +"endTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the end of the segment (inclusive).", +"format": "google-duration", +"type": "string" +}, +"startTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the start of the segment (inclusive).", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p2beta1_WordInfo": { +"description": "Word-specific information for recognized words. Word information is only included in the response when certain request parameters are set, such as `enable_word_time_offsets`.", +"id": "GoogleCloudVideointelligenceV1p2beta1_WordInfo", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"endTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the end of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"speakerTag": { +"description": "Output only. A distinct integer value is assigned for every speaker within the audio. This field specifies which one of those speakers was detected to have spoken this word. Value ranges from 1 up to diarization_speaker_count, and is only set if speaker diarization is enabled.", +"format": "int32", +"readOnly": true, +"type": "integer" +}, +"startTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the start of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"word": { +"description": "The word corresponding to this set of information.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_AnnotateVideoProgress": { +"description": "Video annotation progress. Included in the `metadata` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1p3beta1_AnnotateVideoProgress", +"properties": { +"annotationProgress": { +"description": "Progress metadata for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoAnnotationProgress" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_AnnotateVideoResponse": { +"description": "Video annotation response. Included in the `response` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.", +"id": "GoogleCloudVideointelligenceV1p3beta1_AnnotateVideoResponse", +"properties": { +"annotationResults": { +"description": "Annotation results for all videos specified in `AnnotateVideoRequest`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoAnnotationResults" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_Celebrity": { +"description": "Celebrity definition.", +"id": "GoogleCloudVideointelligenceV1p3beta1_Celebrity", +"properties": { +"description": { +"description": "Textual description of additional information about the celebrity, if applicable.", +"type": "string" +}, +"displayName": { +"description": "The celebrity name.", +"type": "string" +}, +"name": { +"description": "The resource name of the celebrity. Have the format `video-intelligence/kg-mid` indicates a celebrity from preloaded gallery. kg-mid is the id in Google knowledge graph, which is unique for the celebrity.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_CelebrityRecognitionAnnotation": { +"description": "Celebrity recognition annotation per video.", +"id": "GoogleCloudVideointelligenceV1p3beta1_CelebrityRecognitionAnnotation", +"properties": { +"celebrityTracks": { +"description": "The tracks detected from the input video, including recognized celebrities and other detected faces in the video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_CelebrityTrack" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_CelebrityTrack": { +"description": "The annotation result of a celebrity face track. RecognizedCelebrity field could be empty if the face track does not have any matched celebrities.", +"id": "GoogleCloudVideointelligenceV1p3beta1_CelebrityTrack", +"properties": { +"celebrities": { +"description": "Top N match of the celebrities for the face in this track.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_RecognizedCelebrity" +}, +"type": "array" +}, +"faceTrack": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Track", +"description": "A track of a person's face." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_DetectedAttribute": { +"description": "A generic detected attribute represented by name in string format.", +"id": "GoogleCloudVideointelligenceV1p3beta1_DetectedAttribute", +"properties": { +"confidence": { +"description": "Detected attribute confidence. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of the attribute, for example, glasses, dark_glasses, mouth_open. A full list of supported type names will be provided in the document.", +"type": "string" +}, +"value": { +"description": "Text value of the detection result. For example, the value for \"HairColor\" can be \"black\", \"blonde\", etc.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_DetectedLandmark": { +"description": "A generic detected landmark represented by name in string format and a 2D location.", +"id": "GoogleCloudVideointelligenceV1p3beta1_DetectedLandmark", +"properties": { +"confidence": { +"description": "The confidence score of the detected landmark. Range [0, 1].", +"format": "float", +"type": "number" +}, +"name": { +"description": "The name of this landmark, for example, left_hand, right_shoulder.", +"type": "string" +}, +"point": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_NormalizedVertex", +"description": "The 2D point of the detected landmark using the normalized image coordindate system. The normalized coordinates have the range from 0 to 1." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_Entity": { +"description": "Detected entity from video analysis.", +"id": "GoogleCloudVideointelligenceV1p3beta1_Entity", +"properties": { +"description": { +"description": "Textual description, e.g., `Fixed-gear bicycle`.", +"type": "string" +}, +"entityId": { +"description": "Opaque entity ID. Some IDs may be available in [Google Knowledge Graph Search API](https://developers.google.com/knowledge-graph/).", +"type": "string" +}, +"languageCode": { +"description": "Language code for `description` in BCP-47 format.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_ExplicitContentAnnotation": { +"description": "Explicit content annotation (based on per-frame visual signals only). If no explicit content has been detected in a frame, no annotations are present for that frame.", +"id": "GoogleCloudVideointelligenceV1p3beta1_ExplicitContentAnnotation", +"properties": { +"frames": { +"description": "All video frames where explicit content was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_ExplicitContentFrame" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_ExplicitContentFrame": { +"description": "Video frame level annotation results for explicit content.", +"id": "GoogleCloudVideointelligenceV1p3beta1_ExplicitContentFrame", +"properties": { +"pornographyLikelihood": { +"description": "Likelihood of the pornography content..", +"enum": [ +"LIKELIHOOD_UNSPECIFIED", +"VERY_UNLIKELY", +"UNLIKELY", +"POSSIBLE", +"LIKELY", +"VERY_LIKELY" +], +"enumDescriptions": [ +"Unspecified likelihood.", +"Very unlikely.", +"Unlikely.", +"Possible.", +"Likely.", +"Very likely." +], +"type": "string" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_FaceAnnotation": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1p3beta1_FaceAnnotation", +"properties": { +"frames": { +"description": "All video frames where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_FaceFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a face was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_FaceSegment" +}, +"type": "array" +}, +"thumbnail": { +"description": "Thumbnail of a representative face view (in JPEG format).", +"format": "byte", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_FaceDetectionAnnotation": { +"description": "Face detection annotation.", +"id": "GoogleCloudVideointelligenceV1p3beta1_FaceDetectionAnnotation", +"properties": { +"thumbnail": { +"description": "The thumbnail of a person's face.", +"format": "byte", +"type": "string" +}, +"tracks": { +"description": "The face tracks with attributes.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_FaceFrame": { +"deprecated": true, +"description": "Deprecated. No effect.", +"id": "GoogleCloudVideointelligenceV1p3beta1_FaceFrame", +"properties": { +"normalizedBoundingBoxes": { +"description": "Normalized Bounding boxes in a frame. There can be more than one boxes if the same face is detected in multiple locations within the current frame.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_NormalizedBoundingBox" +}, +"type": "array" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_FaceSegment": { +"description": "Video segment level annotation results for face detection.", +"id": "GoogleCloudVideointelligenceV1p3beta1_FaceSegment", +"properties": { +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment", +"description": "Video segment where a face was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_LabelAnnotation": { +"description": "Label annotation.", +"id": "GoogleCloudVideointelligenceV1p3beta1_LabelAnnotation", +"properties": { +"categoryEntities": { +"description": "Common categories for the detected entity. For example, when the label is `Terrier`, the category is likely `dog`. And in some cases there might be more than one categories e.g., `Terrier` could also be a `pet`.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Entity" +}, +"type": "array" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Entity", +"description": "Detected entity." +}, +"frames": { +"description": "All video frames where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LabelFrame" +}, +"type": "array" +}, +"segments": { +"description": "All video segments where a label was detected.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LabelSegment" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_LabelFrame": { +"description": "Video frame level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1p3beta1_LabelFrame", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this location.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_LabelSegment": { +"description": "Video segment level annotation results for label detection.", +"id": "GoogleCloudVideointelligenceV1p3beta1_LabelSegment", +"properties": { +"confidence": { +"description": "Confidence that the label is accurate. Range: [0, 1].", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment", +"description": "Video segment where a label was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_LogoRecognitionAnnotation": { +"description": "Annotation corresponding to one detected, tracked and recognized logo class.", +"id": "GoogleCloudVideointelligenceV1p3beta1_LogoRecognitionAnnotation", +"properties": { +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Entity", +"description": "Entity category information to specify the logo class that all the logo tracks within this LogoRecognitionAnnotation are recognized as." +}, +"segments": { +"description": "All video segments where the recognized logo appears. There might be multiple instances of the same logo class appearing in one VideoSegment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment" +}, +"type": "array" +}, +"tracks": { +"description": "All logo tracks where the recognized logo appears. Each track corresponds to one logo instance appearing in consecutive frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Track" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_NormalizedBoundingBox": { +"description": "Normalized bounding box. The normalized vertex coordinates are relative to the original image. Range: [0, 1].", +"id": "GoogleCloudVideointelligenceV1p3beta1_NormalizedBoundingBox", +"properties": { +"bottom": { +"description": "Bottom Y coordinate.", +"format": "float", +"type": "number" +}, +"left": { +"description": "Left X coordinate.", +"format": "float", +"type": "number" +}, +"right": { +"description": "Right X coordinate.", +"format": "float", +"type": "number" +}, +"top": { +"description": "Top Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_NormalizedBoundingPoly": { +"description": "Normalized bounding polygon for text (that might not be aligned with axis). Contains list of the corner points in clockwise order starting from top-left corner. For example, for a rectangular bounding box: When the text is horizontal it might look like: 0----1 | | 3----2 When it's clockwise rotated 180 degrees around the top-left corner it becomes: 2----3 | | 1----0 and the vertex order will still be (0, 1, 2, 3). Note that values can be less than 0, or greater than 1 due to trignometric calculations for location of the box.", +"id": "GoogleCloudVideointelligenceV1p3beta1_NormalizedBoundingPoly", +"properties": { +"vertices": { +"description": "Normalized vertices of the bounding polygon.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_NormalizedVertex" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_NormalizedVertex": { +"description": "A vertex represents a 2D point in the image. NOTE: the normalized vertex coordinates are relative to the original image and range from 0 to 1.", +"id": "GoogleCloudVideointelligenceV1p3beta1_NormalizedVertex", +"properties": { +"x": { +"description": "X coordinate.", +"format": "float", +"type": "number" +}, +"y": { +"description": "Y coordinate.", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_ObjectTrackingAnnotation": { +"description": "Annotations corresponding to one tracked object.", +"id": "GoogleCloudVideointelligenceV1p3beta1_ObjectTrackingAnnotation", +"properties": { +"confidence": { +"description": "Object category's labeling confidence of this track.", +"format": "float", +"type": "number" +}, +"entity": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Entity", +"description": "Entity to specify the object category that this track is labeled as." +}, +"frames": { +"description": "Information corresponding to all frames where this object track appears. Non-streaming batch mode: it may be one or multiple ObjectTrackingFrame messages in frames. Streaming mode: it can only be one ObjectTrackingFrame message in frames.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_ObjectTrackingFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment", +"description": "Non-streaming batch mode ONLY. Each object track corresponds to one video segment where it appears." +}, +"trackId": { +"description": "Streaming mode ONLY. In streaming mode, we do not know the end time of a tracked object before it is completed. Hence, there is no VideoSegment info returned. Instead, we provide a unique identifiable integer track_id so that the customers can correlate the results of the ongoing ObjectTrackAnnotation of the same track_id over time.", +"format": "int64", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_ObjectTrackingFrame": { +"description": "Video frame level annotations for object detection and tracking. This field stores per frame location, time offset, and confidence.", +"id": "GoogleCloudVideointelligenceV1p3beta1_ObjectTrackingFrame", +"properties": { +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_NormalizedBoundingBox", +"description": "The normalized bounding box location of this object track for the frame." +}, +"timeOffset": { +"description": "The timestamp of the frame in microseconds.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_PersonDetectionAnnotation": { +"description": "Person detection annotation per video.", +"id": "GoogleCloudVideointelligenceV1p3beta1_PersonDetectionAnnotation", +"properties": { +"tracks": { +"description": "The detected tracks of a person.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Track" +}, +"type": "array" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_RecognizedCelebrity": { +"description": "The recognized celebrity with confidence score.", +"id": "GoogleCloudVideointelligenceV1p3beta1_RecognizedCelebrity", +"properties": { +"celebrity": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_Celebrity", +"description": "The recognized celebrity." +}, +"confidence": { +"description": "Recognition confidence. Range [0, 1].", +"format": "float", +"type": "number" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_SpeechRecognitionAlternative": { +"description": "Alternative hypotheses (a.k.a. n-best list).", +"id": "GoogleCloudVideointelligenceV1p3beta1_SpeechRecognitionAlternative", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"transcript": { +"description": "Transcript text representing the words that the user spoke.", +"type": "string" +}, +"words": { +"description": "Output only. A list of word-specific information for each recognized word. Note: When `enable_speaker_diarization` is set to true, you will see all the words from the beginning of the audio.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_WordInfo" +}, +"readOnly": true, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_SpeechTranscription": { +"description": "A speech recognition result corresponding to a portion of the audio.", +"id": "GoogleCloudVideointelligenceV1p3beta1_SpeechTranscription", +"properties": { +"alternatives": { +"description": "May contain one or more recognition hypotheses (up to the maximum specified in `max_alternatives`). These alternatives are ordered in terms of accuracy, with the top (first) alternative being the most probable, as ranked by the recognizer.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_SpeechRecognitionAlternative" +}, +"type": "array" +}, +"languageCode": { +"description": "Output only. The [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) language tag of the language in this result. This language code was detected to have the most likelihood of being spoken in the audio.", +"readOnly": true, +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_StreamingAnnotateVideoResponse": { +"description": "`StreamingAnnotateVideoResponse` is the only message returned to the client by `StreamingAnnotateVideo`. A series of zero or more `StreamingAnnotateVideoResponse` messages are streamed back to the client.", +"id": "GoogleCloudVideointelligenceV1p3beta1_StreamingAnnotateVideoResponse", +"properties": { +"annotationResults": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_StreamingVideoAnnotationResults", +"description": "Streaming annotation results." +}, +"annotationResultsUri": { +"description": "Google Cloud Storage URI that stores annotation results of one streaming session in JSON format. It is the annotation_result_storage_directory from the request followed by '/cloud_project_number-session_id'.", +"type": "string" +}, +"error": { +"$ref": "GoogleRpc_Status", +"description": "If set, returns a google.rpc.Status message that specifies the error for the operation." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_StreamingVideoAnnotationResults": { +"description": "Streaming annotation results corresponding to a portion of the video that is currently being processed. Only ONE type of annotation will be specified in the response.", +"id": "GoogleCloudVideointelligenceV1p3beta1_StreamingVideoAnnotationResults", +"properties": { +"explicitAnnotation": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_ExplicitContentAnnotation", +"description": "Explicit content annotation results." +}, +"frameTimestamp": { +"description": "Timestamp of the processed frame in microseconds.", +"format": "google-duration", +"type": "string" +}, +"labelAnnotations": { +"description": "Label annotation results.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LabelAnnotation" +}, +"type": "array" +}, +"objectAnnotations": { +"description": "Object tracking results.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_ObjectTrackingAnnotation" +}, +"type": "array" +}, +"shotAnnotations": { +"description": "Shot annotation results. Each shot is represented as a video segment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_TextAnnotation": { +"description": "Annotations related to one detected OCR text snippet. This will contain the corresponding text, confidence value, and frame level information for each detection.", +"id": "GoogleCloudVideointelligenceV1p3beta1_TextAnnotation", +"properties": { +"segments": { +"description": "All video segments where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_TextSegment" +}, +"type": "array" +}, +"text": { +"description": "The detected text.", +"type": "string" +}, +"version": { +"description": "Feature version.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_TextFrame": { +"description": "Video frame level annotation results for text annotation (OCR). Contains information regarding timestamp and bounding box locations for the frames containing detected OCR text snippets.", +"id": "GoogleCloudVideointelligenceV1p3beta1_TextFrame", +"properties": { +"rotatedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_NormalizedBoundingPoly", +"description": "Bounding polygon of the detected text for this frame." +}, +"timeOffset": { +"description": "Timestamp of this frame.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_TextSegment": { +"description": "Video segment level annotation results for text detection.", +"id": "GoogleCloudVideointelligenceV1p3beta1_TextSegment", +"properties": { +"confidence": { +"description": "Confidence for the track of detected text. It is calculated as the highest over all frames where OCR detected text appears.", +"format": "float", +"type": "number" +}, +"frames": { +"description": "Information related to the frames where OCR detected text appears.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_TextFrame" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment", +"description": "Video segment where a text snippet was detected." +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_TimestampedObject": { +"description": "For tracking related features. An object at time_offset with attributes, and located with normalized_bounding_box.", +"id": "GoogleCloudVideointelligenceV1p3beta1_TimestampedObject", +"properties": { +"attributes": { +"description": "Optional. The attributes of the object in the bounding box.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_DetectedAttribute" +}, +"type": "array" +}, +"landmarks": { +"description": "Optional. The detected landmarks.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_DetectedLandmark" +}, +"type": "array" +}, +"normalizedBoundingBox": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_NormalizedBoundingBox", +"description": "Normalized Bounding box in a frame, where the object is located." +}, +"timeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the video frame for this object.", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_Track": { +"description": "A track of an object instance.", +"id": "GoogleCloudVideointelligenceV1p3beta1_Track", +"properties": { +"attributes": { +"description": "Optional. Attributes in the track level.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_DetectedAttribute" +}, +"type": "array" +}, +"confidence": { +"description": "Optional. The confidence score of the tracked object.", +"format": "float", +"type": "number" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment", +"description": "Video segment of a track." +}, +"timestampedObjects": { +"description": "The object with timestamp and attributes per frame in the track.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_TimestampedObject" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_VideoAnnotationProgress": { +"description": "Annotation progress for a single video.", +"id": "GoogleCloudVideointelligenceV1p3beta1_VideoAnnotationProgress", +"properties": { +"feature": { +"description": "Specifies which feature is being tracked if the request contains more than one feature.", +"enum": [ +"FEATURE_UNSPECIFIED", +"LABEL_DETECTION", +"SHOT_CHANGE_DETECTION", +"EXPLICIT_CONTENT_DETECTION", +"FACE_DETECTION", +"SPEECH_TRANSCRIPTION", +"TEXT_DETECTION", +"OBJECT_TRACKING", +"LOGO_RECOGNITION", +"CELEBRITY_RECOGNITION", +"PERSON_DETECTION" +], +"enumDescriptions": [ +"Unspecified.", +"Label detection. Detect objects, such as dog or flower.", +"Shot change detection.", +"Explicit content detection.", +"Human face detection.", +"Speech transcription.", +"OCR text detection and tracking.", +"Object detection and tracking.", +"Logo detection, tracking, and recognition.", +"Celebrity recognition.", +"Person detection." +], +"type": "string" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"progressPercent": { +"description": "Approximate percentage processed thus far. Guaranteed to be 100 when fully processed.", +"format": "int32", +"type": "integer" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment", +"description": "Specifies which segment is being tracked if the request contains more than one segment." +}, +"startTime": { +"description": "Time when the request was received.", +"format": "google-datetime", +"type": "string" +}, +"updateTime": { +"description": "Time of the most recent update.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_VideoAnnotationResults": { +"description": "Annotation results for a single video.", +"id": "GoogleCloudVideointelligenceV1p3beta1_VideoAnnotationResults", +"properties": { +"celebrityRecognitionAnnotations": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_CelebrityRecognitionAnnotation", +"description": "Celebrity recognition annotations." +}, +"error": { +"$ref": "GoogleRpc_Status", +"description": "If set, indicates an error. Note that for a single `AnnotateVideoRequest` some videos may succeed and some may fail." +}, +"explicitAnnotation": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_ExplicitContentAnnotation", +"description": "Explicit content annotation." +}, +"faceAnnotations": { +"deprecated": true, +"description": "Deprecated. Please use `face_detection_annotations` instead.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_FaceAnnotation" +}, +"type": "array" +}, +"faceDetectionAnnotations": { +"description": "Face detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_FaceDetectionAnnotation" +}, +"type": "array" +}, +"frameLabelAnnotations": { +"description": "Label annotations on frame level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LabelAnnotation" +}, +"type": "array" +}, +"inputUri": { +"description": "Video file location in [Cloud Storage](https://cloud.google.com/storage/).", +"type": "string" +}, +"logoRecognitionAnnotations": { +"description": "Annotations for list of logos detected, tracked and recognized in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LogoRecognitionAnnotation" +}, +"type": "array" +}, +"objectAnnotations": { +"description": "Annotations for list of objects detected and tracked in video.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_ObjectTrackingAnnotation" +}, +"type": "array" +}, +"personDetectionAnnotations": { +"description": "Person detection annotations.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_PersonDetectionAnnotation" +}, +"type": "array" +}, +"segment": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment", +"description": "Video segment on which the annotation is run." +}, +"segmentLabelAnnotations": { +"description": "Topical label annotations on video level or user-specified segment level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LabelAnnotation" +}, +"type": "array" +}, +"segmentPresenceLabelAnnotations": { +"description": "Presence label annotations on video level or user-specified segment level. There is exactly one element for each unique label. Compared to the existing topical `segment_label_annotations`, this field presents more fine-grained, segment-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LabelAnnotation" +}, +"type": "array" +}, +"shotAnnotations": { +"description": "Shot annotations. Each shot is represented as a video segment.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment" +}, +"type": "array" +}, +"shotLabelAnnotations": { +"description": "Topical label annotations on shot level. There is exactly one element for each unique label.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LabelAnnotation" +}, +"type": "array" +}, +"shotPresenceLabelAnnotations": { +"description": "Presence label annotations on shot level. There is exactly one element for each unique label. Compared to the existing topical `shot_label_annotations`, this field presents more fine-grained, shot-level labels detected in video content and is made available only when the client sets `LabelDetectionConfig.model` to \"builtin/latest\" in the request.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_LabelAnnotation" +}, +"type": "array" +}, +"speechTranscriptions": { +"description": "Speech transcription.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_SpeechTranscription" +}, +"type": "array" +}, +"textAnnotations": { +"description": "OCR text detection and tracking. Annotations for list of detected text snippets. Each will have list of frame information associated with it.", +"items": { +"$ref": "GoogleCloudVideointelligenceV1p3beta1_TextAnnotation" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_VideoSegment": { +"description": "Video segment.", +"id": "GoogleCloudVideointelligenceV1p3beta1_VideoSegment", +"properties": { +"endTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the end of the segment (inclusive).", +"format": "google-duration", +"type": "string" +}, +"startTimeOffset": { +"description": "Time-offset, relative to the beginning of the video, corresponding to the start of the segment (inclusive).", +"format": "google-duration", +"type": "string" +} +}, +"type": "object" +}, +"GoogleCloudVideointelligenceV1p3beta1_WordInfo": { +"description": "Word-specific information for recognized words. Word information is only included in the response when certain request parameters are set, such as `enable_word_time_offsets`.", +"id": "GoogleCloudVideointelligenceV1p3beta1_WordInfo", +"properties": { +"confidence": { +"description": "Output only. The confidence estimate between 0.0 and 1.0. A higher number indicates an estimated greater likelihood that the recognized words are correct. This field is set only for the top alternative. This field is not guaranteed to be accurate and users should not rely on it to be always provided. The default of 0.0 is a sentinel value indicating `confidence` was not set.", +"format": "float", +"readOnly": true, +"type": "number" +}, +"endTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the end of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"speakerTag": { +"description": "Output only. A distinct integer value is assigned for every speaker within the audio. This field specifies which one of those speakers was detected to have spoken this word. Value ranges from 1 up to diarization_speaker_count, and is only set if speaker diarization is enabled.", +"format": "int32", +"readOnly": true, +"type": "integer" +}, +"startTime": { +"description": "Time offset relative to the beginning of the audio, and corresponding to the start of the spoken word. This field is only set if `enable_word_time_offsets=true` and only in the top hypothesis. This is an experimental feature and the accuracy of the time offset can vary.", +"format": "google-duration", +"type": "string" +}, +"word": { +"description": "The word corresponding to this set of information.", +"type": "string" +} +}, +"type": "object" +}, +"GoogleLongrunning_Operation": { +"description": "This resource represents a long-running operation that is the result of a network API call.", +"id": "GoogleLongrunning_Operation", +"properties": { +"done": { +"description": "If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.", +"type": "boolean" +}, +"error": { +"$ref": "GoogleRpc_Status", +"description": "The error result of the operation in case of failure or cancellation." +}, +"metadata": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.", +"type": "object" +}, +"name": { +"description": "The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.", +"type": "string" +}, +"response": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"description": "The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.", +"type": "object" +} +}, +"type": "object" +}, +"GoogleRpc_Status": { +"description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", +"id": "GoogleRpc_Status", +"properties": { +"code": { +"description": "The status code, which should be an enum value of google.rpc.Code.", +"format": "int32", +"type": "integer" +}, +"details": { +"description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.", +"items": { +"additionalProperties": { +"description": "Properties of the object. Contains field @type with type URL.", +"type": "any" +}, +"type": "object" +}, +"type": "array" +}, +"message": { +"description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.", +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Cloud Video Intelligence API", +"version": "v1p1beta1", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/websecurityscanner.v1beta.json b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/websecurityscanner.v1beta.json new file mode 100644 index 0000000000000000000000000000000000000000..da2d60e64d262945562037e2ff2d34081cd32421 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/documents/websecurityscanner.v1beta.json @@ -0,0 +1,1387 @@ +{ +"auth": { +"oauth2": { +"scopes": { +"https://www.googleapis.com/auth/cloud-platform": { +"description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." +} +} +} +}, +"basePath": "", +"baseUrl": "https://websecurityscanner.googleapis.com/", +"batchPath": "batch", +"canonicalName": "WebSecurityScanner", +"description": "Scans your Compute and App Engine apps for common web vulnerabilities.", +"discoveryVersion": "v1", +"documentationLink": "https://cloud.google.com/security-command-center/docs/concepts-web-security-scanner-overview/", +"fullyEncodeReservedExpansion": true, +"icons": { +"x16": "http://www.google.com/images/icons/product/search-16.gif", +"x32": "http://www.google.com/images/icons/product/search-32.gif" +}, +"id": "websecurityscanner:v1beta", +"kind": "discovery#restDescription", +"mtlsRootUrl": "https://websecurityscanner.mtls.googleapis.com/", +"name": "websecurityscanner", +"ownerDomain": "google.com", +"ownerName": "Google", +"parameters": { +"$.xgafv": { +"description": "V1 error format.", +"enum": [ +"1", +"2" +], +"enumDescriptions": [ +"v1 error format", +"v2 error format" +], +"location": "query", +"type": "string" +}, +"access_token": { +"description": "OAuth access token.", +"location": "query", +"type": "string" +}, +"alt": { +"default": "json", +"description": "Data format for response.", +"enum": [ +"json", +"media", +"proto" +], +"enumDescriptions": [ +"Responses with Content-Type of application/json", +"Media download with context-dependent Content-Type", +"Responses with Content-Type of application/x-protobuf" +], +"location": "query", +"type": "string" +}, +"callback": { +"description": "JSONP", +"location": "query", +"type": "string" +}, +"fields": { +"description": "Selector specifying which fields to include in a partial response.", +"location": "query", +"type": "string" +}, +"key": { +"description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", +"location": "query", +"type": "string" +}, +"oauth_token": { +"description": "OAuth 2.0 token for the current user.", +"location": "query", +"type": "string" +}, +"prettyPrint": { +"default": "true", +"description": "Returns response with indentations and line breaks.", +"location": "query", +"type": "boolean" +}, +"quotaUser": { +"description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", +"location": "query", +"type": "string" +}, +"uploadType": { +"description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", +"location": "query", +"type": "string" +}, +"upload_protocol": { +"description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", +"location": "query", +"type": "string" +} +}, +"protocol": "rest", +"resources": { +"projects": { +"resources": { +"scanConfigs": { +"methods": { +"create": { +"description": "Creates a new ScanConfig.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs", +"httpMethod": "POST", +"id": "websecurityscanner.projects.scanConfigs.create", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource name where the scan is created, which should be a project resource name in the format 'projects/{projectId}'.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+parent}/scanConfigs", +"request": { +"$ref": "ScanConfig" +}, +"response": { +"$ref": "ScanConfig" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"delete": { +"description": "Deletes an existing ScanConfig and its child resources.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}", +"httpMethod": "DELETE", +"id": "websecurityscanner.projects.scanConfigs.delete", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource name of the ScanConfig to be deleted. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+name}", +"response": { +"$ref": "Empty" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"get": { +"description": "Gets a ScanConfig.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}", +"httpMethod": "GET", +"id": "websecurityscanner.projects.scanConfigs.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource name of the ScanConfig to be returned. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+name}", +"response": { +"$ref": "ScanConfig" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists ScanConfigs under a given project.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs", +"httpMethod": "GET", +"id": "websecurityscanner.projects.scanConfigs.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "The maximum number of ScanConfigs to return, can be limited by server. If not specified or not positive, the implementation will select a reasonable value.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying a page of results to be returned. This should be a `next_page_token` value returned from a previous List request. If unspecified, the first page of results is returned.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource name, which should be a project resource name in the format 'projects/{projectId}'.", +"location": "path", +"pattern": "^projects/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+parent}/scanConfigs", +"response": { +"$ref": "ListScanConfigsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"patch": { +"description": "Updates a ScanConfig. This method support partial update of a ScanConfig.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}", +"httpMethod": "PATCH", +"id": "websecurityscanner.projects.scanConfigs.patch", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "The resource name of the ScanConfig. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}'. The ScanConfig IDs are generated by the system.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+$", +"required": true, +"type": "string" +}, +"updateMask": { +"description": "Required. The update mask applies to the resource. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask", +"format": "google-fieldmask", +"location": "query", +"type": "string" +} +}, +"path": "v1beta/{+name}", +"request": { +"$ref": "ScanConfig" +}, +"response": { +"$ref": "ScanConfig" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"start": { +"description": "Start a ScanRun according to the given ScanConfig.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}:start", +"httpMethod": "POST", +"id": "websecurityscanner.projects.scanConfigs.start", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource name of the ScanConfig to be used. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+name}:start", +"request": { +"$ref": "StartScanRunRequest" +}, +"response": { +"$ref": "ScanRun" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"scanRuns": { +"methods": { +"get": { +"description": "Gets a ScanRun.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}/scanRuns/{scanRunsId}", +"httpMethod": "GET", +"id": "websecurityscanner.projects.scanConfigs.scanRuns.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource name of the ScanRun to be returned. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}/scanRuns/{scanRunId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+/scanRuns/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+name}", +"response": { +"$ref": "ScanRun" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "Lists ScanRuns under a given ScanConfig, in descending order of ScanRun stop time.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}/scanRuns", +"httpMethod": "GET", +"id": "websecurityscanner.projects.scanConfigs.scanRuns.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "The maximum number of ScanRuns to return, can be limited by server. If not specified or not positive, the implementation will select a reasonable value.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying a page of results to be returned. This should be a `next_page_token` value returned from a previous List request. If unspecified, the first page of results is returned.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource name, which should be a scan resource name in the format 'projects/{projectId}/scanConfigs/{scanConfigId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+parent}/scanRuns", +"response": { +"$ref": "ListScanRunsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"stop": { +"description": "Stops a ScanRun. The stopped ScanRun is returned.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}/scanRuns/{scanRunsId}:stop", +"httpMethod": "POST", +"id": "websecurityscanner.projects.scanConfigs.scanRuns.stop", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource name of the ScanRun to be stopped. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}/scanRuns/{scanRunId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+/scanRuns/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+name}:stop", +"request": { +"$ref": "StopScanRunRequest" +}, +"response": { +"$ref": "ScanRun" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +}, +"resources": { +"crawledUrls": { +"methods": { +"list": { +"description": "List CrawledUrls under a given ScanRun.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}/scanRuns/{scanRunsId}/crawledUrls", +"httpMethod": "GET", +"id": "websecurityscanner.projects.scanConfigs.scanRuns.crawledUrls.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"pageSize": { +"description": "The maximum number of CrawledUrls to return, can be limited by server. If not specified or not positive, the implementation will select a reasonable value.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying a page of results to be returned. This should be a `next_page_token` value returned from a previous List request. If unspecified, the first page of results is returned.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource name, which should be a scan run resource name in the format 'projects/{projectId}/scanConfigs/{scanConfigId}/scanRuns/{scanRunId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+/scanRuns/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+parent}/crawledUrls", +"response": { +"$ref": "ListCrawledUrlsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"findingTypeStats": { +"methods": { +"list": { +"description": "List all FindingTypeStats under a given ScanRun.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}/scanRuns/{scanRunsId}/findingTypeStats", +"httpMethod": "GET", +"id": "websecurityscanner.projects.scanConfigs.scanRuns.findingTypeStats.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"parent": { +"description": "Required. The parent resource name, which should be a scan run resource name in the format 'projects/{projectId}/scanConfigs/{scanConfigId}/scanRuns/{scanRunId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+/scanRuns/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+parent}/findingTypeStats", +"response": { +"$ref": "ListFindingTypeStatsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +}, +"findings": { +"methods": { +"get": { +"description": "Gets a Finding.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}/scanRuns/{scanRunsId}/findings/{findingsId}", +"httpMethod": "GET", +"id": "websecurityscanner.projects.scanConfigs.scanRuns.findings.get", +"parameterOrder": [ +"name" +], +"parameters": { +"name": { +"description": "Required. The resource name of the Finding to be returned. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}/scanRuns/{scanRunId}/findings/{findingId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+/scanRuns/[^/]+/findings/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+name}", +"response": { +"$ref": "Finding" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +}, +"list": { +"description": "List Findings under a given ScanRun.", +"flatPath": "v1beta/projects/{projectsId}/scanConfigs/{scanConfigsId}/scanRuns/{scanRunsId}/findings", +"httpMethod": "GET", +"id": "websecurityscanner.projects.scanConfigs.scanRuns.findings.list", +"parameterOrder": [ +"parent" +], +"parameters": { +"filter": { +"description": "Required. The filter expression. The expression must be in the format: . Supported field: 'finding_type'. Supported operator: '='.", +"location": "query", +"type": "string" +}, +"pageSize": { +"description": "The maximum number of Findings to return, can be limited by server. If not specified or not positive, the implementation will select a reasonable value.", +"format": "int32", +"location": "query", +"type": "integer" +}, +"pageToken": { +"description": "A token identifying a page of results to be returned. This should be a `next_page_token` value returned from a previous List request. If unspecified, the first page of results is returned.", +"location": "query", +"type": "string" +}, +"parent": { +"description": "Required. The parent resource name, which should be a scan run resource name in the format 'projects/{projectId}/scanConfigs/{scanConfigId}/scanRuns/{scanRunId}'.", +"location": "path", +"pattern": "^projects/[^/]+/scanConfigs/[^/]+/scanRuns/[^/]+$", +"required": true, +"type": "string" +} +}, +"path": "v1beta/{+parent}/findings", +"response": { +"$ref": "ListFindingsResponse" +}, +"scopes": [ +"https://www.googleapis.com/auth/cloud-platform" +] +} +} +} +} +} +} +} +} +} +}, +"revision": "20240623", +"rootUrl": "https://websecurityscanner.googleapis.com/", +"schemas": { +"Authentication": { +"description": "Scan authentication configuration.", +"id": "Authentication", +"properties": { +"customAccount": { +"$ref": "CustomAccount", +"description": "Authentication using a custom account." +}, +"googleAccount": { +"$ref": "GoogleAccount", +"deprecated": true, +"description": "Authentication using a Google account." +}, +"iapCredential": { +"$ref": "IapCredential", +"description": "Authentication using Identity-Aware-Proxy (IAP)." +} +}, +"type": "object" +}, +"CrawledUrl": { +"description": "A CrawledUrl resource represents a URL that was crawled during a ScanRun. Web Security Scanner Service crawls the web applications, following all links within the scope of sites, to find the URLs to test against.", +"id": "CrawledUrl", +"properties": { +"body": { +"description": "The body of the request that was used to visit the URL.", +"type": "string" +}, +"httpMethod": { +"description": "The http method of the request that was used to visit the URL, in uppercase.", +"type": "string" +}, +"url": { +"description": "The URL that was crawled.", +"type": "string" +} +}, +"type": "object" +}, +"CustomAccount": { +"description": "Describes authentication configuration that uses a custom account.", +"id": "CustomAccount", +"properties": { +"loginUrl": { +"description": "Required. The login form URL of the website.", +"type": "string" +}, +"password": { +"description": "Required. Input only. The password of the custom account. The credential is stored encrypted and not returned in any response nor included in audit logs.", +"type": "string" +}, +"username": { +"description": "Required. The user name of the custom account.", +"type": "string" +} +}, +"type": "object" +}, +"Empty": { +"description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }", +"id": "Empty", +"properties": {}, +"type": "object" +}, +"Finding": { +"description": "A Finding resource represents a vulnerability instance identified during a ScanRun.", +"id": "Finding", +"properties": { +"body": { +"description": "The body of the request that triggered the vulnerability.", +"type": "string" +}, +"description": { +"description": "The description of the vulnerability.", +"type": "string" +}, +"finalUrl": { +"description": "The URL where the browser lands when the vulnerability is detected.", +"type": "string" +}, +"findingType": { +"description": "The type of the Finding. Detailed and up-to-date information on findings can be found here: https://cloud.google.com/security-command-center/docs/how-to-remediate-web-security-scanner", +"type": "string" +}, +"form": { +"$ref": "Form", +"description": "An addon containing information reported for a vulnerability with an HTML form, if any." +}, +"frameUrl": { +"description": "If the vulnerability was originated from nested IFrame, the immediate parent IFrame is reported.", +"type": "string" +}, +"fuzzedUrl": { +"description": "The URL produced by the server-side fuzzer and used in the request that triggered the vulnerability.", +"type": "string" +}, +"httpMethod": { +"description": "The http method of the request that triggered the vulnerability, in uppercase.", +"type": "string" +}, +"name": { +"description": "The resource name of the Finding. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}/scanruns/{scanRunId}/findings/{findingId}'. The finding IDs are generated by the system.", +"type": "string" +}, +"outdatedLibrary": { +"$ref": "OutdatedLibrary", +"description": "An addon containing information about outdated libraries." +}, +"reproductionUrl": { +"description": "The URL containing human-readable payload that user can leverage to reproduce the vulnerability.", +"type": "string" +}, +"severity": { +"description": "The severity level of the reported vulnerability.", +"enum": [ +"SEVERITY_UNSPECIFIED", +"CRITICAL", +"HIGH", +"MEDIUM", +"LOW" +], +"enumDescriptions": [ +"No severity specified. The default value.", +"Critical severity.", +"High severity.", +"Medium severity.", +"Low severity." +], +"type": "string" +}, +"trackingId": { +"description": "The tracking ID uniquely identifies a vulnerability instance across multiple ScanRuns.", +"type": "string" +}, +"violatingResource": { +"$ref": "ViolatingResource", +"description": "An addon containing detailed information regarding any resource causing the vulnerability such as JavaScript sources, image, audio files, etc." +}, +"vulnerableHeaders": { +"$ref": "VulnerableHeaders", +"description": "An addon containing information about vulnerable or missing HTTP headers." +}, +"vulnerableParameters": { +"$ref": "VulnerableParameters", +"description": "An addon containing information about request parameters which were found to be vulnerable." +}, +"xss": { +"$ref": "Xss", +"description": "An addon containing information reported for an XSS, if any." +}, +"xxe": { +"$ref": "Xxe", +"description": "An addon containing information reported for an XXE, if any." +} +}, +"type": "object" +}, +"FindingTypeStats": { +"description": "A FindingTypeStats resource represents stats regarding a specific FindingType of Findings under a given ScanRun.", +"id": "FindingTypeStats", +"properties": { +"findingCount": { +"description": "The count of findings belonging to this finding type.", +"format": "int32", +"type": "integer" +}, +"findingType": { +"description": "The finding type associated with the stats.", +"type": "string" +} +}, +"type": "object" +}, +"Form": { +"description": "! Information about a vulnerability with an HTML.", +"id": "Form", +"properties": { +"actionUri": { +"description": "! The URI where to send the form when it's submitted.", +"type": "string" +}, +"fields": { +"description": "! The names of form fields related to the vulnerability.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"GoogleAccount": { +"deprecated": true, +"description": "Describes authentication configuration that uses a Google account.", +"id": "GoogleAccount", +"properties": { +"password": { +"description": "Required. Input only. The password of the Google account. The credential is stored encrypted and not returned in any response nor included in audit logs.", +"type": "string" +}, +"username": { +"description": "Required. The user name of the Google account.", +"type": "string" +} +}, +"type": "object" +}, +"Header": { +"description": "Describes a HTTP Header.", +"id": "Header", +"properties": { +"name": { +"description": "Header name.", +"type": "string" +}, +"value": { +"description": "Header value.", +"type": "string" +} +}, +"type": "object" +}, +"IapCredential": { +"description": "Describes authentication configuration for Identity-Aware-Proxy (IAP).", +"id": "IapCredential", +"properties": { +"iapTestServiceAccountInfo": { +"$ref": "IapTestServiceAccountInfo", +"description": "Authentication configuration when Web-Security-Scanner service account is added in Identity-Aware-Proxy (IAP) access policies." +} +}, +"type": "object" +}, +"IapTestServiceAccountInfo": { +"description": "Describes authentication configuration when Web-Security-Scanner service account is added in Identity-Aware-Proxy (IAP) access policies.", +"id": "IapTestServiceAccountInfo", +"properties": { +"targetAudienceClientId": { +"description": "Required. Describes OAuth2 Client ID of resources protected by Identity-Aware-Proxy(IAP).", +"type": "string" +} +}, +"type": "object" +}, +"ListCrawledUrlsResponse": { +"description": "Response for the `ListCrawledUrls` method.", +"id": "ListCrawledUrlsResponse", +"properties": { +"crawledUrls": { +"description": "The list of CrawledUrls returned.", +"items": { +"$ref": "CrawledUrl" +}, +"type": "array" +}, +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +} +}, +"type": "object" +}, +"ListFindingTypeStatsResponse": { +"description": "Response for the `ListFindingTypeStats` method.", +"id": "ListFindingTypeStatsResponse", +"properties": { +"findingTypeStats": { +"description": "The list of FindingTypeStats returned.", +"items": { +"$ref": "FindingTypeStats" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListFindingsResponse": { +"description": "Response for the `ListFindings` method.", +"id": "ListFindingsResponse", +"properties": { +"findings": { +"description": "The list of Findings returned.", +"items": { +"$ref": "Finding" +}, +"type": "array" +}, +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +} +}, +"type": "object" +}, +"ListScanConfigsResponse": { +"description": "Response for the `ListScanConfigs` method.", +"id": "ListScanConfigsResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"scanConfigs": { +"description": "The list of ScanConfigs returned.", +"items": { +"$ref": "ScanConfig" +}, +"type": "array" +} +}, +"type": "object" +}, +"ListScanRunsResponse": { +"description": "Response for the `ListScanRuns` method.", +"id": "ListScanRunsResponse", +"properties": { +"nextPageToken": { +"description": "Token to retrieve the next page of results, or empty if there are no more results in the list.", +"type": "string" +}, +"scanRuns": { +"description": "The list of ScanRuns returned.", +"items": { +"$ref": "ScanRun" +}, +"type": "array" +} +}, +"type": "object" +}, +"OutdatedLibrary": { +"description": "Information reported for an outdated library.", +"id": "OutdatedLibrary", +"properties": { +"learnMoreUrls": { +"description": "URLs to learn more information about the vulnerabilities in the library.", +"items": { +"type": "string" +}, +"type": "array" +}, +"libraryName": { +"description": "The name of the outdated library.", +"type": "string" +}, +"version": { +"description": "The version number.", +"type": "string" +} +}, +"type": "object" +}, +"ScanConfig": { +"description": "A ScanConfig resource contains the configurations to launch a scan.", +"id": "ScanConfig", +"properties": { +"authentication": { +"$ref": "Authentication", +"description": "The authentication configuration. If specified, service will use the authentication configuration during scanning." +}, +"blacklistPatterns": { +"description": "The excluded URL patterns as described in https://cloud.google.com/security-command-center/docs/how-to-use-web-security-scanner#excluding_urls", +"items": { +"type": "string" +}, +"type": "array" +}, +"displayName": { +"description": "Required. The user provided display name of the ScanConfig.", +"type": "string" +}, +"exportToSecurityCommandCenter": { +"description": "Controls export of scan configurations and results to Security Command Center.", +"enum": [ +"EXPORT_TO_SECURITY_COMMAND_CENTER_UNSPECIFIED", +"ENABLED", +"DISABLED" +], +"enumDescriptions": [ +"Use default, which is ENABLED.", +"Export results of this scan to Security Command Center.", +"Do not export results of this scan to Security Command Center." +], +"type": "string" +}, +"ignoreHttpStatusErrors": { +"description": "Whether to keep scanning even if most requests return HTTP error codes.", +"type": "boolean" +}, +"latestRun": { +"$ref": "ScanRun", +"description": "Latest ScanRun if available." +}, +"managedScan": { +"description": "Whether the scan config is managed by Web Security Scanner, output only.", +"type": "boolean" +}, +"maxQps": { +"description": "The maximum QPS during scanning. A valid value ranges from 5 to 20 inclusively. If the field is unspecified or its value is set 0, server will default to 15. Other values outside of [5, 20] range will be rejected with INVALID_ARGUMENT error.", +"format": "int32", +"type": "integer" +}, +"name": { +"description": "The resource name of the ScanConfig. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}'. The ScanConfig IDs are generated by the system.", +"type": "string" +}, +"riskLevel": { +"description": "The risk level selected for the scan", +"enum": [ +"RISK_LEVEL_UNSPECIFIED", +"NORMAL", +"LOW" +], +"enumDescriptions": [ +"Use default, which is NORMAL.", +"Normal scanning (Recommended)", +"Lower impact scanning" +], +"type": "string" +}, +"schedule": { +"$ref": "Schedule", +"description": "The schedule of the ScanConfig." +}, +"startingUrls": { +"description": "Required. The starting URLs from which the scanner finds site pages.", +"items": { +"type": "string" +}, +"type": "array" +}, +"staticIpScan": { +"description": "Whether the scan configuration has enabled static IP address scan feature. If enabled, the scanner will access applications from static IP addresses.", +"type": "boolean" +}, +"targetPlatforms": { +"description": "Set of Google Cloud platforms targeted by the scan. If empty, APP_ENGINE will be used as a default.", +"items": { +"enum": [ +"TARGET_PLATFORM_UNSPECIFIED", +"APP_ENGINE", +"COMPUTE", +"CLOUD_RUN", +"CLOUD_FUNCTIONS" +], +"enumDescriptions": [ +"The target platform is unknown. Requests with this enum value will be rejected with INVALID_ARGUMENT error.", +"Google App Engine service.", +"Google Compute Engine service.", +"Google Cloud Run service.", +"Google Cloud Function service." +], +"type": "string" +}, +"type": "array" +}, +"userAgent": { +"description": "The user agent used during scanning.", +"enum": [ +"USER_AGENT_UNSPECIFIED", +"CHROME_LINUX", +"CHROME_ANDROID", +"SAFARI_IPHONE" +], +"enumDescriptions": [ +"The user agent is unknown. Service will default to CHROME_LINUX.", +"Chrome on Linux. This is the service default if unspecified.", +"Chrome on Android.", +"Safari on IPhone." +], +"type": "string" +} +}, +"type": "object" +}, +"ScanConfigError": { +"description": "Defines a custom error message used by CreateScanConfig and UpdateScanConfig APIs when scan configuration validation fails. It is also reported as part of a ScanRunErrorTrace message if scan validation fails due to a scan configuration error.", +"id": "ScanConfigError", +"properties": { +"code": { +"description": "Indicates the reason code for a configuration failure.", +"enum": [ +"CODE_UNSPECIFIED", +"OK", +"INTERNAL_ERROR", +"APPENGINE_API_BACKEND_ERROR", +"APPENGINE_API_NOT_ACCESSIBLE", +"APPENGINE_DEFAULT_HOST_MISSING", +"CANNOT_USE_GOOGLE_COM_ACCOUNT", +"CANNOT_USE_OWNER_ACCOUNT", +"COMPUTE_API_BACKEND_ERROR", +"COMPUTE_API_NOT_ACCESSIBLE", +"CUSTOM_LOGIN_URL_DOES_NOT_BELONG_TO_CURRENT_PROJECT", +"CUSTOM_LOGIN_URL_MALFORMED", +"CUSTOM_LOGIN_URL_MAPPED_TO_NON_ROUTABLE_ADDRESS", +"CUSTOM_LOGIN_URL_MAPPED_TO_UNRESERVED_ADDRESS", +"CUSTOM_LOGIN_URL_HAS_NON_ROUTABLE_IP_ADDRESS", +"CUSTOM_LOGIN_URL_HAS_UNRESERVED_IP_ADDRESS", +"DUPLICATE_SCAN_NAME", +"INVALID_FIELD_VALUE", +"FAILED_TO_AUTHENTICATE_TO_TARGET", +"FINDING_TYPE_UNSPECIFIED", +"FORBIDDEN_TO_SCAN_COMPUTE", +"FORBIDDEN_UPDATE_TO_MANAGED_SCAN", +"MALFORMED_FILTER", +"MALFORMED_RESOURCE_NAME", +"PROJECT_INACTIVE", +"REQUIRED_FIELD", +"RESOURCE_NAME_INCONSISTENT", +"SCAN_ALREADY_RUNNING", +"SCAN_NOT_RUNNING", +"SEED_URL_DOES_NOT_BELONG_TO_CURRENT_PROJECT", +"SEED_URL_MALFORMED", +"SEED_URL_MAPPED_TO_NON_ROUTABLE_ADDRESS", +"SEED_URL_MAPPED_TO_UNRESERVED_ADDRESS", +"SEED_URL_HAS_NON_ROUTABLE_IP_ADDRESS", +"SEED_URL_HAS_UNRESERVED_IP_ADDRESS", +"SERVICE_ACCOUNT_NOT_CONFIGURED", +"TOO_MANY_SCANS", +"UNABLE_TO_RESOLVE_PROJECT_INFO", +"UNSUPPORTED_BLACKLIST_PATTERN_FORMAT", +"UNSUPPORTED_FILTER", +"UNSUPPORTED_FINDING_TYPE", +"UNSUPPORTED_URL_SCHEME", +"CLOUD_ASSET_INVENTORY_ASSET_NOT_FOUND" +], +"enumDescriptions": [ +"There is no error.", +"There is no error.", +"Indicates an internal server error. Please DO NOT USE THIS ERROR CODE unless the root cause is truly unknown.", +"One of the seed URLs is an App Engine URL but we cannot validate the scan settings due to an App Engine API backend error.", +"One of the seed URLs is an App Engine URL but we cannot access the App Engine API to validate scan settings.", +"One of the seed URLs is an App Engine URL but the Default Host of the App Engine is not set.", +"Google corporate accounts can not be used for scanning.", +"The account of the scan creator can not be used for scanning.", +"This scan targets Compute Engine, but we cannot validate scan settings due to a Compute Engine API backend error.", +"This scan targets Compute Engine, but we cannot access the Compute Engine API to validate the scan settings.", +"The Custom Login URL does not belong to the current project.", +"The Custom Login URL is malformed (can not be parsed).", +"The Custom Login URL is mapped to a non-routable IP address in DNS.", +"The Custom Login URL is mapped to an IP address which is not reserved for the current project.", +"The Custom Login URL has a non-routable IP address.", +"The Custom Login URL has an IP address which is not reserved for the current project.", +"Another scan with the same name (case-sensitive) already exists.", +"A field is set to an invalid value.", +"There was an error trying to authenticate to the scan target.", +"Finding type value is not specified in the list findings request.", +"Scan targets Compute Engine, yet current project was not whitelisted for Google Compute Engine Scanning Alpha access.", +"User tries to update managed scan", +"The supplied filter is malformed. For example, it can not be parsed, does not have a filter type in expression, or the same filter type appears more than once.", +"The supplied resource name is malformed (can not be parsed).", +"The current project is not in an active state.", +"A required field is not set.", +"Project id, scanconfig id, scanrun id, or finding id are not consistent with each other in resource name.", +"The scan being requested to start is already running.", +"The scan that was requested to be stopped is not running.", +"One of the seed URLs does not belong to the current project.", +"One of the seed URLs is malformed (can not be parsed).", +"One of the seed URLs is mapped to a non-routable IP address in DNS.", +"One of the seed URLs is mapped to an IP address which is not reserved for the current project.", +"One of the seed URLs has on-routable IP address.", +"One of the seed URLs has an IP address that is not reserved for the current project.", +"The Web Security Scanner service account is not configured under the project.", +"A project has reached the maximum number of scans.", +"Resolving the details of the current project fails.", +"One or more blacklist patterns were in the wrong format.", +"The supplied filter is not supported.", +"The supplied finding type is not supported. For example, we do not provide findings of the given finding type.", +"The URL scheme of one or more of the supplied URLs is not supported.", +"CAI is not able to list assets." +], +"type": "string" +}, +"fieldName": { +"description": "Indicates the full name of the ScanConfig field that triggers this error, for example \"scan_config.max_qps\". This field is provided for troubleshooting purposes only and its actual value can change in the future.", +"type": "string" +} +}, +"type": "object" +}, +"ScanRun": { +"description": "A ScanRun is a output-only resource representing an actual run of the scan. Next id: 12", +"id": "ScanRun", +"properties": { +"endTime": { +"description": "The time at which the ScanRun reached termination state - that the ScanRun is either finished or stopped by user.", +"format": "google-datetime", +"type": "string" +}, +"errorTrace": { +"$ref": "ScanRunErrorTrace", +"description": "If result_state is an ERROR, this field provides the primary reason for scan's termination and more details, if such are available." +}, +"executionState": { +"description": "The execution state of the ScanRun.", +"enum": [ +"EXECUTION_STATE_UNSPECIFIED", +"QUEUED", +"SCANNING", +"FINISHED" +], +"enumDescriptions": [ +"Represents an invalid state caused by internal server error. This value should never be returned.", +"The scan is waiting in the queue.", +"The scan is in progress.", +"The scan is either finished or stopped by user." +], +"type": "string" +}, +"hasVulnerabilities": { +"description": "Whether the scan run has found any vulnerabilities.", +"type": "boolean" +}, +"name": { +"description": "The resource name of the ScanRun. The name follows the format of 'projects/{projectId}/scanConfigs/{scanConfigId}/scanRuns/{scanRunId}'. The ScanRun IDs are generated by the system.", +"type": "string" +}, +"progressPercent": { +"description": "The percentage of total completion ranging from 0 to 100. If the scan is in queue, the value is 0. If the scan is running, the value ranges from 0 to 100. If the scan is finished, the value is 100.", +"format": "int32", +"type": "integer" +}, +"resultState": { +"description": "The result state of the ScanRun. This field is only available after the execution state reaches \"FINISHED\".", +"enum": [ +"RESULT_STATE_UNSPECIFIED", +"SUCCESS", +"ERROR", +"KILLED" +], +"enumDescriptions": [ +"Default value. This value is returned when the ScanRun is not yet finished.", +"The scan finished without errors.", +"The scan finished with errors.", +"The scan was terminated by user." +], +"type": "string" +}, +"startTime": { +"description": "The time at which the ScanRun started.", +"format": "google-datetime", +"type": "string" +}, +"urlsCrawledCount": { +"description": "The number of URLs crawled during this ScanRun. If the scan is in progress, the value represents the number of URLs crawled up to now.", +"format": "int64", +"type": "string" +}, +"urlsTestedCount": { +"description": "The number of URLs tested during this ScanRun. If the scan is in progress, the value represents the number of URLs tested up to now. The number of URLs tested is usually larger than the number URLS crawled because typically a crawled URL is tested with multiple test payloads.", +"format": "int64", +"type": "string" +}, +"warningTraces": { +"description": "A list of warnings, if such are encountered during this scan run.", +"items": { +"$ref": "ScanRunWarningTrace" +}, +"type": "array" +} +}, +"type": "object" +}, +"ScanRunErrorTrace": { +"description": "Output only. Defines an error trace message for a ScanRun.", +"id": "ScanRunErrorTrace", +"properties": { +"code": { +"description": "Indicates the error reason code.", +"enum": [ +"CODE_UNSPECIFIED", +"INTERNAL_ERROR", +"SCAN_CONFIG_ISSUE", +"AUTHENTICATION_CONFIG_ISSUE", +"TIMED_OUT_WHILE_SCANNING", +"TOO_MANY_REDIRECTS", +"TOO_MANY_HTTP_ERRORS", +"STARTING_URLS_CRAWL_HTTP_ERRORS" +], +"enumDescriptions": [ +"Default value is never used.", +"Indicates that the scan run failed due to an internal server error.", +"Indicates a scan configuration error, usually due to outdated ScanConfig settings, such as starting_urls or the DNS configuration.", +"Indicates an authentication error, usually due to outdated ScanConfig authentication settings.", +"Indicates a scan operation timeout, usually caused by a very large site.", +"Indicates that a scan encountered excessive redirects, either to authentication or some other page outside of the scan scope.", +"Indicates that a scan encountered numerous errors from the web site pages. When available, most_common_http_error_code field indicates the most common HTTP error code encountered during the scan.", +"Indicates that some of the starting web urls returned HTTP errors during the scan." +], +"type": "string" +}, +"mostCommonHttpErrorCode": { +"description": "If the scan encounters TOO_MANY_HTTP_ERRORS, this field indicates the most common HTTP error code, if such is available. For example, if this code is 404, the scan has encountered too many NOT_FOUND responses.", +"format": "int32", +"type": "integer" +}, +"scanConfigError": { +"$ref": "ScanConfigError", +"description": "If the scan encounters SCAN_CONFIG_ISSUE error, this field has the error message encountered during scan configuration validation that is performed before each scan run." +} +}, +"type": "object" +}, +"ScanRunWarningTrace": { +"description": "Output only. Defines a warning trace message for ScanRun. Warning traces provide customers with useful information that helps make the scanning process more effective.", +"id": "ScanRunWarningTrace", +"properties": { +"code": { +"description": "Indicates the warning code.", +"enum": [ +"CODE_UNSPECIFIED", +"INSUFFICIENT_CRAWL_RESULTS", +"TOO_MANY_CRAWL_RESULTS", +"TOO_MANY_FUZZ_TASKS", +"BLOCKED_BY_IAP", +"NO_STARTING_URL_FOUND_FOR_MANAGED_SCAN" +], +"enumDescriptions": [ +"Default value is never used.", +"Indicates that a scan discovered an unexpectedly low number of URLs. This is sometimes caused by complex navigation features or by using a single URL for numerous pages.", +"Indicates that a scan discovered too many URLs to test, or excessive redundant URLs.", +"Indicates that too many tests have been generated for the scan. Customer should try reducing the number of starting URLs, increasing the QPS rate, or narrowing down the scope of the scan using the excluded patterns.", +"Indicates that a scan is blocked by IAP.", +"Indicates that no seed is found for a scan" +], +"type": "string" +} +}, +"type": "object" +}, +"Schedule": { +"description": "Scan schedule configuration.", +"id": "Schedule", +"properties": { +"intervalDurationDays": { +"description": "Required. The duration of time between executions in days.", +"format": "int32", +"type": "integer" +}, +"scheduleTime": { +"description": "A timestamp indicates when the next run will be scheduled. The value is refreshed by the server after each run. If unspecified, it will default to current server time, which means the scan will be scheduled to start immediately.", +"format": "google-datetime", +"type": "string" +} +}, +"type": "object" +}, +"StartScanRunRequest": { +"description": "Request for the `StartScanRun` method.", +"id": "StartScanRunRequest", +"properties": {}, +"type": "object" +}, +"StopScanRunRequest": { +"description": "Request for the `StopScanRun` method.", +"id": "StopScanRunRequest", +"properties": {}, +"type": "object" +}, +"ViolatingResource": { +"description": "Information regarding any resource causing the vulnerability such as JavaScript sources, image, audio files, etc.", +"id": "ViolatingResource", +"properties": { +"contentType": { +"description": "The MIME type of this resource.", +"type": "string" +}, +"resourceUrl": { +"description": "URL of this violating resource.", +"type": "string" +} +}, +"type": "object" +}, +"VulnerableHeaders": { +"description": "Information about vulnerable or missing HTTP Headers.", +"id": "VulnerableHeaders", +"properties": { +"headers": { +"description": "List of vulnerable headers.", +"items": { +"$ref": "Header" +}, +"type": "array" +}, +"missingHeaders": { +"description": "List of missing headers.", +"items": { +"$ref": "Header" +}, +"type": "array" +} +}, +"type": "object" +}, +"VulnerableParameters": { +"description": "Information about vulnerable request parameters.", +"id": "VulnerableParameters", +"properties": { +"parameterNames": { +"description": "The vulnerable parameter names.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Xss": { +"description": "Information reported for an XSS.", +"id": "Xss", +"properties": { +"errorMessage": { +"description": "An error message generated by a javascript breakage.", +"type": "string" +}, +"stackTraces": { +"description": "Stack traces leading to the point where the XSS occurred.", +"items": { +"type": "string" +}, +"type": "array" +} +}, +"type": "object" +}, +"Xxe": { +"description": "Information reported for an XXE.", +"id": "Xxe", +"properties": { +"payloadLocation": { +"description": "Location within the request where the payload was placed.", +"enum": [ +"LOCATION_UNSPECIFIED", +"COMPLETE_REQUEST_BODY" +], +"enumDescriptions": [ +"Unknown Location.", +"The XML payload replaced the complete request body." +], +"type": "string" +}, +"payloadValue": { +"description": "The XML string that triggered the XXE vulnerability. Non-payload values might be redacted.", +"type": "string" +} +}, +"type": "object" +} +}, +"servicePath": "", +"title": "Web Security Scanner API", +"version": "v1beta", +"version_module": true +} \ No newline at end of file diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/file_cache.py b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/file_cache.py new file mode 100644 index 0000000000000000000000000000000000000000..28a7219847fd8a59591a52751d8ee21497cdaef6 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/file_cache.py @@ -0,0 +1,145 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""File based cache for the discovery document. + +The cache is stored in a single file so that multiple processes can +share the same cache. It locks the file whenever accessing to the +file. When the cache content is corrupted, it will be initialized with +an empty cache. +""" + +from __future__ import division + +import datetime +import json +import logging +import os +import tempfile + +try: + from oauth2client.contrib.locked_file import LockedFile +except ImportError: + # oauth2client < 2.0.0 + try: + from oauth2client.locked_file import LockedFile + except ImportError: + # oauth2client > 4.0.0 or google-auth + raise ImportError( + "file_cache is unavailable when using oauth2client >= 4.0.0 or google-auth" + ) + +from . import base +from ..discovery_cache import DISCOVERY_DOC_MAX_AGE + +LOGGER = logging.getLogger(__name__) + +FILENAME = "google-api-python-client-discovery-doc.cache" +EPOCH = datetime.datetime(1970, 1, 1) + + +def _to_timestamp(date): + try: + return (date - EPOCH).total_seconds() + except AttributeError: + # The following is the equivalent of total_seconds() in Python2.6. + # See also: https://docs.python.org/2/library/datetime.html + delta = date - EPOCH + return ( + delta.microseconds + (delta.seconds + delta.days * 24 * 3600) * 10**6 + ) / 10**6 + + +def _read_or_initialize_cache(f): + f.file_handle().seek(0) + try: + cache = json.load(f.file_handle()) + except Exception: + # This means it opens the file for the first time, or the cache is + # corrupted, so initializing the file with an empty dict. + cache = {} + f.file_handle().truncate(0) + f.file_handle().seek(0) + json.dump(cache, f.file_handle()) + return cache + + +class Cache(base.Cache): + """A file based cache for the discovery documents.""" + + def __init__(self, max_age): + """Constructor. + + Args: + max_age: Cache expiration in seconds. + """ + self._max_age = max_age + self._file = os.path.join(tempfile.gettempdir(), FILENAME) + f = LockedFile(self._file, "a+", "r") + try: + f.open_and_lock() + if f.is_locked(): + _read_or_initialize_cache(f) + # If we can not obtain the lock, other process or thread must + # have initialized the file. + except Exception as e: + LOGGER.warning(e, exc_info=True) + finally: + f.unlock_and_close() + + def get(self, url): + f = LockedFile(self._file, "r+", "r") + try: + f.open_and_lock() + if f.is_locked(): + cache = _read_or_initialize_cache(f) + if url in cache: + content, t = cache.get(url, (None, 0)) + if _to_timestamp(datetime.datetime.now()) < t + self._max_age: + return content + return None + else: + LOGGER.debug("Could not obtain a lock for the cache file.") + return None + except Exception as e: + LOGGER.warning(e, exc_info=True) + finally: + f.unlock_and_close() + + def set(self, url, content): + f = LockedFile(self._file, "r+", "r") + try: + f.open_and_lock() + if f.is_locked(): + cache = _read_or_initialize_cache(f) + cache[url] = (content, _to_timestamp(datetime.datetime.now())) + # Remove stale cache. + for k, (_, timestamp) in list(cache.items()): + if ( + _to_timestamp(datetime.datetime.now()) + >= timestamp + self._max_age + ): + del cache[k] + f.file_handle().truncate(0) + f.file_handle().seek(0) + json.dump(cache, f.file_handle()) + else: + LOGGER.debug("Could not obtain a lock for the cache file.") + except Exception as e: + LOGGER.warning(e, exc_info=True) + finally: + f.unlock_and_close() + + +cache = Cache(max_age=DISCOVERY_DOC_MAX_AGE) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/errors.py b/.venv/lib/python3.11/site-packages/googleapiclient/errors.py new file mode 100644 index 0000000000000000000000000000000000000000..288594a68a5647ff5179bccc0adcf18a697d4c41 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/errors.py @@ -0,0 +1,197 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""Errors for the library. + +All exceptions defined by the library +should be defined in this file. +""" +from __future__ import absolute_import + +__author__ = "jcgregorio@google.com (Joe Gregorio)" + +import json + +from googleapiclient import _helpers as util + + +class Error(Exception): + """Base error for this module.""" + + pass + + +class HttpError(Error): + """HTTP data was invalid or unexpected.""" + + @util.positional(3) + def __init__(self, resp, content, uri=None): + self.resp = resp + if not isinstance(content, bytes): + raise TypeError("HTTP content should be bytes") + self.content = content + self.uri = uri + self.error_details = "" + self.reason = self._get_reason() + + @property + def status_code(self): + """Return the HTTP status code from the response content.""" + return self.resp.status + + def _get_reason(self): + """Calculate the reason for the error from the response content.""" + reason = self.resp.reason + try: + try: + data = json.loads(self.content.decode("utf-8")) + except json.JSONDecodeError: + # In case it is not json + data = self.content.decode("utf-8") + if isinstance(data, dict): + reason = data["error"]["message"] + error_detail_keyword = next( + ( + kw + for kw in ["detail", "details", "errors", "message"] + if kw in data["error"] + ), + "", + ) + if error_detail_keyword: + self.error_details = data["error"][error_detail_keyword] + elif isinstance(data, list) and len(data) > 0: + first_error = data[0] + reason = first_error["error"]["message"] + if "details" in first_error["error"]: + self.error_details = first_error["error"]["details"] + else: + self.error_details = data + except (ValueError, KeyError, TypeError): + pass + if reason is None: + reason = "" + return reason.strip() + + def __repr__(self): + if self.error_details: + return '' % ( + self.resp.status, + self.uri, + self.reason, + self.error_details, + ) + elif self.uri: + return '' % ( + self.resp.status, + self.uri, + self.reason, + ) + else: + return '' % (self.resp.status, self.reason) + + __str__ = __repr__ + + +class InvalidJsonError(Error): + """The JSON returned could not be parsed.""" + + pass + + +class UnknownFileType(Error): + """File type unknown or unexpected.""" + + pass + + +class UnknownLinkType(Error): + """Link type unknown or unexpected.""" + + pass + + +class UnknownApiNameOrVersion(Error): + """No API with that name and version exists.""" + + pass + + +class UnacceptableMimeTypeError(Error): + """That is an unacceptable mimetype for this operation.""" + + pass + + +class MediaUploadSizeError(Error): + """Media is larger than the method can accept.""" + + pass + + +class ResumableUploadError(HttpError): + """Error occurred during resumable upload.""" + + pass + + +class InvalidChunkSizeError(Error): + """The given chunksize is not valid.""" + + pass + + +class InvalidNotificationError(Error): + """The channel Notification is invalid.""" + + pass + + +class BatchError(HttpError): + """Error occurred during batch operations.""" + + @util.positional(2) + def __init__(self, reason, resp=None, content=None): + self.resp = resp + self.content = content + self.reason = reason + + def __repr__(self): + if getattr(self.resp, "status", None) is None: + return '' % (self.reason) + else: + return '' % (self.resp.status, self.reason) + + __str__ = __repr__ + + +class UnexpectedMethodError(Error): + """Exception raised by RequestMockBuilder on unexpected calls.""" + + @util.positional(1) + def __init__(self, methodId=None): + """Constructor for an UnexpectedMethodError.""" + super(UnexpectedMethodError, self).__init__( + "Received unexpected call %s" % methodId + ) + + +class UnexpectedBodyError(Error): + """Exception raised by RequestMockBuilder on unexpected bodies.""" + + def __init__(self, expected, provided): + """Constructor for an UnexpectedMethodError.""" + super(UnexpectedBodyError, self).__init__( + "Expected: [%s] - Provided: [%s]" % (expected, provided) + ) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/http.py b/.venv/lib/python3.11/site-packages/googleapiclient/http.py new file mode 100644 index 0000000000000000000000000000000000000000..187f6f5dac856e27d583e66ca805d80e26f8f6df --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/http.py @@ -0,0 +1,1962 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""Classes to encapsulate a single HTTP request. + +The classes implement a command pattern, with every +object supporting an execute() method that does the +actual HTTP request. +""" +from __future__ import absolute_import + +__author__ = "jcgregorio@google.com (Joe Gregorio)" + +import copy +import http.client as http_client +import io +import json +import logging +import mimetypes +import os +import random +import socket +import time +import urllib +import uuid + +import httplib2 + +# TODO(issue 221): Remove this conditional import jibbajabba. +try: + import ssl +except ImportError: + _ssl_SSLError = object() +else: + _ssl_SSLError = ssl.SSLError + +from email.generator import Generator +from email.mime.multipart import MIMEMultipart +from email.mime.nonmultipart import MIMENonMultipart +from email.parser import FeedParser + +from googleapiclient import _auth +from googleapiclient import _helpers as util +from googleapiclient.errors import ( + BatchError, + HttpError, + InvalidChunkSizeError, + ResumableUploadError, + UnexpectedBodyError, + UnexpectedMethodError, +) +from googleapiclient.model import JsonModel + +LOGGER = logging.getLogger(__name__) + +DEFAULT_CHUNK_SIZE = 100 * 1024 * 1024 + +MAX_URI_LENGTH = 2048 + +MAX_BATCH_LIMIT = 1000 + +_TOO_MANY_REQUESTS = 429 + +DEFAULT_HTTP_TIMEOUT_SEC = 60 + +_LEGACY_BATCH_URI = "https://www.googleapis.com/batch" + + +def _should_retry_response(resp_status, content): + """Determines whether a response should be retried. + + Args: + resp_status: The response status received. + content: The response content body. + + Returns: + True if the response should be retried, otherwise False. + """ + reason = None + + # Retry on 5xx errors. + if resp_status >= 500: + return True + + # Retry on 429 errors. + if resp_status == _TOO_MANY_REQUESTS: + return True + + # For 403 errors, we have to check for the `reason` in the response to + # determine if we should retry. + if resp_status == http_client.FORBIDDEN: + # If there's no details about the 403 type, don't retry. + if not content: + return False + + # Content is in JSON format. + try: + data = json.loads(content.decode("utf-8")) + if isinstance(data, dict): + # There are many variations of the error json so we need + # to determine the keyword which has the error detail. Make sure + # that the order of the keywords below isn't changed as it can + # break user code. If the "errors" key exists, we must use that + # first. + # See Issue #1243 + # https://github.com/googleapis/google-api-python-client/issues/1243 + error_detail_keyword = next( + ( + kw + for kw in ["errors", "status", "message"] + if kw in data["error"] + ), + "", + ) + + if error_detail_keyword: + reason = data["error"][error_detail_keyword] + + if isinstance(reason, list) and len(reason) > 0: + reason = reason[0] + if "reason" in reason: + reason = reason["reason"] + else: + reason = data[0]["error"]["errors"]["reason"] + except (UnicodeDecodeError, ValueError, KeyError): + LOGGER.warning("Invalid JSON content from response: %s", content) + return False + + LOGGER.warning('Encountered 403 Forbidden with reason "%s"', reason) + + # Only retry on rate limit related failures. + if reason in ("userRateLimitExceeded", "rateLimitExceeded"): + return True + + # Everything else is a success or non-retriable so break. + return False + + +def _retry_request( + http, num_retries, req_type, sleep, rand, uri, method, *args, **kwargs +): + """Retries an HTTP request multiple times while handling errors. + + If after all retries the request still fails, last error is either returned as + return value (for HTTP 5xx errors) or thrown (for ssl.SSLError). + + Args: + http: Http object to be used to execute request. + num_retries: Maximum number of retries. + req_type: Type of the request (used for logging retries). + sleep, rand: Functions to sleep for random time between retries. + uri: URI to be requested. + method: HTTP method to be used. + args, kwargs: Additional arguments passed to http.request. + + Returns: + resp, content - Response from the http request (may be HTTP 5xx). + """ + resp = None + content = None + exception = None + for retry_num in range(num_retries + 1): + if retry_num > 0: + # Sleep before retrying. + sleep_time = rand() * 2**retry_num + LOGGER.warning( + "Sleeping %.2f seconds before retry %d of %d for %s: %s %s, after %s", + sleep_time, + retry_num, + num_retries, + req_type, + method, + uri, + resp.status if resp else exception, + ) + sleep(sleep_time) + + try: + exception = None + resp, content = http.request(uri, method, *args, **kwargs) + # Retry on SSL errors and socket timeout errors. + except _ssl_SSLError as ssl_error: + exception = ssl_error + except socket.timeout as socket_timeout: + # Needs to be before socket.error as it's a subclass of OSError + # socket.timeout has no errorcode + exception = socket_timeout + except ConnectionError as connection_error: + # Needs to be before socket.error as it's a subclass of OSError + exception = connection_error + except OSError as socket_error: + # errno's contents differ by platform, so we have to match by name. + # Some of these same errors may have been caught above, e.g. ECONNRESET *should* be + # raised as a ConnectionError, but some libraries will raise it as a socket.error + # with an errno corresponding to ECONNRESET + if socket.errno.errorcode.get(socket_error.errno) not in { + "WSAETIMEDOUT", + "ETIMEDOUT", + "EPIPE", + "ECONNABORTED", + "ECONNREFUSED", + "ECONNRESET", + }: + raise + exception = socket_error + except httplib2.ServerNotFoundError as server_not_found_error: + exception = server_not_found_error + + if exception: + if retry_num == num_retries: + raise exception + else: + continue + + if not _should_retry_response(resp.status, content): + break + + return resp, content + + +class MediaUploadProgress(object): + """Status of a resumable upload.""" + + def __init__(self, resumable_progress, total_size): + """Constructor. + + Args: + resumable_progress: int, bytes sent so far. + total_size: int, total bytes in complete upload, or None if the total + upload size isn't known ahead of time. + """ + self.resumable_progress = resumable_progress + self.total_size = total_size + + def progress(self): + """Percent of upload completed, as a float. + + Returns: + the percentage complete as a float, returning 0.0 if the total size of + the upload is unknown. + """ + if self.total_size is not None and self.total_size != 0: + return float(self.resumable_progress) / float(self.total_size) + else: + return 0.0 + + +class MediaDownloadProgress(object): + """Status of a resumable download.""" + + def __init__(self, resumable_progress, total_size): + """Constructor. + + Args: + resumable_progress: int, bytes received so far. + total_size: int, total bytes in complete download. + """ + self.resumable_progress = resumable_progress + self.total_size = total_size + + def progress(self): + """Percent of download completed, as a float. + + Returns: + the percentage complete as a float, returning 0.0 if the total size of + the download is unknown. + """ + if self.total_size is not None and self.total_size != 0: + return float(self.resumable_progress) / float(self.total_size) + else: + return 0.0 + + +class MediaUpload(object): + """Describes a media object to upload. + + Base class that defines the interface of MediaUpload subclasses. + + Note that subclasses of MediaUpload may allow you to control the chunksize + when uploading a media object. It is important to keep the size of the chunk + as large as possible to keep the upload efficient. Other factors may influence + the size of the chunk you use, particularly if you are working in an + environment where individual HTTP requests may have a hardcoded time limit, + such as under certain classes of requests under Google App Engine. + + Streams are io.Base compatible objects that support seek(). Some MediaUpload + subclasses support using streams directly to upload data. Support for + streaming may be indicated by a MediaUpload sub-class and if appropriate for a + platform that stream will be used for uploading the media object. The support + for streaming is indicated by has_stream() returning True. The stream() method + should return an io.Base object that supports seek(). On platforms where the + underlying httplib module supports streaming, for example Python 2.6 and + later, the stream will be passed into the http library which will result in + less memory being used and possibly faster uploads. + + If you need to upload media that can't be uploaded using any of the existing + MediaUpload sub-class then you can sub-class MediaUpload for your particular + needs. + """ + + def chunksize(self): + """Chunk size for resumable uploads. + + Returns: + Chunk size in bytes. + """ + raise NotImplementedError() + + def mimetype(self): + """Mime type of the body. + + Returns: + Mime type. + """ + return "application/octet-stream" + + def size(self): + """Size of upload. + + Returns: + Size of the body, or None of the size is unknown. + """ + return None + + def resumable(self): + """Whether this upload is resumable. + + Returns: + True if resumable upload or False. + """ + return False + + def getbytes(self, begin, end): + """Get bytes from the media. + + Args: + begin: int, offset from beginning of file. + length: int, number of bytes to read, starting at begin. + + Returns: + A string of bytes read. May be shorter than length if EOF was reached + first. + """ + raise NotImplementedError() + + def has_stream(self): + """Does the underlying upload support a streaming interface. + + Streaming means it is an io.IOBase subclass that supports seek, i.e. + seekable() returns True. + + Returns: + True if the call to stream() will return an instance of a seekable io.Base + subclass. + """ + return False + + def stream(self): + """A stream interface to the data being uploaded. + + Returns: + The returned value is an io.IOBase subclass that supports seek, i.e. + seekable() returns True. + """ + raise NotImplementedError() + + @util.positional(1) + def _to_json(self, strip=None): + """Utility function for creating a JSON representation of a MediaUpload. + + Args: + strip: array, An array of names of members to not include in the JSON. + + Returns: + string, a JSON representation of this instance, suitable to pass to + from_json(). + """ + t = type(self) + d = copy.copy(self.__dict__) + if strip is not None: + for member in strip: + del d[member] + d["_class"] = t.__name__ + d["_module"] = t.__module__ + return json.dumps(d) + + def to_json(self): + """Create a JSON representation of an instance of MediaUpload. + + Returns: + string, a JSON representation of this instance, suitable to pass to + from_json(). + """ + return self._to_json() + + @classmethod + def new_from_json(cls, s): + """Utility class method to instantiate a MediaUpload subclass from a JSON + representation produced by to_json(). + + Args: + s: string, JSON from to_json(). + + Returns: + An instance of the subclass of MediaUpload that was serialized with + to_json(). + """ + data = json.loads(s) + # Find and call the right classmethod from_json() to restore the object. + module = data["_module"] + m = __import__(module, fromlist=module.split(".")[:-1]) + kls = getattr(m, data["_class"]) + from_json = getattr(kls, "from_json") + return from_json(s) + + +class MediaIoBaseUpload(MediaUpload): + """A MediaUpload for a io.Base objects. + + Note that the Python file object is compatible with io.Base and can be used + with this class also. + + fh = BytesIO('...Some data to upload...') + media = MediaIoBaseUpload(fh, mimetype='image/png', + chunksize=1024*1024, resumable=True) + farm.animals().insert( + id='cow', + name='cow.png', + media_body=media).execute() + + Depending on the platform you are working on, you may pass -1 as the + chunksize, which indicates that the entire file should be uploaded in a single + request. If the underlying platform supports streams, such as Python 2.6 or + later, then this can be very efficient as it avoids multiple connections, and + also avoids loading the entire file into memory before sending it. Note that + Google App Engine has a 5MB limit on request size, so you should never set + your chunksize larger than 5MB, or to -1. + """ + + @util.positional(3) + def __init__(self, fd, mimetype, chunksize=DEFAULT_CHUNK_SIZE, resumable=False): + """Constructor. + + Args: + fd: io.Base or file object, The source of the bytes to upload. MUST be + opened in blocking mode, do not use streams opened in non-blocking mode. + The given stream must be seekable, that is, it must be able to call + seek() on fd. + mimetype: string, Mime-type of the file. + chunksize: int, File will be uploaded in chunks of this many bytes. Only + used if resumable=True. Pass in a value of -1 if the file is to be + uploaded as a single chunk. Note that Google App Engine has a 5MB limit + on request size, so you should never set your chunksize larger than 5MB, + or to -1. + resumable: bool, True if this is a resumable upload. False means upload + in a single request. + """ + super(MediaIoBaseUpload, self).__init__() + self._fd = fd + self._mimetype = mimetype + if not (chunksize == -1 or chunksize > 0): + raise InvalidChunkSizeError() + self._chunksize = chunksize + self._resumable = resumable + + self._fd.seek(0, os.SEEK_END) + self._size = self._fd.tell() + + def chunksize(self): + """Chunk size for resumable uploads. + + Returns: + Chunk size in bytes. + """ + return self._chunksize + + def mimetype(self): + """Mime type of the body. + + Returns: + Mime type. + """ + return self._mimetype + + def size(self): + """Size of upload. + + Returns: + Size of the body, or None of the size is unknown. + """ + return self._size + + def resumable(self): + """Whether this upload is resumable. + + Returns: + True if resumable upload or False. + """ + return self._resumable + + def getbytes(self, begin, length): + """Get bytes from the media. + + Args: + begin: int, offset from beginning of file. + length: int, number of bytes to read, starting at begin. + + Returns: + A string of bytes read. May be shorted than length if EOF was reached + first. + """ + self._fd.seek(begin) + return self._fd.read(length) + + def has_stream(self): + """Does the underlying upload support a streaming interface. + + Streaming means it is an io.IOBase subclass that supports seek, i.e. + seekable() returns True. + + Returns: + True if the call to stream() will return an instance of a seekable io.Base + subclass. + """ + return True + + def stream(self): + """A stream interface to the data being uploaded. + + Returns: + The returned value is an io.IOBase subclass that supports seek, i.e. + seekable() returns True. + """ + return self._fd + + def to_json(self): + """This upload type is not serializable.""" + raise NotImplementedError("MediaIoBaseUpload is not serializable.") + + +class MediaFileUpload(MediaIoBaseUpload): + """A MediaUpload for a file. + + Construct a MediaFileUpload and pass as the media_body parameter of the + method. For example, if we had a service that allowed uploading images: + + media = MediaFileUpload('cow.png', mimetype='image/png', + chunksize=1024*1024, resumable=True) + farm.animals().insert( + id='cow', + name='cow.png', + media_body=media).execute() + + Depending on the platform you are working on, you may pass -1 as the + chunksize, which indicates that the entire file should be uploaded in a single + request. If the underlying platform supports streams, such as Python 2.6 or + later, then this can be very efficient as it avoids multiple connections, and + also avoids loading the entire file into memory before sending it. Note that + Google App Engine has a 5MB limit on request size, so you should never set + your chunksize larger than 5MB, or to -1. + """ + + @util.positional(2) + def __init__( + self, filename, mimetype=None, chunksize=DEFAULT_CHUNK_SIZE, resumable=False + ): + """Constructor. + + Args: + filename: string, Name of the file. + mimetype: string, Mime-type of the file. If None then a mime-type will be + guessed from the file extension. + chunksize: int, File will be uploaded in chunks of this many bytes. Only + used if resumable=True. Pass in a value of -1 if the file is to be + uploaded in a single chunk. Note that Google App Engine has a 5MB limit + on request size, so you should never set your chunksize larger than 5MB, + or to -1. + resumable: bool, True if this is a resumable upload. False means upload + in a single request. + """ + self._fd = None + self._filename = filename + self._fd = open(self._filename, "rb") + if mimetype is None: + # No mimetype provided, make a guess. + mimetype, _ = mimetypes.guess_type(filename) + if mimetype is None: + # Guess failed, use octet-stream. + mimetype = "application/octet-stream" + super(MediaFileUpload, self).__init__( + self._fd, mimetype, chunksize=chunksize, resumable=resumable + ) + + def __del__(self): + if self._fd: + self._fd.close() + + def to_json(self): + """Creating a JSON representation of an instance of MediaFileUpload. + + Returns: + string, a JSON representation of this instance, suitable to pass to + from_json(). + """ + return self._to_json(strip=["_fd"]) + + @staticmethod + def from_json(s): + d = json.loads(s) + return MediaFileUpload( + d["_filename"], + mimetype=d["_mimetype"], + chunksize=d["_chunksize"], + resumable=d["_resumable"], + ) + + +class MediaInMemoryUpload(MediaIoBaseUpload): + """MediaUpload for a chunk of bytes. + + DEPRECATED: Use MediaIoBaseUpload with either io.TextIOBase or io.StringIO for + the stream. + """ + + @util.positional(2) + def __init__( + self, + body, + mimetype="application/octet-stream", + chunksize=DEFAULT_CHUNK_SIZE, + resumable=False, + ): + """Create a new MediaInMemoryUpload. + + DEPRECATED: Use MediaIoBaseUpload with either io.TextIOBase or io.StringIO for + the stream. + + Args: + body: string, Bytes of body content. + mimetype: string, Mime-type of the file or default of + 'application/octet-stream'. + chunksize: int, File will be uploaded in chunks of this many bytes. Only + used if resumable=True. + resumable: bool, True if this is a resumable upload. False means upload + in a single request. + """ + fd = io.BytesIO(body) + super(MediaInMemoryUpload, self).__init__( + fd, mimetype, chunksize=chunksize, resumable=resumable + ) + + +class MediaIoBaseDownload(object): + """ "Download media resources. + + Note that the Python file object is compatible with io.Base and can be used + with this class also. + + + Example: + request = farms.animals().get_media(id='cow') + fh = io.FileIO('cow.png', mode='wb') + downloader = MediaIoBaseDownload(fh, request, chunksize=1024*1024) + + done = False + while done is False: + status, done = downloader.next_chunk() + if status: + print "Download %d%%." % int(status.progress() * 100) + print "Download Complete!" + """ + + @util.positional(3) + def __init__(self, fd, request, chunksize=DEFAULT_CHUNK_SIZE): + """Constructor. + + Args: + fd: io.Base or file object, The stream in which to write the downloaded + bytes. + request: googleapiclient.http.HttpRequest, the media request to perform in + chunks. + chunksize: int, File will be downloaded in chunks of this many bytes. + """ + self._fd = fd + self._request = request + self._uri = request.uri + self._chunksize = chunksize + self._progress = 0 + self._total_size = None + self._done = False + + # Stubs for testing. + self._sleep = time.sleep + self._rand = random.random + + self._headers = {} + for k, v in request.headers.items(): + # allow users to supply custom headers by setting them on the request + # but strip out the ones that are set by default on requests generated by + # API methods like Drive's files().get(fileId=...) + if not k.lower() in ("accept", "accept-encoding", "user-agent"): + self._headers[k] = v + + @util.positional(1) + def next_chunk(self, num_retries=0): + """Get the next chunk of the download. + + Args: + num_retries: Integer, number of times to retry with randomized + exponential backoff. If all retries fail, the raised HttpError + represents the last request. If zero (default), we attempt the + request only once. + + Returns: + (status, done): (MediaDownloadProgress, boolean) + The value of 'done' will be True when the media has been fully + downloaded or the total size of the media is unknown. + + Raises: + googleapiclient.errors.HttpError if the response was not a 2xx. + httplib2.HttpLib2Error if a transport error has occurred. + """ + headers = self._headers.copy() + headers["range"] = "bytes=%d-%d" % ( + self._progress, + self._progress + self._chunksize - 1, + ) + http = self._request.http + + resp, content = _retry_request( + http, + num_retries, + "media download", + self._sleep, + self._rand, + self._uri, + "GET", + headers=headers, + ) + + if resp.status in [200, 206]: + if "content-location" in resp and resp["content-location"] != self._uri: + self._uri = resp["content-location"] + self._progress += len(content) + self._fd.write(content) + + if "content-range" in resp: + content_range = resp["content-range"] + length = content_range.rsplit("/", 1)[1] + self._total_size = int(length) + elif "content-length" in resp: + self._total_size = int(resp["content-length"]) + + if self._total_size is None or self._progress == self._total_size: + self._done = True + return MediaDownloadProgress(self._progress, self._total_size), self._done + elif resp.status == 416: + # 416 is Range Not Satisfiable + # This typically occurs with a zero byte file + content_range = resp["content-range"] + length = content_range.rsplit("/", 1)[1] + self._total_size = int(length) + if self._total_size == 0: + self._done = True + return ( + MediaDownloadProgress(self._progress, self._total_size), + self._done, + ) + raise HttpError(resp, content, uri=self._uri) + + +class _StreamSlice(object): + """Truncated stream. + + Takes a stream and presents a stream that is a slice of the original stream. + This is used when uploading media in chunks. In later versions of Python a + stream can be passed to httplib in place of the string of data to send. The + problem is that httplib just blindly reads to the end of the stream. This + wrapper presents a virtual stream that only reads to the end of the chunk. + """ + + def __init__(self, stream, begin, chunksize): + """Constructor. + + Args: + stream: (io.Base, file object), the stream to wrap. + begin: int, the seek position the chunk begins at. + chunksize: int, the size of the chunk. + """ + self._stream = stream + self._begin = begin + self._chunksize = chunksize + self._stream.seek(begin) + + def read(self, n=-1): + """Read n bytes. + + Args: + n, int, the number of bytes to read. + + Returns: + A string of length 'n', or less if EOF is reached. + """ + # The data left available to read sits in [cur, end) + cur = self._stream.tell() + end = self._begin + self._chunksize + if n == -1 or cur + n > end: + n = end - cur + return self._stream.read(n) + + +class HttpRequest(object): + """Encapsulates a single HTTP request.""" + + @util.positional(4) + def __init__( + self, + http, + postproc, + uri, + method="GET", + body=None, + headers=None, + methodId=None, + resumable=None, + ): + """Constructor for an HttpRequest. + + Args: + http: httplib2.Http, the transport object to use to make a request + postproc: callable, called on the HTTP response and content to transform + it into a data object before returning, or raising an exception + on an error. + uri: string, the absolute URI to send the request to + method: string, the HTTP method to use + body: string, the request body of the HTTP request, + headers: dict, the HTTP request headers + methodId: string, a unique identifier for the API method being called. + resumable: MediaUpload, None if this is not a resumbale request. + """ + self.uri = uri + self.method = method + self.body = body + self.headers = headers or {} + self.methodId = methodId + self.http = http + self.postproc = postproc + self.resumable = resumable + self.response_callbacks = [] + self._in_error_state = False + + # The size of the non-media part of the request. + self.body_size = len(self.body or "") + + # The resumable URI to send chunks to. + self.resumable_uri = None + + # The bytes that have been uploaded. + self.resumable_progress = 0 + + # Stubs for testing. + self._rand = random.random + self._sleep = time.sleep + + @util.positional(1) + def execute(self, http=None, num_retries=0): + """Execute the request. + + Args: + http: httplib2.Http, an http object to be used in place of the + one the HttpRequest request object was constructed with. + num_retries: Integer, number of times to retry with randomized + exponential backoff. If all retries fail, the raised HttpError + represents the last request. If zero (default), we attempt the + request only once. + + Returns: + A deserialized object model of the response body as determined + by the postproc. + + Raises: + googleapiclient.errors.HttpError if the response was not a 2xx. + httplib2.HttpLib2Error if a transport error has occurred. + """ + if http is None: + http = self.http + + if self.resumable: + body = None + while body is None: + _, body = self.next_chunk(http=http, num_retries=num_retries) + return body + + # Non-resumable case. + + if "content-length" not in self.headers: + self.headers["content-length"] = str(self.body_size) + # If the request URI is too long then turn it into a POST request. + # Assume that a GET request never contains a request body. + if len(self.uri) > MAX_URI_LENGTH and self.method == "GET": + self.method = "POST" + self.headers["x-http-method-override"] = "GET" + self.headers["content-type"] = "application/x-www-form-urlencoded" + parsed = urllib.parse.urlparse(self.uri) + self.uri = urllib.parse.urlunparse( + (parsed.scheme, parsed.netloc, parsed.path, parsed.params, None, None) + ) + self.body = parsed.query + self.headers["content-length"] = str(len(self.body)) + + # Handle retries for server-side errors. + resp, content = _retry_request( + http, + num_retries, + "request", + self._sleep, + self._rand, + str(self.uri), + method=str(self.method), + body=self.body, + headers=self.headers, + ) + + for callback in self.response_callbacks: + callback(resp) + if resp.status >= 300: + raise HttpError(resp, content, uri=self.uri) + return self.postproc(resp, content) + + @util.positional(2) + def add_response_callback(self, cb): + """add_response_headers_callback + + Args: + cb: Callback to be called on receiving the response headers, of signature: + + def cb(resp): + # Where resp is an instance of httplib2.Response + """ + self.response_callbacks.append(cb) + + @util.positional(1) + def next_chunk(self, http=None, num_retries=0): + """Execute the next step of a resumable upload. + + Can only be used if the method being executed supports media uploads and + the MediaUpload object passed in was flagged as using resumable upload. + + Example: + + media = MediaFileUpload('cow.png', mimetype='image/png', + chunksize=1000, resumable=True) + request = farm.animals().insert( + id='cow', + name='cow.png', + media_body=media) + + response = None + while response is None: + status, response = request.next_chunk() + if status: + print "Upload %d%% complete." % int(status.progress() * 100) + + + Args: + http: httplib2.Http, an http object to be used in place of the + one the HttpRequest request object was constructed with. + num_retries: Integer, number of times to retry with randomized + exponential backoff. If all retries fail, the raised HttpError + represents the last request. If zero (default), we attempt the + request only once. + + Returns: + (status, body): (ResumableMediaStatus, object) + The body will be None until the resumable media is fully uploaded. + + Raises: + googleapiclient.errors.HttpError if the response was not a 2xx. + httplib2.HttpLib2Error if a transport error has occurred. + """ + if http is None: + http = self.http + + if self.resumable.size() is None: + size = "*" + else: + size = str(self.resumable.size()) + + if self.resumable_uri is None: + start_headers = copy.copy(self.headers) + start_headers["X-Upload-Content-Type"] = self.resumable.mimetype() + if size != "*": + start_headers["X-Upload-Content-Length"] = size + start_headers["content-length"] = str(self.body_size) + + resp, content = _retry_request( + http, + num_retries, + "resumable URI request", + self._sleep, + self._rand, + self.uri, + method=self.method, + body=self.body, + headers=start_headers, + ) + + if resp.status == 200 and "location" in resp: + self.resumable_uri = resp["location"] + else: + raise ResumableUploadError(resp, content) + elif self._in_error_state: + # If we are in an error state then query the server for current state of + # the upload by sending an empty PUT and reading the 'range' header in + # the response. + headers = {"Content-Range": "bytes */%s" % size, "content-length": "0"} + resp, content = http.request(self.resumable_uri, "PUT", headers=headers) + status, body = self._process_response(resp, content) + if body: + # The upload was complete. + return (status, body) + + if self.resumable.has_stream(): + data = self.resumable.stream() + if self.resumable.chunksize() == -1: + data.seek(self.resumable_progress) + chunk_end = self.resumable.size() - self.resumable_progress - 1 + else: + # Doing chunking with a stream, so wrap a slice of the stream. + data = _StreamSlice( + data, self.resumable_progress, self.resumable.chunksize() + ) + chunk_end = min( + self.resumable_progress + self.resumable.chunksize() - 1, + self.resumable.size() - 1, + ) + else: + data = self.resumable.getbytes( + self.resumable_progress, self.resumable.chunksize() + ) + + # A short read implies that we are at EOF, so finish the upload. + if len(data) < self.resumable.chunksize(): + size = str(self.resumable_progress + len(data)) + + chunk_end = self.resumable_progress + len(data) - 1 + + headers = { + # Must set the content-length header here because httplib can't + # calculate the size when working with _StreamSlice. + "Content-Length": str(chunk_end - self.resumable_progress + 1), + } + + # An empty file results in chunk_end = -1 and size = 0 + # sending "bytes 0--1/0" results in an invalid request + # Only add header "Content-Range" if chunk_end != -1 + if chunk_end != -1: + headers["Content-Range"] = "bytes %d-%d/%s" % ( + self.resumable_progress, + chunk_end, + size, + ) + + for retry_num in range(num_retries + 1): + if retry_num > 0: + self._sleep(self._rand() * 2**retry_num) + LOGGER.warning( + "Retry #%d for media upload: %s %s, following status: %d" + % (retry_num, self.method, self.uri, resp.status) + ) + + try: + resp, content = http.request( + self.resumable_uri, method="PUT", body=data, headers=headers + ) + except: + self._in_error_state = True + raise + if not _should_retry_response(resp.status, content): + break + + return self._process_response(resp, content) + + def _process_response(self, resp, content): + """Process the response from a single chunk upload. + + Args: + resp: httplib2.Response, the response object. + content: string, the content of the response. + + Returns: + (status, body): (ResumableMediaStatus, object) + The body will be None until the resumable media is fully uploaded. + + Raises: + googleapiclient.errors.HttpError if the response was not a 2xx or a 308. + """ + if resp.status in [200, 201]: + self._in_error_state = False + return None, self.postproc(resp, content) + elif resp.status == 308: + self._in_error_state = False + # A "308 Resume Incomplete" indicates we are not done. + try: + self.resumable_progress = int(resp["range"].split("-")[1]) + 1 + except KeyError: + # If resp doesn't contain range header, resumable progress is 0 + self.resumable_progress = 0 + if "location" in resp: + self.resumable_uri = resp["location"] + else: + self._in_error_state = True + raise HttpError(resp, content, uri=self.uri) + + return ( + MediaUploadProgress(self.resumable_progress, self.resumable.size()), + None, + ) + + def to_json(self): + """Returns a JSON representation of the HttpRequest.""" + d = copy.copy(self.__dict__) + if d["resumable"] is not None: + d["resumable"] = self.resumable.to_json() + del d["http"] + del d["postproc"] + del d["_sleep"] + del d["_rand"] + + return json.dumps(d) + + @staticmethod + def from_json(s, http, postproc): + """Returns an HttpRequest populated with info from a JSON object.""" + d = json.loads(s) + if d["resumable"] is not None: + d["resumable"] = MediaUpload.new_from_json(d["resumable"]) + return HttpRequest( + http, + postproc, + uri=d["uri"], + method=d["method"], + body=d["body"], + headers=d["headers"], + methodId=d["methodId"], + resumable=d["resumable"], + ) + + @staticmethod + def null_postproc(resp, contents): + return resp, contents + + +class BatchHttpRequest(object): + """Batches multiple HttpRequest objects into a single HTTP request. + + Example: + from googleapiclient.http import BatchHttpRequest + + def list_animals(request_id, response, exception): + \"\"\"Do something with the animals list response.\"\"\" + if exception is not None: + # Do something with the exception. + pass + else: + # Do something with the response. + pass + + def list_farmers(request_id, response, exception): + \"\"\"Do something with the farmers list response.\"\"\" + if exception is not None: + # Do something with the exception. + pass + else: + # Do something with the response. + pass + + service = build('farm', 'v2') + + batch = BatchHttpRequest() + + batch.add(service.animals().list(), list_animals) + batch.add(service.farmers().list(), list_farmers) + batch.execute(http=http) + """ + + @util.positional(1) + def __init__(self, callback=None, batch_uri=None): + """Constructor for a BatchHttpRequest. + + Args: + callback: callable, A callback to be called for each response, of the + form callback(id, response, exception). The first parameter is the + request id, and the second is the deserialized response object. The + third is an googleapiclient.errors.HttpError exception object if an HTTP error + occurred while processing the request, or None if no error occurred. + batch_uri: string, URI to send batch requests to. + """ + if batch_uri is None: + batch_uri = _LEGACY_BATCH_URI + + if batch_uri == _LEGACY_BATCH_URI: + LOGGER.warning( + "You have constructed a BatchHttpRequest using the legacy batch " + "endpoint %s. This endpoint will be turned down on August 12, 2020. " + "Please provide the API-specific endpoint or use " + "service.new_batch_http_request(). For more details see " + "https://developers.googleblog.com/2018/03/discontinuing-support-for-json-rpc-and.html" + "and https://developers.google.com/api-client-library/python/guide/batch.", + _LEGACY_BATCH_URI, + ) + self._batch_uri = batch_uri + + # Global callback to be called for each individual response in the batch. + self._callback = callback + + # A map from id to request. + self._requests = {} + + # A map from id to callback. + self._callbacks = {} + + # List of request ids, in the order in which they were added. + self._order = [] + + # The last auto generated id. + self._last_auto_id = 0 + + # Unique ID on which to base the Content-ID headers. + self._base_id = None + + # A map from request id to (httplib2.Response, content) response pairs + self._responses = {} + + # A map of id(Credentials) that have been refreshed. + self._refreshed_credentials = {} + + def _refresh_and_apply_credentials(self, request, http): + """Refresh the credentials and apply to the request. + + Args: + request: HttpRequest, the request. + http: httplib2.Http, the global http object for the batch. + """ + # For the credentials to refresh, but only once per refresh_token + # If there is no http per the request then refresh the http passed in + # via execute() + creds = None + request_credentials = False + + if request.http is not None: + creds = _auth.get_credentials_from_http(request.http) + request_credentials = True + + if creds is None and http is not None: + creds = _auth.get_credentials_from_http(http) + + if creds is not None: + if id(creds) not in self._refreshed_credentials: + _auth.refresh_credentials(creds) + self._refreshed_credentials[id(creds)] = 1 + + # Only apply the credentials if we are using the http object passed in, + # otherwise apply() will get called during _serialize_request(). + if request.http is None or not request_credentials: + _auth.apply_credentials(creds, request.headers) + + def _id_to_header(self, id_): + """Convert an id to a Content-ID header value. + + Args: + id_: string, identifier of individual request. + + Returns: + A Content-ID header with the id_ encoded into it. A UUID is prepended to + the value because Content-ID headers are supposed to be universally + unique. + """ + if self._base_id is None: + self._base_id = uuid.uuid4() + + # NB: we intentionally leave whitespace between base/id and '+', so RFC2822 + # line folding works properly on Python 3; see + # https://github.com/googleapis/google-api-python-client/issues/164 + return "<%s + %s>" % (self._base_id, urllib.parse.quote(id_)) + + def _header_to_id(self, header): + """Convert a Content-ID header value to an id. + + Presumes the Content-ID header conforms to the format that _id_to_header() + returns. + + Args: + header: string, Content-ID header value. + + Returns: + The extracted id value. + + Raises: + BatchError if the header is not in the expected format. + """ + if header[0] != "<" or header[-1] != ">": + raise BatchError("Invalid value for Content-ID: %s" % header) + if "+" not in header: + raise BatchError("Invalid value for Content-ID: %s" % header) + base, id_ = header[1:-1].split(" + ", 1) + + return urllib.parse.unquote(id_) + + def _serialize_request(self, request): + """Convert an HttpRequest object into a string. + + Args: + request: HttpRequest, the request to serialize. + + Returns: + The request as a string in application/http format. + """ + # Construct status line + parsed = urllib.parse.urlparse(request.uri) + request_line = urllib.parse.urlunparse( + ("", "", parsed.path, parsed.params, parsed.query, "") + ) + status_line = request.method + " " + request_line + " HTTP/1.1\n" + major, minor = request.headers.get("content-type", "application/json").split( + "/" + ) + msg = MIMENonMultipart(major, minor) + headers = request.headers.copy() + + if request.http is not None: + credentials = _auth.get_credentials_from_http(request.http) + if credentials is not None: + _auth.apply_credentials(credentials, headers) + + # MIMENonMultipart adds its own Content-Type header. + if "content-type" in headers: + del headers["content-type"] + + for key, value in headers.items(): + msg[key] = value + msg["Host"] = parsed.netloc + msg.set_unixfrom(None) + + if request.body is not None: + msg.set_payload(request.body) + msg["content-length"] = str(len(request.body)) + + # Serialize the mime message. + fp = io.StringIO() + # maxheaderlen=0 means don't line wrap headers. + g = Generator(fp, maxheaderlen=0) + g.flatten(msg, unixfrom=False) + body = fp.getvalue() + + return status_line + body + + def _deserialize_response(self, payload): + """Convert string into httplib2 response and content. + + Args: + payload: string, headers and body as a string. + + Returns: + A pair (resp, content), such as would be returned from httplib2.request. + """ + # Strip off the status line + status_line, payload = payload.split("\n", 1) + protocol, status, reason = status_line.split(" ", 2) + + # Parse the rest of the response + parser = FeedParser() + parser.feed(payload) + msg = parser.close() + msg["status"] = status + + # Create httplib2.Response from the parsed headers. + resp = httplib2.Response(msg) + resp.reason = reason + resp.version = int(protocol.split("/", 1)[1].replace(".", "")) + + content = payload.split("\r\n\r\n", 1)[1] + + return resp, content + + def _new_id(self): + """Create a new id. + + Auto incrementing number that avoids conflicts with ids already used. + + Returns: + string, a new unique id. + """ + self._last_auto_id += 1 + while str(self._last_auto_id) in self._requests: + self._last_auto_id += 1 + return str(self._last_auto_id) + + @util.positional(2) + def add(self, request, callback=None, request_id=None): + """Add a new request. + + Every callback added will be paired with a unique id, the request_id. That + unique id will be passed back to the callback when the response comes back + from the server. The default behavior is to have the library generate it's + own unique id. If the caller passes in a request_id then they must ensure + uniqueness for each request_id, and if they are not an exception is + raised. Callers should either supply all request_ids or never supply a + request id, to avoid such an error. + + Args: + request: HttpRequest, Request to add to the batch. + callback: callable, A callback to be called for this response, of the + form callback(id, response, exception). The first parameter is the + request id, and the second is the deserialized response object. The + third is an googleapiclient.errors.HttpError exception object if an HTTP error + occurred while processing the request, or None if no errors occurred. + request_id: string, A unique id for the request. The id will be passed + to the callback with the response. + + Returns: + None + + Raises: + BatchError if a media request is added to a batch. + KeyError is the request_id is not unique. + """ + + if len(self._order) >= MAX_BATCH_LIMIT: + raise BatchError( + "Exceeded the maximum calls(%d) in a single batch request." + % MAX_BATCH_LIMIT + ) + if request_id is None: + request_id = self._new_id() + if request.resumable is not None: + raise BatchError("Media requests cannot be used in a batch request.") + if request_id in self._requests: + raise KeyError("A request with this ID already exists: %s" % request_id) + self._requests[request_id] = request + self._callbacks[request_id] = callback + self._order.append(request_id) + + def _execute(self, http, order, requests): + """Serialize batch request, send to server, process response. + + Args: + http: httplib2.Http, an http object to be used to make the request with. + order: list, list of request ids in the order they were added to the + batch. + requests: list, list of request objects to send. + + Raises: + httplib2.HttpLib2Error if a transport error has occurred. + googleapiclient.errors.BatchError if the response is the wrong format. + """ + message = MIMEMultipart("mixed") + # Message should not write out it's own headers. + setattr(message, "_write_headers", lambda self: None) + + # Add all the individual requests. + for request_id in order: + request = requests[request_id] + + msg = MIMENonMultipart("application", "http") + msg["Content-Transfer-Encoding"] = "binary" + msg["Content-ID"] = self._id_to_header(request_id) + + body = self._serialize_request(request) + msg.set_payload(body) + message.attach(msg) + + # encode the body: note that we can't use `as_string`, because + # it plays games with `From ` lines. + fp = io.StringIO() + g = Generator(fp, mangle_from_=False) + g.flatten(message, unixfrom=False) + body = fp.getvalue() + + headers = {} + headers["content-type"] = ( + "multipart/mixed; " 'boundary="%s"' + ) % message.get_boundary() + + resp, content = http.request( + self._batch_uri, method="POST", body=body, headers=headers + ) + + if resp.status >= 300: + raise HttpError(resp, content, uri=self._batch_uri) + + # Prepend with a content-type header so FeedParser can handle it. + header = "content-type: %s\r\n\r\n" % resp["content-type"] + # PY3's FeedParser only accepts unicode. So we should decode content + # here, and encode each payload again. + content = content.decode("utf-8") + for_parser = header + content + + parser = FeedParser() + parser.feed(for_parser) + mime_response = parser.close() + + if not mime_response.is_multipart(): + raise BatchError( + "Response not in multipart/mixed format.", resp=resp, content=content + ) + + for part in mime_response.get_payload(): + request_id = self._header_to_id(part["Content-ID"]) + response, content = self._deserialize_response(part.get_payload()) + # We encode content here to emulate normal http response. + if isinstance(content, str): + content = content.encode("utf-8") + self._responses[request_id] = (response, content) + + @util.positional(1) + def execute(self, http=None): + """Execute all the requests as a single batched HTTP request. + + Args: + http: httplib2.Http, an http object to be used in place of the one the + HttpRequest request object was constructed with. If one isn't supplied + then use a http object from the requests in this batch. + + Returns: + None + + Raises: + httplib2.HttpLib2Error if a transport error has occurred. + googleapiclient.errors.BatchError if the response is the wrong format. + """ + # If we have no requests return + if len(self._order) == 0: + return None + + # If http is not supplied use the first valid one given in the requests. + if http is None: + for request_id in self._order: + request = self._requests[request_id] + if request is not None: + http = request.http + break + + if http is None: + raise ValueError("Missing a valid http object.") + + # Special case for OAuth2Credentials-style objects which have not yet been + # refreshed with an initial access_token. + creds = _auth.get_credentials_from_http(http) + if creds is not None: + if not _auth.is_valid(creds): + LOGGER.info("Attempting refresh to obtain initial access_token") + _auth.refresh_credentials(creds) + + self._execute(http, self._order, self._requests) + + # Loop over all the requests and check for 401s. For each 401 request the + # credentials should be refreshed and then sent again in a separate batch. + redo_requests = {} + redo_order = [] + + for request_id in self._order: + resp, content = self._responses[request_id] + if resp["status"] == "401": + redo_order.append(request_id) + request = self._requests[request_id] + self._refresh_and_apply_credentials(request, http) + redo_requests[request_id] = request + + if redo_requests: + self._execute(http, redo_order, redo_requests) + + # Now process all callbacks that are erroring, and raise an exception for + # ones that return a non-2xx response? Or add extra parameter to callback + # that contains an HttpError? + + for request_id in self._order: + resp, content = self._responses[request_id] + + request = self._requests[request_id] + callback = self._callbacks[request_id] + + response = None + exception = None + try: + if resp.status >= 300: + raise HttpError(resp, content, uri=request.uri) + response = request.postproc(resp, content) + except HttpError as e: + exception = e + + if callback is not None: + callback(request_id, response, exception) + if self._callback is not None: + self._callback(request_id, response, exception) + + +class HttpRequestMock(object): + """Mock of HttpRequest. + + Do not construct directly, instead use RequestMockBuilder. + """ + + def __init__(self, resp, content, postproc): + """Constructor for HttpRequestMock + + Args: + resp: httplib2.Response, the response to emulate coming from the request + content: string, the response body + postproc: callable, the post processing function usually supplied by + the model class. See model.JsonModel.response() as an example. + """ + self.resp = resp + self.content = content + self.postproc = postproc + if resp is None: + self.resp = httplib2.Response({"status": 200, "reason": "OK"}) + if "reason" in self.resp: + self.resp.reason = self.resp["reason"] + + def execute(self, http=None): + """Execute the request. + + Same behavior as HttpRequest.execute(), but the response is + mocked and not really from an HTTP request/response. + """ + return self.postproc(self.resp, self.content) + + +class RequestMockBuilder(object): + """A simple mock of HttpRequest + + Pass in a dictionary to the constructor that maps request methodIds to + tuples of (httplib2.Response, content, opt_expected_body) that should be + returned when that method is called. None may also be passed in for the + httplib2.Response, in which case a 200 OK response will be generated. + If an opt_expected_body (str or dict) is provided, it will be compared to + the body and UnexpectedBodyError will be raised on inequality. + + Example: + response = '{"data": {"id": "tag:google.c...' + requestBuilder = RequestMockBuilder( + { + 'plus.activities.get': (None, response), + } + ) + googleapiclient.discovery.build("plus", "v1", requestBuilder=requestBuilder) + + Methods that you do not supply a response for will return a + 200 OK with an empty string as the response content or raise an excpetion + if check_unexpected is set to True. The methodId is taken from the rpcName + in the discovery document. + + For more details see the project wiki. + """ + + def __init__(self, responses, check_unexpected=False): + """Constructor for RequestMockBuilder + + The constructed object should be a callable object + that can replace the class HttpResponse. + + responses - A dictionary that maps methodIds into tuples + of (httplib2.Response, content). The methodId + comes from the 'rpcName' field in the discovery + document. + check_unexpected - A boolean setting whether or not UnexpectedMethodError + should be raised on unsupplied method. + """ + self.responses = responses + self.check_unexpected = check_unexpected + + def __call__( + self, + http, + postproc, + uri, + method="GET", + body=None, + headers=None, + methodId=None, + resumable=None, + ): + """Implements the callable interface that discovery.build() expects + of requestBuilder, which is to build an object compatible with + HttpRequest.execute(). See that method for the description of the + parameters and the expected response. + """ + if methodId in self.responses: + response = self.responses[methodId] + resp, content = response[:2] + if len(response) > 2: + # Test the body against the supplied expected_body. + expected_body = response[2] + if bool(expected_body) != bool(body): + # Not expecting a body and provided one + # or expecting a body and not provided one. + raise UnexpectedBodyError(expected_body, body) + if isinstance(expected_body, str): + expected_body = json.loads(expected_body) + body = json.loads(body) + if body != expected_body: + raise UnexpectedBodyError(expected_body, body) + return HttpRequestMock(resp, content, postproc) + elif self.check_unexpected: + raise UnexpectedMethodError(methodId=methodId) + else: + model = JsonModel(False) + return HttpRequestMock(None, "{}", model.response) + + +class HttpMock(object): + """Mock of httplib2.Http""" + + def __init__(self, filename=None, headers=None): + """ + Args: + filename: string, absolute filename to read response from + headers: dict, header to return with response + """ + if headers is None: + headers = {"status": "200"} + if filename: + with open(filename, "rb") as f: + self.data = f.read() + else: + self.data = None + self.response_headers = headers + self.headers = None + self.uri = None + self.method = None + self.body = None + self.headers = None + + def request( + self, + uri, + method="GET", + body=None, + headers=None, + redirections=1, + connection_type=None, + ): + self.uri = uri + self.method = method + self.body = body + self.headers = headers + return httplib2.Response(self.response_headers), self.data + + def close(self): + return None + + +class HttpMockSequence(object): + """Mock of httplib2.Http + + Mocks a sequence of calls to request returning different responses for each + call. Create an instance initialized with the desired response headers + and content and then use as if an httplib2.Http instance. + + http = HttpMockSequence([ + ({'status': '401'}, ''), + ({'status': '200'}, '{"access_token":"1/3w","expires_in":3600}'), + ({'status': '200'}, 'echo_request_headers'), + ]) + resp, content = http.request("http://examples.com") + + There are special values you can pass in for content to trigger + behavours that are helpful in testing. + + 'echo_request_headers' means return the request headers in the response body + 'echo_request_headers_as_json' means return the request headers in + the response body + 'echo_request_body' means return the request body in the response body + 'echo_request_uri' means return the request uri in the response body + """ + + def __init__(self, iterable): + """ + Args: + iterable: iterable, a sequence of pairs of (headers, body) + """ + self._iterable = iterable + self.follow_redirects = True + self.request_sequence = list() + + def request( + self, + uri, + method="GET", + body=None, + headers=None, + redirections=1, + connection_type=None, + ): + # Remember the request so after the fact this mock can be examined + self.request_sequence.append((uri, method, body, headers)) + resp, content = self._iterable.pop(0) + if isinstance(content, str): + content = content.encode("utf-8") + + if content == b"echo_request_headers": + content = headers + elif content == b"echo_request_headers_as_json": + content = json.dumps(headers) + elif content == b"echo_request_body": + if hasattr(body, "read"): + content = body.read() + else: + content = body + elif content == b"echo_request_uri": + content = uri + if isinstance(content, str): + content = content.encode("utf-8") + return httplib2.Response(resp), content + + +def set_user_agent(http, user_agent): + """Set the user-agent on every request. + + Args: + http - An instance of httplib2.Http + or something that acts like it. + user_agent: string, the value for the user-agent header. + + Returns: + A modified instance of http that was passed in. + + Example: + + h = httplib2.Http() + h = set_user_agent(h, "my-app-name/6.0") + + Most of the time the user-agent will be set doing auth, this is for the rare + cases where you are accessing an unauthenticated endpoint. + """ + request_orig = http.request + + # The closure that will replace 'httplib2.Http.request'. + def new_request( + uri, + method="GET", + body=None, + headers=None, + redirections=httplib2.DEFAULT_MAX_REDIRECTS, + connection_type=None, + ): + """Modify the request headers to add the user-agent.""" + if headers is None: + headers = {} + if "user-agent" in headers: + headers["user-agent"] = user_agent + " " + headers["user-agent"] + else: + headers["user-agent"] = user_agent + resp, content = request_orig( + uri, + method=method, + body=body, + headers=headers, + redirections=redirections, + connection_type=connection_type, + ) + return resp, content + + http.request = new_request + return http + + +def tunnel_patch(http): + """Tunnel PATCH requests over POST. + Args: + http - An instance of httplib2.Http + or something that acts like it. + + Returns: + A modified instance of http that was passed in. + + Example: + + h = httplib2.Http() + h = tunnel_patch(h, "my-app-name/6.0") + + Useful if you are running on a platform that doesn't support PATCH. + Apply this last if you are using OAuth 1.0, as changing the method + will result in a different signature. + """ + request_orig = http.request + + # The closure that will replace 'httplib2.Http.request'. + def new_request( + uri, + method="GET", + body=None, + headers=None, + redirections=httplib2.DEFAULT_MAX_REDIRECTS, + connection_type=None, + ): + """Modify the request headers to add the user-agent.""" + if headers is None: + headers = {} + if method == "PATCH": + if "oauth_token" in headers.get("authorization", ""): + LOGGER.warning( + "OAuth 1.0 request made with Credentials after tunnel_patch." + ) + headers["x-http-method-override"] = "PATCH" + method = "POST" + resp, content = request_orig( + uri, + method=method, + body=body, + headers=headers, + redirections=redirections, + connection_type=connection_type, + ) + return resp, content + + http.request = new_request + return http + + +def build_http(): + """Builds httplib2.Http object + + Returns: + A httplib2.Http object, which is used to make http requests, and which has timeout set by default. + To override default timeout call + + socket.setdefaulttimeout(timeout_in_sec) + + before interacting with this method. + """ + if socket.getdefaulttimeout() is not None: + http_timeout = socket.getdefaulttimeout() + else: + http_timeout = DEFAULT_HTTP_TIMEOUT_SEC + http = httplib2.Http(timeout=http_timeout) + # 308's are used by several Google APIs (Drive, YouTube) + # for Resumable Uploads rather than Permanent Redirects. + # This asks httplib2 to exclude 308s from the status codes + # it treats as redirects + try: + http.redirect_codes = http.redirect_codes - {308} + except AttributeError: + # Apache Beam tests depend on this library and cannot + # currently upgrade their httplib2 version + # http.redirect_codes does not exist in previous versions + # of httplib2, so pass + pass + + return http diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/mimeparse.py b/.venv/lib/python3.11/site-packages/googleapiclient/mimeparse.py new file mode 100644 index 0000000000000000000000000000000000000000..d3dedee9c53370e9ba67f252d34a7e0cccd2a244 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/mimeparse.py @@ -0,0 +1,183 @@ +# Copyright 2014 Joe Gregorio +# +# Licensed under the MIT License + +"""MIME-Type Parser + +This module provides basic functions for handling mime-types. It can handle +matching mime-types against a list of media-ranges. See section 14.1 of the +HTTP specification [RFC 2616] for a complete explanation. + + http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1 + +Contents: + - parse_mime_type(): Parses a mime-type into its component parts. + - parse_media_range(): Media-ranges are mime-types with wild-cards and a 'q' + quality parameter. + - quality(): Determines the quality ('q') of a mime-type when + compared against a list of media-ranges. + - quality_parsed(): Just like quality() except the second parameter must be + pre-parsed. + - best_match(): Choose the mime-type with the highest quality ('q') + from a list of candidates. +""" +from __future__ import absolute_import + +from functools import reduce + +__version__ = "0.1.3" +__author__ = "Joe Gregorio" +__email__ = "joe@bitworking.org" +__license__ = "MIT License" +__credits__ = "" + + +def parse_mime_type(mime_type): + """Parses a mime-type into its component parts. + + Carves up a mime-type and returns a tuple of the (type, subtype, params) + where 'params' is a dictionary of all the parameters for the media range. + For example, the media range 'application/xhtml;q=0.5' would get parsed + into: + + ('application', 'xhtml', {'q', '0.5'}) + """ + parts = mime_type.split(";") + params = dict( + [tuple([s.strip() for s in param.split("=", 1)]) for param in parts[1:]] + ) + full_type = parts[0].strip() + # Java URLConnection class sends an Accept header that includes a + # single '*'. Turn it into a legal wildcard. + if full_type == "*": + full_type = "*/*" + (type, subtype) = full_type.split("/") + + return (type.strip(), subtype.strip(), params) + + +def parse_media_range(range): + """Parse a media-range into its component parts. + + Carves up a media range and returns a tuple of the (type, subtype, + params) where 'params' is a dictionary of all the parameters for the media + range. For example, the media range 'application/*;q=0.5' would get parsed + into: + + ('application', '*', {'q', '0.5'}) + + In addition this function also guarantees that there is a value for 'q' + in the params dictionary, filling it in with a proper default if + necessary. + """ + (type, subtype, params) = parse_mime_type(range) + if ( + "q" not in params + or not params["q"] + or not float(params["q"]) + or float(params["q"]) > 1 + or float(params["q"]) < 0 + ): + params["q"] = "1" + + return (type, subtype, params) + + +def fitness_and_quality_parsed(mime_type, parsed_ranges): + """Find the best match for a mime-type amongst parsed media-ranges. + + Find the best match for a given mime-type against a list of media_ranges + that have already been parsed by parse_media_range(). Returns a tuple of + the fitness value and the value of the 'q' quality parameter of the best + match, or (-1, 0) if no match was found. Just as for quality_parsed(), + 'parsed_ranges' must be a list of parsed media ranges. + """ + best_fitness = -1 + best_fit_q = 0 + (target_type, target_subtype, target_params) = parse_media_range(mime_type) + for (type, subtype, params) in parsed_ranges: + type_match = type == target_type or type == "*" or target_type == "*" + subtype_match = ( + subtype == target_subtype or subtype == "*" or target_subtype == "*" + ) + if type_match and subtype_match: + param_matches = reduce( + lambda x, y: x + y, + [ + 1 + for (key, value) in target_params.items() + if key != "q" and key in params and value == params[key] + ], + 0, + ) + fitness = (type == target_type) and 100 or 0 + fitness += (subtype == target_subtype) and 10 or 0 + fitness += param_matches + if fitness > best_fitness: + best_fitness = fitness + best_fit_q = params["q"] + + return best_fitness, float(best_fit_q) + + +def quality_parsed(mime_type, parsed_ranges): + """Find the best match for a mime-type amongst parsed media-ranges. + + Find the best match for a given mime-type against a list of media_ranges + that have already been parsed by parse_media_range(). Returns the 'q' + quality parameter of the best match, 0 if no match was found. This function + bahaves the same as quality() except that 'parsed_ranges' must be a list of + parsed media ranges. + """ + + return fitness_and_quality_parsed(mime_type, parsed_ranges)[1] + + +def quality(mime_type, ranges): + """Return the quality ('q') of a mime-type against a list of media-ranges. + + Returns the quality 'q' of a mime-type when compared against the + media-ranges in ranges. For example: + + >>> quality('text/html','text/*;q=0.3, text/html;q=0.7, + text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5') + 0.7 + + """ + parsed_ranges = [parse_media_range(r) for r in ranges.split(",")] + + return quality_parsed(mime_type, parsed_ranges) + + +def best_match(supported, header): + """Return mime-type with the highest quality ('q') from list of candidates. + + Takes a list of supported mime-types and finds the best match for all the + media-ranges listed in header. The value of header must be a string that + conforms to the format of the HTTP Accept: header. The value of 'supported' + is a list of mime-types. The list of supported mime-types should be sorted + in order of increasing desirability, in case of a situation where there is + a tie. + + >>> best_match(['application/xbel+xml', 'text/xml'], + 'text/*;q=0.5,*/*; q=0.1') + 'text/xml' + """ + split_header = _filter_blank(header.split(",")) + parsed_header = [parse_media_range(r) for r in split_header] + weighted_matches = [] + pos = 0 + for mime_type in supported: + weighted_matches.append( + (fitness_and_quality_parsed(mime_type, parsed_header), pos, mime_type) + ) + pos += 1 + weighted_matches.sort() + + return weighted_matches[-1][0][1] and weighted_matches[-1][2] or "" + + +def _filter_blank(i): + for s in i: + if s.strip(): + yield s diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/model.py b/.venv/lib/python3.11/site-packages/googleapiclient/model.py new file mode 100644 index 0000000000000000000000000000000000000000..dee1cb7f377bd81acfd9b43b72d20034ee5cb096 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/model.py @@ -0,0 +1,429 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""Model objects for requests and responses. + +Each API may support one or more serializations, such +as JSON, Atom, etc. The model classes are responsible +for converting between the wire format and the Python +object representation. +""" +from __future__ import absolute_import + +__author__ = "jcgregorio@google.com (Joe Gregorio)" + +import json +import logging +import platform +import urllib +import warnings + +from googleapiclient import version as googleapiclient_version +from googleapiclient.errors import HttpError + +try: + from google.api_core.version_header import API_VERSION_METADATA_KEY + + HAS_API_VERSION = True +except ImportError: + HAS_API_VERSION = False + +_LIBRARY_VERSION = googleapiclient_version.__version__ +_PY_VERSION = platform.python_version() + +LOGGER = logging.getLogger(__name__) + +dump_request_response = False + + +def _abstract(): + raise NotImplementedError("You need to override this function") + + +class Model(object): + """Model base class. + + All Model classes should implement this interface. + The Model serializes and de-serializes between a wire + format such as JSON and a Python object representation. + """ + + def request(self, headers, path_params, query_params, body_value): + """Updates outgoing requests with a serialized body. + + Args: + headers: dict, request headers + path_params: dict, parameters that appear in the request path + query_params: dict, parameters that appear in the query + body_value: object, the request body as a Python object, which must be + serializable. + Returns: + A tuple of (headers, path_params, query, body) + + headers: dict, request headers + path_params: dict, parameters that appear in the request path + query: string, query part of the request URI + body: string, the body serialized in the desired wire format. + """ + _abstract() + + def response(self, resp, content): + """Convert the response wire format into a Python object. + + Args: + resp: httplib2.Response, the HTTP response headers and status + content: string, the body of the HTTP response + + Returns: + The body de-serialized as a Python object. + + Raises: + googleapiclient.errors.HttpError if a non 2xx response is received. + """ + _abstract() + + +class BaseModel(Model): + """Base model class. + + Subclasses should provide implementations for the "serialize" and + "deserialize" methods, as well as values for the following class attributes. + + Attributes: + accept: The value to use for the HTTP Accept header. + content_type: The value to use for the HTTP Content-type header. + no_content_response: The value to return when deserializing a 204 "No + Content" response. + alt_param: The value to supply as the "alt" query parameter for requests. + """ + + accept = None + content_type = None + no_content_response = None + alt_param = None + + def _log_request(self, headers, path_params, query, body): + """Logs debugging information about the request if requested.""" + if dump_request_response: + LOGGER.info("--request-start--") + LOGGER.info("-headers-start-") + for h, v in headers.items(): + LOGGER.info("%s: %s", h, v) + LOGGER.info("-headers-end-") + LOGGER.info("-path-parameters-start-") + for h, v in path_params.items(): + LOGGER.info("%s: %s", h, v) + LOGGER.info("-path-parameters-end-") + LOGGER.info("body: %s", body) + LOGGER.info("query: %s", query) + LOGGER.info("--request-end--") + + def request(self, headers, path_params, query_params, body_value, api_version=None): + """Updates outgoing requests with a serialized body. + + Args: + headers: dict, request headers + path_params: dict, parameters that appear in the request path + query_params: dict, parameters that appear in the query + body_value: object, the request body as a Python object, which must be + serializable by json. + api_version: str, The precise API version represented by this request, + which will result in an API Version header being sent along with the + HTTP request. + Returns: + A tuple of (headers, path_params, query, body) + + headers: dict, request headers + path_params: dict, parameters that appear in the request path + query: string, query part of the request URI + body: string, the body serialized as JSON + """ + query = self._build_query(query_params) + headers["accept"] = self.accept + headers["accept-encoding"] = "gzip, deflate" + if "user-agent" in headers: + headers["user-agent"] += " " + else: + headers["user-agent"] = "" + headers["user-agent"] += "(gzip)" + if "x-goog-api-client" in headers: + headers["x-goog-api-client"] += " " + else: + headers["x-goog-api-client"] = "" + headers["x-goog-api-client"] += "gdcl/%s gl-python/%s" % ( + _LIBRARY_VERSION, + _PY_VERSION, + ) + + if api_version and HAS_API_VERSION: + headers[API_VERSION_METADATA_KEY] = api_version + elif api_version: + warnings.warn( + "The `api_version` argument is ignored as a newer version of " + "`google-api-core` is required to use this feature." + "Please upgrade `google-api-core` to 2.19.0 or newer." + ) + + if body_value is not None: + headers["content-type"] = self.content_type + body_value = self.serialize(body_value) + self._log_request(headers, path_params, query, body_value) + return (headers, path_params, query, body_value) + + def _build_query(self, params): + """Builds a query string. + + Args: + params: dict, the query parameters + + Returns: + The query parameters properly encoded into an HTTP URI query string. + """ + if self.alt_param is not None: + params.update({"alt": self.alt_param}) + astuples = [] + for key, value in params.items(): + if type(value) == type([]): + for x in value: + x = x.encode("utf-8") + astuples.append((key, x)) + else: + if isinstance(value, str) and callable(value.encode): + value = value.encode("utf-8") + astuples.append((key, value)) + return "?" + urllib.parse.urlencode(astuples) + + def _log_response(self, resp, content): + """Logs debugging information about the response if requested.""" + if dump_request_response: + LOGGER.info("--response-start--") + for h, v in resp.items(): + LOGGER.info("%s: %s", h, v) + if content: + LOGGER.info(content) + LOGGER.info("--response-end--") + + def response(self, resp, content): + """Convert the response wire format into a Python object. + + Args: + resp: httplib2.Response, the HTTP response headers and status + content: string, the body of the HTTP response + + Returns: + The body de-serialized as a Python object. + + Raises: + googleapiclient.errors.HttpError if a non 2xx response is received. + """ + self._log_response(resp, content) + # Error handling is TBD, for example, do we retry + # for some operation/error combinations? + if resp.status < 300: + if resp.status == 204: + # A 204: No Content response should be treated differently + # to all the other success states + return self.no_content_response + return self.deserialize(content) + else: + LOGGER.debug("Content from bad request was: %r" % content) + raise HttpError(resp, content) + + def serialize(self, body_value): + """Perform the actual Python object serialization. + + Args: + body_value: object, the request body as a Python object. + + Returns: + string, the body in serialized form. + """ + _abstract() + + def deserialize(self, content): + """Perform the actual deserialization from response string to Python + object. + + Args: + content: string, the body of the HTTP response + + Returns: + The body de-serialized as a Python object. + """ + _abstract() + + +class JsonModel(BaseModel): + """Model class for JSON. + + Serializes and de-serializes between JSON and the Python + object representation of HTTP request and response bodies. + """ + + accept = "application/json" + content_type = "application/json" + alt_param = "json" + + def __init__(self, data_wrapper=False): + """Construct a JsonModel. + + Args: + data_wrapper: boolean, wrap requests and responses in a data wrapper + """ + self._data_wrapper = data_wrapper + + def serialize(self, body_value): + if ( + isinstance(body_value, dict) + and "data" not in body_value + and self._data_wrapper + ): + body_value = {"data": body_value} + return json.dumps(body_value) + + def deserialize(self, content): + try: + content = content.decode("utf-8") + except AttributeError: + pass + try: + body = json.loads(content) + except json.decoder.JSONDecodeError: + body = content + else: + if self._data_wrapper and "data" in body: + body = body["data"] + return body + + @property + def no_content_response(self): + return {} + + +class RawModel(JsonModel): + """Model class for requests that don't return JSON. + + Serializes and de-serializes between JSON and the Python + object representation of HTTP request, and returns the raw bytes + of the response body. + """ + + accept = "*/*" + content_type = "application/json" + alt_param = None + + def deserialize(self, content): + return content + + @property + def no_content_response(self): + return "" + + +class MediaModel(JsonModel): + """Model class for requests that return Media. + + Serializes and de-serializes between JSON and the Python + object representation of HTTP request, and returns the raw bytes + of the response body. + """ + + accept = "*/*" + content_type = "application/json" + alt_param = "media" + + def deserialize(self, content): + return content + + @property + def no_content_response(self): + return "" + + +class ProtocolBufferModel(BaseModel): + """Model class for protocol buffers. + + Serializes and de-serializes the binary protocol buffer sent in the HTTP + request and response bodies. + """ + + accept = "application/x-protobuf" + content_type = "application/x-protobuf" + alt_param = "proto" + + def __init__(self, protocol_buffer): + """Constructs a ProtocolBufferModel. + + The serialized protocol buffer returned in an HTTP response will be + de-serialized using the given protocol buffer class. + + Args: + protocol_buffer: The protocol buffer class used to de-serialize a + response from the API. + """ + self._protocol_buffer = protocol_buffer + + def serialize(self, body_value): + return body_value.SerializeToString() + + def deserialize(self, content): + return self._protocol_buffer.FromString(content) + + @property + def no_content_response(self): + return self._protocol_buffer() + + +def makepatch(original, modified): + """Create a patch object. + + Some methods support PATCH, an efficient way to send updates to a resource. + This method allows the easy construction of patch bodies by looking at the + differences between a resource before and after it was modified. + + Args: + original: object, the original deserialized resource + modified: object, the modified deserialized resource + Returns: + An object that contains only the changes from original to modified, in a + form suitable to pass to a PATCH method. + + Example usage: + item = service.activities().get(postid=postid, userid=userid).execute() + original = copy.deepcopy(item) + item['object']['content'] = 'This is updated.' + service.activities.patch(postid=postid, userid=userid, + body=makepatch(original, item)).execute() + """ + patch = {} + for key, original_value in original.items(): + modified_value = modified.get(key, None) + if modified_value is None: + # Use None to signal that the element is deleted + patch[key] = None + elif original_value != modified_value: + if type(original_value) == type({}): + # Recursively descend objects + patch[key] = makepatch(original_value, modified_value) + else: + # In the case of simple types or arrays we just replace + patch[key] = modified_value + else: + # Don't add anything to patch if there's no change + pass + for key in modified: + if key not in original: + patch[key] = modified[key] + + return patch diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/sample_tools.py b/.venv/lib/python3.11/site-packages/googleapiclient/sample_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..bdad0a2ae878f43627199c5a7dcdd82cad0a8e8e --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/sample_tools.py @@ -0,0 +1,108 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""Utilities for making samples. + +Consolidates a lot of code commonly repeated in sample applications. +""" +from __future__ import absolute_import + +__author__ = "jcgregorio@google.com (Joe Gregorio)" +__all__ = ["init"] + + +import argparse +import os + +from googleapiclient import discovery +from googleapiclient.http import build_http + + +def init( + argv, name, version, doc, filename, scope=None, parents=[], discovery_filename=None +): + """A common initialization routine for samples. + + Many of the sample applications do the same initialization, which has now + been consolidated into this function. This function uses common idioms found + in almost all the samples, i.e. for an API with name 'apiname', the + credentials are stored in a file named apiname.dat, and the + client_secrets.json file is stored in the same directory as the application + main file. + + Args: + argv: list of string, the command-line parameters of the application. + name: string, name of the API. + version: string, version of the API. + doc: string, description of the application. Usually set to __doc__. + file: string, filename of the application. Usually set to __file__. + parents: list of argparse.ArgumentParser, additional command-line flags. + scope: string, The OAuth scope used. + discovery_filename: string, name of local discovery file (JSON). Use when discovery doc not available via URL. + + Returns: + A tuple of (service, flags), where service is the service object and flags + is the parsed command-line flags. + """ + try: + from oauth2client import client, file, tools + except ImportError: + raise ImportError( + "googleapiclient.sample_tools requires oauth2client. Please install oauth2client and try again." + ) + + if scope is None: + scope = "https://www.googleapis.com/auth/" + name + + # Parser command-line arguments. + parent_parsers = [tools.argparser] + parent_parsers.extend(parents) + parser = argparse.ArgumentParser( + description=doc, + formatter_class=argparse.RawDescriptionHelpFormatter, + parents=parent_parsers, + ) + flags = parser.parse_args(argv[1:]) + + # Name of a file containing the OAuth 2.0 information for this + # application, including client_id and client_secret, which are found + # on the API Access tab on the Google APIs + # Console . + client_secrets = os.path.join(os.path.dirname(filename), "client_secrets.json") + + # Set up a Flow object to be used if we need to authenticate. + flow = client.flow_from_clientsecrets( + client_secrets, scope=scope, message=tools.message_if_missing(client_secrets) + ) + + # Prepare credentials, and authorize HTTP object with them. + # If the credentials don't exist or are invalid run through the native client + # flow. The Storage object will ensure that if successful the good + # credentials will get written back to a file. + storage = file.Storage(name + ".dat") + credentials = storage.get() + if credentials is None or credentials.invalid: + credentials = tools.run_flow(flow, storage, flags) + http = credentials.authorize(http=build_http()) + + if discovery_filename is None: + # Construct a service object via the discovery service. + service = discovery.build(name, version, http=http) + else: + # Construct a service object using a local discovery document file. + with open(discovery_filename) as discovery_file: + service = discovery.build_from_document( + discovery_file.read(), base="https://www.googleapis.com/", http=http + ) + return (service, flags) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/schema.py b/.venv/lib/python3.11/site-packages/googleapiclient/schema.py new file mode 100644 index 0000000000000000000000000000000000000000..93b07df44ac6cb3ddf47a23218801de2ecdc6614 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/schema.py @@ -0,0 +1,317 @@ +# Copyright 2014 Google Inc. All Rights Reserved. +# +# 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. + +"""Schema processing for discovery based APIs + +Schemas holds an APIs discovery schemas. It can return those schema as +deserialized JSON objects, or pretty print them as prototype objects that +conform to the schema. + +For example, given the schema: + + schema = \"\"\"{ + "Foo": { + "type": "object", + "properties": { + "etag": { + "type": "string", + "description": "ETag of the collection." + }, + "kind": { + "type": "string", + "description": "Type of the collection ('calendar#acl').", + "default": "calendar#acl" + }, + "nextPageToken": { + "type": "string", + "description": "Token used to access the next + page of this result. Omitted if no further results are available." + } + } + } + }\"\"\" + + s = Schemas(schema) + print s.prettyPrintByName('Foo') + + Produces the following output: + + { + "nextPageToken": "A String", # Token used to access the + # next page of this result. Omitted if no further results are available. + "kind": "A String", # Type of the collection ('calendar#acl'). + "etag": "A String", # ETag of the collection. + }, + +The constructor takes a discovery document in which to look up named schema. +""" +from __future__ import absolute_import + +# TODO(jcgregorio) support format, enum, minimum, maximum + +__author__ = "jcgregorio@google.com (Joe Gregorio)" + + +from collections import OrderedDict + +from googleapiclient import _helpers as util + + +class Schemas(object): + """Schemas for an API.""" + + def __init__(self, discovery): + """Constructor. + + Args: + discovery: object, Deserialized discovery document from which we pull + out the named schema. + """ + self.schemas = discovery.get("schemas", {}) + + # Cache of pretty printed schemas. + self.pretty = {} + + @util.positional(2) + def _prettyPrintByName(self, name, seen=None, dent=0): + """Get pretty printed object prototype from the schema name. + + Args: + name: string, Name of schema in the discovery document. + seen: list of string, Names of schema already seen. Used to handle + recursive definitions. + + Returns: + string, A string that contains a prototype object with + comments that conforms to the given schema. + """ + if seen is None: + seen = [] + + if name in seen: + # Do not fall into an infinite loop over recursive definitions. + return "# Object with schema name: %s" % name + seen.append(name) + + if name not in self.pretty: + self.pretty[name] = _SchemaToStruct( + self.schemas[name], seen, dent=dent + ).to_str(self._prettyPrintByName) + + seen.pop() + + return self.pretty[name] + + def prettyPrintByName(self, name): + """Get pretty printed object prototype from the schema name. + + Args: + name: string, Name of schema in the discovery document. + + Returns: + string, A string that contains a prototype object with + comments that conforms to the given schema. + """ + # Return with trailing comma and newline removed. + return self._prettyPrintByName(name, seen=[], dent=0)[:-2] + + @util.positional(2) + def _prettyPrintSchema(self, schema, seen=None, dent=0): + """Get pretty printed object prototype of schema. + + Args: + schema: object, Parsed JSON schema. + seen: list of string, Names of schema already seen. Used to handle + recursive definitions. + + Returns: + string, A string that contains a prototype object with + comments that conforms to the given schema. + """ + if seen is None: + seen = [] + + return _SchemaToStruct(schema, seen, dent=dent).to_str(self._prettyPrintByName) + + def prettyPrintSchema(self, schema): + """Get pretty printed object prototype of schema. + + Args: + schema: object, Parsed JSON schema. + + Returns: + string, A string that contains a prototype object with + comments that conforms to the given schema. + """ + # Return with trailing comma and newline removed. + return self._prettyPrintSchema(schema, dent=0)[:-2] + + def get(self, name, default=None): + """Get deserialized JSON schema from the schema name. + + Args: + name: string, Schema name. + default: object, return value if name not found. + """ + return self.schemas.get(name, default) + + +class _SchemaToStruct(object): + """Convert schema to a prototype object.""" + + @util.positional(3) + def __init__(self, schema, seen, dent=0): + """Constructor. + + Args: + schema: object, Parsed JSON schema. + seen: list, List of names of schema already seen while parsing. Used to + handle recursive definitions. + dent: int, Initial indentation depth. + """ + # The result of this parsing kept as list of strings. + self.value = [] + + # The final value of the parsing. + self.string = None + + # The parsed JSON schema. + self.schema = schema + + # Indentation level. + self.dent = dent + + # Method that when called returns a prototype object for the schema with + # the given name. + self.from_cache = None + + # List of names of schema already seen while parsing. + self.seen = seen + + def emit(self, text): + """Add text as a line to the output. + + Args: + text: string, Text to output. + """ + self.value.extend([" " * self.dent, text, "\n"]) + + def emitBegin(self, text): + """Add text to the output, but with no line terminator. + + Args: + text: string, Text to output. + """ + self.value.extend([" " * self.dent, text]) + + def emitEnd(self, text, comment): + """Add text and comment to the output with line terminator. + + Args: + text: string, Text to output. + comment: string, Python comment. + """ + if comment: + divider = "\n" + " " * (self.dent + 2) + "# " + lines = comment.splitlines() + lines = [x.rstrip() for x in lines] + comment = divider.join(lines) + self.value.extend([text, " # ", comment, "\n"]) + else: + self.value.extend([text, "\n"]) + + def indent(self): + """Increase indentation level.""" + self.dent += 1 + + def undent(self): + """Decrease indentation level.""" + self.dent -= 1 + + def _to_str_impl(self, schema): + """Prototype object based on the schema, in Python code with comments. + + Args: + schema: object, Parsed JSON schema file. + + Returns: + Prototype object based on the schema, in Python code with comments. + """ + stype = schema.get("type") + if stype == "object": + self.emitEnd("{", schema.get("description", "")) + self.indent() + if "properties" in schema: + properties = schema.get("properties", {}) + sorted_properties = OrderedDict(sorted(properties.items())) + for pname, pschema in sorted_properties.items(): + self.emitBegin('"%s": ' % pname) + self._to_str_impl(pschema) + elif "additionalProperties" in schema: + self.emitBegin('"a_key": ') + self._to_str_impl(schema["additionalProperties"]) + self.undent() + self.emit("},") + elif "$ref" in schema: + schemaName = schema["$ref"] + description = schema.get("description", "") + s = self.from_cache(schemaName, seen=self.seen) + parts = s.splitlines() + self.emitEnd(parts[0], description) + for line in parts[1:]: + self.emit(line.rstrip()) + elif stype == "boolean": + value = schema.get("default", "True or False") + self.emitEnd("%s," % str(value), schema.get("description", "")) + elif stype == "string": + value = schema.get("default", "A String") + self.emitEnd('"%s",' % str(value), schema.get("description", "")) + elif stype == "integer": + value = schema.get("default", "42") + self.emitEnd("%s," % str(value), schema.get("description", "")) + elif stype == "number": + value = schema.get("default", "3.14") + self.emitEnd("%s," % str(value), schema.get("description", "")) + elif stype == "null": + self.emitEnd("None,", schema.get("description", "")) + elif stype == "any": + self.emitEnd('"",', schema.get("description", "")) + elif stype == "array": + self.emitEnd("[", schema.get("description")) + self.indent() + self.emitBegin("") + self._to_str_impl(schema["items"]) + self.undent() + self.emit("],") + else: + self.emit("Unknown type! %s" % stype) + self.emitEnd("", "") + + self.string = "".join(self.value) + return self.string + + def to_str(self, from_cache): + """Prototype object based on the schema, in Python code with comments. + + Args: + from_cache: callable(name, seen), Callable that retrieves an object + prototype for a schema with the given name. Seen is a list of schema + names already seen as we recursively descend the schema definition. + + Returns: + Prototype object based on the schema, in Python code with comments. + The lines of the code will all be properly indented. + """ + self.from_cache = from_cache + return self._to_str_impl(self.schema) diff --git a/.venv/lib/python3.11/site-packages/googleapiclient/version.py b/.venv/lib/python3.11/site-packages/googleapiclient/version.py new file mode 100644 index 0000000000000000000000000000000000000000..5781ac6970e6a43af4286d4244a8e2dd5f8606f7 --- /dev/null +++ b/.venv/lib/python3.11/site-packages/googleapiclient/version.py @@ -0,0 +1,15 @@ +# Copyright 2021 Google LLC +# +# 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. + +__version__ = "2.159.0" diff --git a/.venv/lib/python3.11/site-packages/nvidia_cufft_cu12-11.2.1.3.dist-info/METADATA b/.venv/lib/python3.11/site-packages/nvidia_cufft_cu12-11.2.1.3.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..7f3d3db95ffbbe222c91c7284524edc471dce14f --- /dev/null +++ b/.venv/lib/python3.11/site-packages/nvidia_cufft_cu12-11.2.1.3.dist-info/METADATA @@ -0,0 +1,35 @@ +Metadata-Version: 2.1 +Name: nvidia-cufft-cu12 +Version: 11.2.1.3 +Summary: CUFFT native runtime libraries +Home-page: https://developer.nvidia.com/cuda-zone +Author: Nvidia CUDA Installer Team +Author-email: cuda_installer@nvidia.com +License: NVIDIA Proprietary Software +Keywords: cuda,nvidia,runtime,machine learning,deep learning +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: Other/Proprietary License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX :: Linux +Requires-Python: >=3 +License-File: License.txt + +CUFFT native runtime libraries