././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0791612 googleapis_common_protos-1.75.0/0000755000000000000000000000000015177036143015460 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/LICENSE0000644000000000000000000002613615177035227016477 0ustar00rootroot Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/MANIFEST.in0000644000000000000000000000153415177035226017222 0ustar00rootroot# -*- coding: utf-8 -*- # # Copyright 2024 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 # # https://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. # Generated by synthtool. DO NOT EDIT! include README.rst LICENSE recursive-include google *.json *.proto py.typed recursive-include tests * global-exclude *.py[co] global-exclude __pycache__ # Exclude scripts for samples readmegen prune scripts/readme-gen ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0791066 googleapis_common_protos-1.75.0/PKG-INFO0000644000000000000000000002055715177036143016566 0ustar00rootrootMetadata-Version: 2.4 Name: googleapis-common-protos Version: 1.75.0 Summary: Common protobufs used in Google APIs Author-email: Google LLC License: Apache 2.0 Project-URL: Repository, https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: Apache Software License 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: Programming Language :: Python :: 3.14 Classifier: Operating System :: OS Independent Classifier: Topic :: Internet Requires-Python: >=3.9 Description-Content-Type: text/x-rst License-File: LICENSE Requires-Dist: protobuf<8.0.0,>=4.25.8 Provides-Extra: grpc Requires-Dist: grpcio<2.0.0,>=1.44.0; extra == "grpc" Dynamic: license-file Python Client for Service Config ================================ |stable| |pypi| |versions| - `Client Library Documentation`_ .. |stable| image:: https://img.shields.io/badge/support-stable-gold.svg :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#stability-levels .. |pypi| image:: https://img.shields.io/pypi/v/googleapis-common-protos.svg :target: https://pypi.org/project/googleapis-common-protos/ .. |versions| image:: https://img.shields.io/pypi/pyversions/googleapis-common-protos.svg :target: https://pypi.org/project/googleapis-common-protos/ .. _Client Library Documentation: https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos/summary_overview Quick Start ----------- In order to use this library, you first need to go through the following steps: 1. `Select or create a Cloud Platform project.`_ 2. `Enable billing for your project.`_ 3. `Set up Authentication.`_ .. _Select or create a Cloud Platform project.: https://console.cloud.google.com/project .. _Enable billing for your project.: https://cloud.google.com/billing/docs/how-to/modify-project#enable_billing_for_a_project .. _Set up Authentication.: https://googleapis.dev/python/google-api-core/latest/auth.html Installation ~~~~~~~~~~~~ Install this library in a virtual environment using `venv`_. `venv`_ is a tool that creates isolated Python environments. These isolated environments can have separate versions of Python packages, which allows you to isolate one project's dependencies from the dependencies of other projects. With `venv`_, it's possible to install this library without needing system install permissions, and without clashing with the installed system dependencies. .. _`venv`: https://docs.python.org/3/library/venv.html Code samples and snippets ~~~~~~~~~~~~~~~~~~~~~~~~~ Code samples and snippets live in the `samples/`_ folder. .. _samples/: https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos/samples Supported Python Versions ^^^^^^^^^^^^^^^^^^^^^^^^^ Our client libraries are compatible with all current `active`_ and `maintenance`_ versions of Python. Python >= 3.9, including 3.14 .. _active: https://devguide.python.org/devcycle/#in-development-main-branch .. _maintenance: https://devguide.python.org/devcycle/#maintenance-branches Unsupported Python Versions ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Python <= 3.8 If you are using an `end-of-life`_ version of Python, we recommend that you update as soon as possible to an actively supported version. .. _end-of-life: https://devguide.python.org/devcycle/#end-of-life-branches Mac/Linux ^^^^^^^^^ .. code-block:: console python3 -m venv source /bin/activate pip install googleapis-common-protos Windows ^^^^^^^ .. code-block:: console py -m venv .\\Scripts\activate pip install googleapis-common-protos Next Steps ~~~~~~~~~~ - Read the `Client Library Documentation`_ for Service Config to see other available methods on the client. - View this `README`_ to see the full list of Cloud APIs that we cover. .. _README: https://github.com/googleapis/google-cloud-python/blob/main/README.rst Logging ------- This library uses the standard Python :code:`logging` functionality to log some RPC events that could be of interest for debugging and monitoring purposes. Note the following: #. Logs may contain sensitive information. Take care to **restrict access to the logs** if they are saved, whether it be on local storage or on Google Cloud Logging. #. Google may refine the occurrence, level, and content of various log messages in this library without flagging such changes as breaking. **Do not depend on immutability of the logging events**. #. By default, the logging events from this library are not handled. You must **explicitly configure log handling** using one of the mechanisms below. Simple, environment-based configuration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To enable logging for this library without any changes in your code, set the :code:`GOOGLE_SDK_PYTHON_LOGGING_SCOPE` environment variable to a valid Google logging scope. This configures handling of logging events (at level :code:`logging.DEBUG` or higher) from this library in a default manner, emitting the logged messages in a structured format. It does not currently allow customizing the logging levels captured nor the handlers, formatters, etc. used for any logging event. A logging scope is a period-separated namespace that begins with :code:`google`, identifying the Python module or package to log. - Valid logging scopes: :code:`google`, :code:`google.cloud.asset.v1`, :code:`google.api`, :code:`google.auth`, etc. - Invalid logging scopes: :code:`foo`, :code:`123`, etc. **NOTE**: If the logging scope is invalid, the library does not set up any logging handlers. Environment-Based Examples ^^^^^^^^^^^^^^^^^^^^^^^^^^ - Enabling the default handler for all Google-based loggers .. code-block:: console export GOOGLE_SDK_PYTHON_LOGGING_SCOPE=google - Enabling the default handler for a specific Google module (for a client library called :code:`library_v1`): .. code-block:: console export GOOGLE_SDK_PYTHON_LOGGING_SCOPE=google.cloud.library_v1 Advanced, code-based configuration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can also configure a valid logging scope using Python's standard `logging` mechanism. Code-Based Examples ^^^^^^^^^^^^^^^^^^^ - Configuring a handler for all Google-based loggers .. code-block:: python import logging from google.cloud import library_v1 base_logger = logging.getLogger("google") base_logger.addHandler(logging.StreamHandler()) base_logger.setLevel(logging.DEBUG) - Configuring a handler for a specific Google module (for a client library called :code:`library_v1`): .. code-block:: python import logging from google.cloud import library_v1 base_logger = logging.getLogger("google.cloud.library_v1") base_logger.addHandler(logging.StreamHandler()) base_logger.setLevel(logging.DEBUG) Logging details ~~~~~~~~~~~~~~~ #. Regardless of which of the mechanisms above you use to configure logging for this library, by default logging events are not propagated up to the root logger from the `google`-level logger. If you need the events to be propagated to the root logger, you must explicitly set :code:`logging.getLogger("google").propagate = True` in your code. #. You can mix the different logging configurations above for different Google modules. For example, you may want use a code-based logging configuration for one library, but decide you need to also set up environment-based logging configuration for another library. #. If you attempt to use both code-based and environment-based configuration for the same module, the environment-based configuration will be ineffectual if the code -based configuration gets applied first. #. The Google-specific logging configurations (default handlers for environment-based configuration; not propagating logging events to the root logger) get executed the first time *any* client library is instantiated in your application, and only if the affected loggers have not been previously configured. (This is the reason for 2.i. above.) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/README.rst0000644000000000000000000001634015177035226017154 0ustar00rootrootPython Client for Service Config ================================ |stable| |pypi| |versions| - `Client Library Documentation`_ .. |stable| image:: https://img.shields.io/badge/support-stable-gold.svg :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#stability-levels .. |pypi| image:: https://img.shields.io/pypi/v/googleapis-common-protos.svg :target: https://pypi.org/project/googleapis-common-protos/ .. |versions| image:: https://img.shields.io/pypi/pyversions/googleapis-common-protos.svg :target: https://pypi.org/project/googleapis-common-protos/ .. _Client Library Documentation: https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos/summary_overview Quick Start ----------- In order to use this library, you first need to go through the following steps: 1. `Select or create a Cloud Platform project.`_ 2. `Enable billing for your project.`_ 3. `Set up Authentication.`_ .. _Select or create a Cloud Platform project.: https://console.cloud.google.com/project .. _Enable billing for your project.: https://cloud.google.com/billing/docs/how-to/modify-project#enable_billing_for_a_project .. _Set up Authentication.: https://googleapis.dev/python/google-api-core/latest/auth.html Installation ~~~~~~~~~~~~ Install this library in a virtual environment using `venv`_. `venv`_ is a tool that creates isolated Python environments. These isolated environments can have separate versions of Python packages, which allows you to isolate one project's dependencies from the dependencies of other projects. With `venv`_, it's possible to install this library without needing system install permissions, and without clashing with the installed system dependencies. .. _`venv`: https://docs.python.org/3/library/venv.html Code samples and snippets ~~~~~~~~~~~~~~~~~~~~~~~~~ Code samples and snippets live in the `samples/`_ folder. .. _samples/: https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos/samples Supported Python Versions ^^^^^^^^^^^^^^^^^^^^^^^^^ Our client libraries are compatible with all current `active`_ and `maintenance`_ versions of Python. Python >= 3.9, including 3.14 .. _active: https://devguide.python.org/devcycle/#in-development-main-branch .. _maintenance: https://devguide.python.org/devcycle/#maintenance-branches Unsupported Python Versions ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Python <= 3.8 If you are using an `end-of-life`_ version of Python, we recommend that you update as soon as possible to an actively supported version. .. _end-of-life: https://devguide.python.org/devcycle/#end-of-life-branches Mac/Linux ^^^^^^^^^ .. code-block:: console python3 -m venv source /bin/activate pip install googleapis-common-protos Windows ^^^^^^^ .. code-block:: console py -m venv .\\Scripts\activate pip install googleapis-common-protos Next Steps ~~~~~~~~~~ - Read the `Client Library Documentation`_ for Service Config to see other available methods on the client. - View this `README`_ to see the full list of Cloud APIs that we cover. .. _README: https://github.com/googleapis/google-cloud-python/blob/main/README.rst Logging ------- This library uses the standard Python :code:`logging` functionality to log some RPC events that could be of interest for debugging and monitoring purposes. Note the following: #. Logs may contain sensitive information. Take care to **restrict access to the logs** if they are saved, whether it be on local storage or on Google Cloud Logging. #. Google may refine the occurrence, level, and content of various log messages in this library without flagging such changes as breaking. **Do not depend on immutability of the logging events**. #. By default, the logging events from this library are not handled. You must **explicitly configure log handling** using one of the mechanisms below. Simple, environment-based configuration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To enable logging for this library without any changes in your code, set the :code:`GOOGLE_SDK_PYTHON_LOGGING_SCOPE` environment variable to a valid Google logging scope. This configures handling of logging events (at level :code:`logging.DEBUG` or higher) from this library in a default manner, emitting the logged messages in a structured format. It does not currently allow customizing the logging levels captured nor the handlers, formatters, etc. used for any logging event. A logging scope is a period-separated namespace that begins with :code:`google`, identifying the Python module or package to log. - Valid logging scopes: :code:`google`, :code:`google.cloud.asset.v1`, :code:`google.api`, :code:`google.auth`, etc. - Invalid logging scopes: :code:`foo`, :code:`123`, etc. **NOTE**: If the logging scope is invalid, the library does not set up any logging handlers. Environment-Based Examples ^^^^^^^^^^^^^^^^^^^^^^^^^^ - Enabling the default handler for all Google-based loggers .. code-block:: console export GOOGLE_SDK_PYTHON_LOGGING_SCOPE=google - Enabling the default handler for a specific Google module (for a client library called :code:`library_v1`): .. code-block:: console export GOOGLE_SDK_PYTHON_LOGGING_SCOPE=google.cloud.library_v1 Advanced, code-based configuration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can also configure a valid logging scope using Python's standard `logging` mechanism. Code-Based Examples ^^^^^^^^^^^^^^^^^^^ - Configuring a handler for all Google-based loggers .. code-block:: python import logging from google.cloud import library_v1 base_logger = logging.getLogger("google") base_logger.addHandler(logging.StreamHandler()) base_logger.setLevel(logging.DEBUG) - Configuring a handler for a specific Google module (for a client library called :code:`library_v1`): .. code-block:: python import logging from google.cloud import library_v1 base_logger = logging.getLogger("google.cloud.library_v1") base_logger.addHandler(logging.StreamHandler()) base_logger.setLevel(logging.DEBUG) Logging details ~~~~~~~~~~~~~~~ #. Regardless of which of the mechanisms above you use to configure logging for this library, by default logging events are not propagated up to the root logger from the `google`-level logger. If you need the events to be propagated to the root logger, you must explicitly set :code:`logging.getLogger("google").propagate = True` in your code. #. You can mix the different logging configurations above for different Google modules. For example, you may want use a code-based logging configuration for one library, but decide you need to also set up environment-based logging configuration for another library. #. If you attempt to use both code-based and environment-based configuration for the same module, the environment-based configuration will be ineffectual if the code -based configuration gets applied first. #. The Google-specific logging configurations (default handlers for environment-based configuration; not propagating logging events to the root logger) get executed the first time *any* client library is instantiated in your application, and only if the affected loggers have not been previously configured. (This is the reason for 2.i. above.) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0453506 googleapis_common_protos-1.75.0/google/0000755000000000000000000000000015177036143016734 5ustar00rootroot././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0623388 googleapis_common_protos-1.75.0/google/api/0000755000000000000000000000000015177036143017505 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/annotations.proto0000644000000000000000000000202515177035224023125 0ustar00rootroot// Copyright 2025 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. syntax = "proto3"; package google.api; import "google/api/http.proto"; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "AnnotationsProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.MethodOptions { // See `HttpRule`. HttpRule http = 72295728; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/annotations_pb2.py0000644000000000000000000000420715177035227023164 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/annotations.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 from google.api import http_pb2 as google_dot_api_dot_http__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1cgoogle/api/annotations.proto\x12\ngoogle.api\x1a\x15google/api/http.proto\x1a google/protobuf/descriptor.proto:E\n\x04http\x12\x1e.google.protobuf.MethodOptions\x18\xb0\xca\xbc" \x01(\x0b\x32\x14.google.api.HttpRuleBn\n\x0e\x63om.google.apiB\x10\x41nnotationsProtoP\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.annotations_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\020AnnotationsProtoP\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\242\002\004GAPI" # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/annotations_pb2.pyi0000644000000000000000000000156715177035222023336 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.api import http_pb2 as _http_pb2 DESCRIPTOR: _descriptor.FileDescriptor HTTP_FIELD_NUMBER: _ClassVar[int] http: _descriptor.FieldDescriptor ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/auth.proto0000644000000000000000000002205615177035225021540 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "AuthProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // `Authentication` defines the authentication configuration for API methods // provided by an API service. // // Example: // // name: calendar.googleapis.com // authentication: // providers: // - id: google_calendar_auth // jwks_uri: https://www.googleapis.com/oauth2/v1/certs // issuer: https://securetoken.google.com // rules: // - selector: "*" // requirements: // provider_id: google_calendar_auth // - selector: google.calendar.Delegate // oauth: // canonical_scopes: https://www.googleapis.com/auth/calendar.read message Authentication { // A list of authentication rules that apply to individual API methods. // // **NOTE:** All service configuration rules follow "last one wins" order. repeated AuthenticationRule rules = 3; // Defines a set of authentication providers that a service supports. repeated AuthProvider providers = 4; } // Authentication rules for the service. // // By default, if a method has any authentication requirements, every request // must include a valid credential matching one of the requirements. // It's an error to include more than one kind of credential in a single // request. // // If a method doesn't have any auth requirements, request credentials will be // ignored. message AuthenticationRule { // Selects the methods to which this rule applies. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. string selector = 1; // The requirements for OAuth credentials. OAuthRequirements oauth = 2; // If true, the service accepts API keys without any other credential. // This flag only applies to HTTP and gRPC requests. bool allow_without_credential = 5; // Requirements for additional authentication providers. repeated AuthRequirement requirements = 7; } // Specifies a location to extract JWT from an API request. message JwtLocation { oneof in { // Specifies HTTP header name to extract JWT token. string header = 1; // Specifies URL query parameter name to extract JWT token. string query = 2; // Specifies cookie name to extract JWT token. string cookie = 4; } // The value prefix. The value format is "value_prefix{token}" // Only applies to "in" header type. Must be empty for "in" query type. // If not empty, the header value has to match (case sensitive) this prefix. // If not matched, JWT will not be extracted. If matched, JWT will be // extracted after the prefix is removed. // // For example, for "Authorization: Bearer {JWT}", // value_prefix="Bearer " with a space at the end. string value_prefix = 3; } // Configuration for an authentication provider, including support for // [JSON Web Token // (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32). message AuthProvider { // The unique identifier of the auth provider. It will be referred to by // `AuthRequirement.provider_id`. // // Example: "bookstore_auth". string id = 1; // Identifies the principal that issued the JWT. See // https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.1 // Usually a URL or an email address. // // Example: https://securetoken.google.com // Example: 1234567-compute@developer.gserviceaccount.com string issuer = 2; // URL of the provider's public key set to validate signature of the JWT. See // [OpenID // Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata). // Optional if the key set document: // - can be retrieved from // [OpenID // Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html) // of the issuer. // - can be inferred from the email domain of the issuer (e.g. a Google // service account). // // Example: https://www.googleapis.com/oauth2/v1/certs string jwks_uri = 3; // The list of JWT // [audiences](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.3). // that are allowed to access. A JWT containing any of these audiences will // be accepted. When this setting is absent, JWTs with audiences: // - "https://[service.name]/[google.protobuf.Api.name]" // - "https://[service.name]/" // will be accepted. // For example, if no audiences are in the setting, LibraryService API will // accept JWTs with the following audiences: // - // https://library-example.googleapis.com/google.example.library.v1.LibraryService // - https://library-example.googleapis.com/ // // Example: // // audiences: bookstore_android.apps.googleusercontent.com, // bookstore_web.apps.googleusercontent.com string audiences = 4; // Redirect URL if JWT token is required but not present or is expired. // Implement authorizationUrl of securityDefinitions in OpenAPI spec. string authorization_url = 5; // Defines the locations to extract the JWT. For now it is only used by the // Cloud Endpoints to store the OpenAPI extension [x-google-jwt-locations] // (https://cloud.google.com/endpoints/docs/openapi/openapi-extensions#x-google-jwt-locations) // // JWT locations can be one of HTTP headers, URL query parameters or // cookies. The rule is that the first match wins. // // If not specified, default to use following 3 locations: // 1) Authorization: Bearer // 2) x-goog-iap-jwt-assertion // 3) access_token query parameter // // Default locations can be specified as followings: // jwt_locations: // - header: Authorization // value_prefix: "Bearer " // - header: x-goog-iap-jwt-assertion // - query: access_token repeated JwtLocation jwt_locations = 6; } // OAuth scopes are a way to define data and permissions on data. For example, // there are scopes defined for "Read-only access to Google Calendar" and // "Access to Cloud Platform". Users can consent to a scope for an application, // giving it permission to access that data on their behalf. // // OAuth scope specifications should be fairly coarse grained; a user will need // to see and understand the text description of what your scope means. // // In most cases: use one or at most two OAuth scopes for an entire family of // products. If your product has multiple APIs, you should probably be sharing // the OAuth scope across all of those APIs. // // When you need finer grained OAuth consent screens: talk with your product // management about how developers will use them in practice. // // Please note that even though each of the canonical scopes is enough for a // request to be accepted and passed to the backend, a request can still fail // due to the backend requiring additional scopes or permissions. message OAuthRequirements { // The list of publicly documented OAuth scopes that are allowed access. An // OAuth token containing any of these scopes will be accepted. // // // Example: // // canonical_scopes: https://www.googleapis.com/auth/calendar, // https://www.googleapis.com/auth/calendar.read string canonical_scopes = 1; } // User-defined authentication requirements, including support for // [JSON Web Token // (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32). message AuthRequirement { // [id][google.api.AuthProvider.id] from authentication provider. // // Example: // // provider_id: bookstore_auth string provider_id = 1; // NOTE: This will be deprecated soon, once AuthProvider.audiences is // implemented and accepted in all the runtime components. // // The list of JWT // [audiences](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.3). // that are allowed to access. A JWT containing any of these audiences will // be accepted. When this setting is absent, only JWTs with audience // "https://[Service_name][google.api.Service.name]/[API_name][google.protobuf.Api.name]" // will be accepted. For example, if no audiences are in the setting, // LibraryService API will only accept JWTs with the following audience // "https://library-example.googleapis.com/google.example.library.v1.LibraryService". // // Example: // // audiences: bookstore_android.apps.googleusercontent.com, // bookstore_web.apps.googleusercontent.com string audiences = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/auth_pb2.py0000644000000000000000000000702215177035223021562 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/auth.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x15google/api/auth.proto\x12\ngoogle.api"l\n\x0e\x41uthentication\x12-\n\x05rules\x18\x03 \x03(\x0b\x32\x1e.google.api.AuthenticationRule\x12+\n\tproviders\x18\x04 \x03(\x0b\x32\x18.google.api.AuthProvider"\xa9\x01\n\x12\x41uthenticationRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12,\n\x05oauth\x18\x02 \x01(\x0b\x32\x1d.google.api.OAuthRequirements\x12 \n\x18\x61llow_without_credential\x18\x05 \x01(\x08\x12\x31\n\x0crequirements\x18\x07 \x03(\x0b\x32\x1b.google.api.AuthRequirement"^\n\x0bJwtLocation\x12\x10\n\x06header\x18\x01 \x01(\tH\x00\x12\x0f\n\x05query\x18\x02 \x01(\tH\x00\x12\x10\n\x06\x63ookie\x18\x04 \x01(\tH\x00\x12\x14\n\x0cvalue_prefix\x18\x03 \x01(\tB\x04\n\x02in"\x9a\x01\n\x0c\x41uthProvider\x12\n\n\x02id\x18\x01 \x01(\t\x12\x0e\n\x06issuer\x18\x02 \x01(\t\x12\x10\n\x08jwks_uri\x18\x03 \x01(\t\x12\x11\n\taudiences\x18\x04 \x01(\t\x12\x19\n\x11\x61uthorization_url\x18\x05 \x01(\t\x12.\n\rjwt_locations\x18\x06 \x03(\x0b\x32\x17.google.api.JwtLocation"-\n\x11OAuthRequirements\x12\x18\n\x10\x63\x61nonical_scopes\x18\x01 \x01(\t"9\n\x0f\x41uthRequirement\x12\x13\n\x0bprovider_id\x18\x01 \x01(\t\x12\x11\n\taudiences\x18\x02 \x01(\tBk\n\x0e\x63om.google.apiB\tAuthProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.auth_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\tAuthProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_AUTHENTICATION"]._serialized_start = 37 _globals["_AUTHENTICATION"]._serialized_end = 145 _globals["_AUTHENTICATIONRULE"]._serialized_start = 148 _globals["_AUTHENTICATIONRULE"]._serialized_end = 317 _globals["_JWTLOCATION"]._serialized_start = 319 _globals["_JWTLOCATION"]._serialized_end = 413 _globals["_AUTHPROVIDER"]._serialized_start = 416 _globals["_AUTHPROVIDER"]._serialized_end = 570 _globals["_OAUTHREQUIREMENTS"]._serialized_start = 572 _globals["_OAUTHREQUIREMENTS"]._serialized_end = 617 _globals["_AUTHREQUIREMENT"]._serialized_start = 619 _globals["_AUTHREQUIREMENT"]._serialized_end = 676 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/auth_pb2.pyi0000644000000000000000000001034415177035226021737 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Authentication(_message.Message): __slots__ = ("rules", "providers") RULES_FIELD_NUMBER: _ClassVar[int] PROVIDERS_FIELD_NUMBER: _ClassVar[int] rules: _containers.RepeatedCompositeFieldContainer[AuthenticationRule] providers: _containers.RepeatedCompositeFieldContainer[AuthProvider] def __init__( self, rules: _Optional[_Iterable[_Union[AuthenticationRule, _Mapping]]] = ..., providers: _Optional[_Iterable[_Union[AuthProvider, _Mapping]]] = ..., ) -> None: ... class AuthenticationRule(_message.Message): __slots__ = ("selector", "oauth", "allow_without_credential", "requirements") SELECTOR_FIELD_NUMBER: _ClassVar[int] OAUTH_FIELD_NUMBER: _ClassVar[int] ALLOW_WITHOUT_CREDENTIAL_FIELD_NUMBER: _ClassVar[int] REQUIREMENTS_FIELD_NUMBER: _ClassVar[int] selector: str oauth: OAuthRequirements allow_without_credential: bool requirements: _containers.RepeatedCompositeFieldContainer[AuthRequirement] def __init__( self, selector: _Optional[str] = ..., oauth: _Optional[_Union[OAuthRequirements, _Mapping]] = ..., allow_without_credential: bool = ..., requirements: _Optional[_Iterable[_Union[AuthRequirement, _Mapping]]] = ..., ) -> None: ... class JwtLocation(_message.Message): __slots__ = ("header", "query", "cookie", "value_prefix") HEADER_FIELD_NUMBER: _ClassVar[int] QUERY_FIELD_NUMBER: _ClassVar[int] COOKIE_FIELD_NUMBER: _ClassVar[int] VALUE_PREFIX_FIELD_NUMBER: _ClassVar[int] header: str query: str cookie: str value_prefix: str def __init__( self, header: _Optional[str] = ..., query: _Optional[str] = ..., cookie: _Optional[str] = ..., value_prefix: _Optional[str] = ..., ) -> None: ... class AuthProvider(_message.Message): __slots__ = ( "id", "issuer", "jwks_uri", "audiences", "authorization_url", "jwt_locations", ) ID_FIELD_NUMBER: _ClassVar[int] ISSUER_FIELD_NUMBER: _ClassVar[int] JWKS_URI_FIELD_NUMBER: _ClassVar[int] AUDIENCES_FIELD_NUMBER: _ClassVar[int] AUTHORIZATION_URL_FIELD_NUMBER: _ClassVar[int] JWT_LOCATIONS_FIELD_NUMBER: _ClassVar[int] id: str issuer: str jwks_uri: str audiences: str authorization_url: str jwt_locations: _containers.RepeatedCompositeFieldContainer[JwtLocation] def __init__( self, id: _Optional[str] = ..., issuer: _Optional[str] = ..., jwks_uri: _Optional[str] = ..., audiences: _Optional[str] = ..., authorization_url: _Optional[str] = ..., jwt_locations: _Optional[_Iterable[_Union[JwtLocation, _Mapping]]] = ..., ) -> None: ... class OAuthRequirements(_message.Message): __slots__ = ("canonical_scopes",) CANONICAL_SCOPES_FIELD_NUMBER: _ClassVar[int] canonical_scopes: str def __init__(self, canonical_scopes: _Optional[str] = ...) -> None: ... class AuthRequirement(_message.Message): __slots__ = ("provider_id", "audiences") PROVIDER_ID_FIELD_NUMBER: _ClassVar[int] AUDIENCES_FIELD_NUMBER: _ClassVar[int] provider_id: str audiences: str def __init__( self, provider_id: _Optional[str] = ..., audiences: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/backend.proto0000644000000000000000000001667115177035221022170 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "BackendProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // `Backend` defines the backend configuration for a service. message Backend { // A list of API backend rules that apply to individual API methods. // // **NOTE:** All service configuration rules follow "last one wins" order. repeated BackendRule rules = 1; } // A backend rule provides configuration for an individual API element. message BackendRule { // Path Translation specifies how to combine the backend address with the // request path in order to produce the appropriate forwarding URL for the // request. // // Path Translation is applicable only to HTTP-based backends. Backends which // do not accept requests over HTTP/HTTPS should leave `path_translation` // unspecified. enum PathTranslation { PATH_TRANSLATION_UNSPECIFIED = 0; // Use the backend address as-is, with no modification to the path. If the // URL pattern contains variables, the variable names and values will be // appended to the query string. If a query string parameter and a URL // pattern variable have the same name, this may result in duplicate keys in // the query string. // // # Examples // // Given the following operation config: // // Method path: /api/company/{cid}/user/{uid} // Backend address: https://example.cloudfunctions.net/getUser // // Requests to the following request paths will call the backend at the // translated path: // // Request path: /api/company/widgetworks/user/johndoe // Translated: // https://example.cloudfunctions.net/getUser?cid=widgetworks&uid=johndoe // // Request path: /api/company/widgetworks/user/johndoe?timezone=EST // Translated: // https://example.cloudfunctions.net/getUser?timezone=EST&cid=widgetworks&uid=johndoe CONSTANT_ADDRESS = 1; // The request path will be appended to the backend address. // // # Examples // // Given the following operation config: // // Method path: /api/company/{cid}/user/{uid} // Backend address: https://example.appspot.com // // Requests to the following request paths will call the backend at the // translated path: // // Request path: /api/company/widgetworks/user/johndoe // Translated: // https://example.appspot.com/api/company/widgetworks/user/johndoe // // Request path: /api/company/widgetworks/user/johndoe?timezone=EST // Translated: // https://example.appspot.com/api/company/widgetworks/user/johndoe?timezone=EST APPEND_PATH_TO_ADDRESS = 2; } // Selects the methods to which this rule applies. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. string selector = 1; // The address of the API backend. // // The scheme is used to determine the backend protocol and security. // The following schemes are accepted: // // SCHEME PROTOCOL SECURITY // http:// HTTP None // https:// HTTP TLS // grpc:// gRPC None // grpcs:// gRPC TLS // // It is recommended to explicitly include a scheme. Leaving out the scheme // may cause constrasting behaviors across platforms. // // If the port is unspecified, the default is: // - 80 for schemes without TLS // - 443 for schemes with TLS // // For HTTP backends, use [protocol][google.api.BackendRule.protocol] // to specify the protocol version. string address = 2; // The number of seconds to wait for a response from a request. The default // varies based on the request protocol and deployment environment. double deadline = 3; // Deprecated, do not use. double min_deadline = 4 [deprecated = true]; // The number of seconds to wait for the completion of a long running // operation. The default is no deadline. double operation_deadline = 5; // Path translation specifies how to combine the backend address with the // request path in order to produce the appropriate forwarding URL for the // request. See [PathTranslation][google.api.BackendRule.PathTranslation] for // more details. PathTranslation path_translation = 6; // Authentication settings used by the backend. // // These are typically used to provide service management functionality to // a backend served on a publicly-routable URL. The `authentication` // details should match the authentication behavior used by the backend. // // For example, specifying `jwt_audience` implies that the backend expects // authentication via a JWT. // // When authentication is unspecified, the resulting behavior is the same // as `disable_auth` set to `true`. // // Refer to https://developers.google.com/identity/protocols/OpenIDConnect for // JWT ID token. oneof authentication { // The JWT audience is used when generating a JWT ID token for the backend. // This ID token will be added in the HTTP "authorization" header, and sent // to the backend. string jwt_audience = 7; // When disable_auth is true, a JWT ID token won't be generated and the // original "Authorization" HTTP header will be preserved. If the header is // used to carry the original token and is expected by the backend, this // field must be set to true to preserve the header. bool disable_auth = 8; } // The protocol used for sending a request to the backend. // The supported values are "http/1.1" and "h2". // // The default value is inferred from the scheme in the // [address][google.api.BackendRule.address] field: // // SCHEME PROTOCOL // http:// http/1.1 // https:// http/1.1 // grpc:// h2 // grpcs:// h2 // // For secure HTTP backends (https://) that support HTTP/2, set this field // to "h2" for improved performance. // // Configuring this field to non-default values is only supported for secure // HTTP backends. This field will be ignored for all other backends. // // See // https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids // for more details on the supported values. string protocol = 9; // The map between request protocol and the backend address. map overrides_by_request_protocol = 10; // The load balancing policy used for connection to the application backend. // // Defined as an arbitrary string to accomondate custom load balancing // policies supported by the underlying channel, but suggest most users use // one of the standard policies, such as the default, "RoundRobin". string load_balancing_policy = 11; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/backend_pb2.py0000644000000000000000000000736215177035226022222 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/backend.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x18google/api/backend.proto\x12\ngoogle.api"1\n\x07\x42\x61\x63kend\x12&\n\x05rules\x18\x01 \x03(\x0b\x32\x17.google.api.BackendRule"\xd1\x04\n\x0b\x42\x61\x63kendRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\t\x12\x10\n\x08\x64\x65\x61\x64line\x18\x03 \x01(\x01\x12\x18\n\x0cmin_deadline\x18\x04 \x01(\x01\x42\x02\x18\x01\x12\x1a\n\x12operation_deadline\x18\x05 \x01(\x01\x12\x41\n\x10path_translation\x18\x06 \x01(\x0e\x32\'.google.api.BackendRule.PathTranslation\x12\x16\n\x0cjwt_audience\x18\x07 \x01(\tH\x00\x12\x16\n\x0c\x64isable_auth\x18\x08 \x01(\x08H\x00\x12\x10\n\x08protocol\x18\t \x01(\t\x12^\n\x1doverrides_by_request_protocol\x18\n \x03(\x0b\x32\x37.google.api.BackendRule.OverridesByRequestProtocolEntry\x12\x1d\n\x15load_balancing_policy\x18\x0b \x01(\t\x1aZ\n\x1fOverridesByRequestProtocolEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12&\n\x05value\x18\x02 \x01(\x0b\x32\x17.google.api.BackendRule:\x02\x38\x01"e\n\x0fPathTranslation\x12 \n\x1cPATH_TRANSLATION_UNSPECIFIED\x10\x00\x12\x14\n\x10\x43ONSTANT_ADDRESS\x10\x01\x12\x1a\n\x16\x41PPEND_PATH_TO_ADDRESS\x10\x02\x42\x10\n\x0e\x61uthenticationBn\n\x0e\x63om.google.apiB\x0c\x42\x61\x63kendProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.backend_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\014BackendProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_BACKENDRULE_OVERRIDESBYREQUESTPROTOCOLENTRY"]._options = None _globals[ "_BACKENDRULE_OVERRIDESBYREQUESTPROTOCOLENTRY" ]._serialized_options = b"8\001" _globals["_BACKENDRULE"].fields_by_name["min_deadline"]._options = None _globals["_BACKENDRULE"].fields_by_name[ "min_deadline" ]._serialized_options = b"\030\001" _globals["_BACKEND"]._serialized_start = 40 _globals["_BACKEND"]._serialized_end = 89 _globals["_BACKENDRULE"]._serialized_start = 92 _globals["_BACKENDRULE"]._serialized_end = 685 _globals["_BACKENDRULE_OVERRIDESBYREQUESTPROTOCOLENTRY"]._serialized_start = 474 _globals["_BACKENDRULE_OVERRIDESBYREQUESTPROTOCOLENTRY"]._serialized_end = 564 _globals["_BACKENDRULE_PATHTRANSLATION"]._serialized_start = 566 _globals["_BACKENDRULE_PATHTRANSLATION"]._serialized_end = 667 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/backend_pb2.pyi0000644000000000000000000000767315177035223022375 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class Backend(_message.Message): __slots__ = ("rules",) RULES_FIELD_NUMBER: _ClassVar[int] rules: _containers.RepeatedCompositeFieldContainer[BackendRule] def __init__( self, rules: _Optional[_Iterable[_Union[BackendRule, _Mapping]]] = ... ) -> None: ... class BackendRule(_message.Message): __slots__ = ( "selector", "address", "deadline", "min_deadline", "operation_deadline", "path_translation", "jwt_audience", "disable_auth", "protocol", "overrides_by_request_protocol", "load_balancing_policy", ) class PathTranslation(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () PATH_TRANSLATION_UNSPECIFIED: _ClassVar[BackendRule.PathTranslation] CONSTANT_ADDRESS: _ClassVar[BackendRule.PathTranslation] APPEND_PATH_TO_ADDRESS: _ClassVar[BackendRule.PathTranslation] PATH_TRANSLATION_UNSPECIFIED: BackendRule.PathTranslation CONSTANT_ADDRESS: BackendRule.PathTranslation APPEND_PATH_TO_ADDRESS: BackendRule.PathTranslation class OverridesByRequestProtocolEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: BackendRule def __init__( self, key: _Optional[str] = ..., value: _Optional[_Union[BackendRule, _Mapping]] = ..., ) -> None: ... SELECTOR_FIELD_NUMBER: _ClassVar[int] ADDRESS_FIELD_NUMBER: _ClassVar[int] DEADLINE_FIELD_NUMBER: _ClassVar[int] MIN_DEADLINE_FIELD_NUMBER: _ClassVar[int] OPERATION_DEADLINE_FIELD_NUMBER: _ClassVar[int] PATH_TRANSLATION_FIELD_NUMBER: _ClassVar[int] JWT_AUDIENCE_FIELD_NUMBER: _ClassVar[int] DISABLE_AUTH_FIELD_NUMBER: _ClassVar[int] PROTOCOL_FIELD_NUMBER: _ClassVar[int] OVERRIDES_BY_REQUEST_PROTOCOL_FIELD_NUMBER: _ClassVar[int] LOAD_BALANCING_POLICY_FIELD_NUMBER: _ClassVar[int] selector: str address: str deadline: float min_deadline: float operation_deadline: float path_translation: BackendRule.PathTranslation jwt_audience: str disable_auth: bool protocol: str overrides_by_request_protocol: _containers.MessageMap[str, BackendRule] load_balancing_policy: str def __init__( self, selector: _Optional[str] = ..., address: _Optional[str] = ..., deadline: _Optional[float] = ..., min_deadline: _Optional[float] = ..., operation_deadline: _Optional[float] = ..., path_translation: _Optional[_Union[BackendRule.PathTranslation, str]] = ..., jwt_audience: _Optional[str] = ..., disable_auth: bool = ..., protocol: _Optional[str] = ..., overrides_by_request_protocol: _Optional[_Mapping[str, BackendRule]] = ..., load_balancing_policy: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/billing.proto0000644000000000000000000000576615177035221022224 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "BillingProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Billing related configuration of the service. // // The following example shows how to configure monitored resources and metrics // for billing, `consumer_destinations` is the only supported destination and // the monitored resources need at least one label key // `cloud.googleapis.com/location` to indicate the location of the billing // usage, using different monitored resources between monitoring and billing is // recommended so they can be evolved independently: // // // monitored_resources: // - type: library.googleapis.com/billing_branch // labels: // - key: cloud.googleapis.com/location // description: | // Predefined label to support billing location restriction. // - key: city // description: | // Custom label to define the city where the library branch is located // in. // - key: name // description: Custom label to define the name of the library branch. // metrics: // - name: library.googleapis.com/book/borrowed_count // metric_kind: DELTA // value_type: INT64 // unit: "1" // billing: // consumer_destinations: // - monitored_resource: library.googleapis.com/billing_branch // metrics: // - library.googleapis.com/book/borrowed_count message Billing { // Configuration of a specific billing destination (Currently only support // bill against consumer project). message BillingDestination { // The monitored resource type. The type must be defined in // [Service.monitored_resources][google.api.Service.monitored_resources] // section. string monitored_resource = 1; // Names of the metrics to report to this billing destination. // Each name must be defined in // [Service.metrics][google.api.Service.metrics] section. repeated string metrics = 2; } // Billing configurations for sending metrics to the consumer project. // There can be multiple consumer destinations per service, each one must have // a different monitored resource type. A metric can be used in at most // one consumer destination. repeated BillingDestination consumer_destinations = 8; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/billing_pb2.py0000644000000000000000000000441315177035223022242 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/billing.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x18google/api/billing.proto\x12\ngoogle.api"\x93\x01\n\x07\x42illing\x12\x45\n\x15\x63onsumer_destinations\x18\x08 \x03(\x0b\x32&.google.api.Billing.BillingDestination\x1a\x41\n\x12\x42illingDestination\x12\x1a\n\x12monitored_resource\x18\x01 \x01(\t\x12\x0f\n\x07metrics\x18\x02 \x03(\tBn\n\x0e\x63om.google.apiB\x0c\x42illingProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.billing_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\014BillingProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_BILLING"]._serialized_start = 41 _globals["_BILLING"]._serialized_end = 188 _globals["_BILLING_BILLINGDESTINATION"]._serialized_start = 123 _globals["_BILLING_BILLINGDESTINATION"]._serialized_end = 188 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/billing_pb2.pyi0000644000000000000000000000351715177035222022416 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Billing(_message.Message): __slots__ = ("consumer_destinations",) class BillingDestination(_message.Message): __slots__ = ("monitored_resource", "metrics") MONITORED_RESOURCE_FIELD_NUMBER: _ClassVar[int] METRICS_FIELD_NUMBER: _ClassVar[int] monitored_resource: str metrics: _containers.RepeatedScalarFieldContainer[str] def __init__( self, monitored_resource: _Optional[str] = ..., metrics: _Optional[_Iterable[str]] = ..., ) -> None: ... CONSUMER_DESTINATIONS_FIELD_NUMBER: _ClassVar[int] consumer_destinations: _containers.RepeatedCompositeFieldContainer[ Billing.BillingDestination ] def __init__( self, consumer_destinations: _Optional[ _Iterable[_Union[Billing.BillingDestination, _Mapping]] ] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/client.proto0000644000000000000000000005172415177035227022063 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/api/launch_stage.proto"; import "google/protobuf/descriptor.proto"; import "google/protobuf/duration.proto"; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "ClientProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.MethodOptions { // A definition of a client library method signature. // // In client libraries, each proto RPC corresponds to one or more methods // which the end user is able to call, and calls the underlying RPC. // Normally, this method receives a single argument (a struct or instance // corresponding to the RPC request object). Defining this field will // add one or more overloads providing flattened or simpler method signatures // in some languages. // // The fields on the method signature are provided as a comma-separated // string. // // For example, the proto RPC and annotation: // // rpc CreateSubscription(CreateSubscriptionRequest) // returns (Subscription) { // option (google.api.method_signature) = "name,topic"; // } // // Would add the following Java overload (in addition to the method accepting // the request object): // // public final Subscription createSubscription(String name, String topic) // // The following backwards-compatibility guidelines apply: // // * Adding this annotation to an unannotated method is backwards // compatible. // * Adding this annotation to a method which already has existing // method signature annotations is backwards compatible if and only if // the new method signature annotation is last in the sequence. // * Modifying or removing an existing method signature annotation is // a breaking change. // * Re-ordering existing method signature annotations is a breaking // change. repeated string method_signature = 1051; } extend google.protobuf.ServiceOptions { // The hostname for this service. // This should be specified with no prefix or protocol. // // Example: // // service Foo { // option (google.api.default_host) = "foo.googleapi.com"; // ... // } string default_host = 1049; // OAuth scopes needed for the client. // // Example: // // service Foo { // option (google.api.oauth_scopes) = \ // "https://www.googleapis.com/auth/cloud-platform"; // ... // } // // If there is more than one scope, use a comma-separated string: // // Example: // // service Foo { // option (google.api.oauth_scopes) = \ // "https://www.googleapis.com/auth/cloud-platform," // "https://www.googleapis.com/auth/monitoring"; // ... // } string oauth_scopes = 1050; // The API version of this service, which should be sent by version-aware // clients to the service. This allows services to abide by the schema and // behavior of the service at the time this API version was deployed. // The format of the API version must be treated as opaque by clients. // Services may use a format with an apparent structure, but clients must // not rely on this to determine components within an API version, or attempt // to construct other valid API versions. Note that this is for upcoming // functionality and may not be implemented for all services. // // Example: // // service Foo { // option (google.api.api_version) = "v1_20230821_preview"; // } string api_version = 525000001; } // Required information for every language. message CommonLanguageSettings { // Link to automatically generated reference documentation. Example: // https://cloud.google.com/nodejs/docs/reference/asset/latest string reference_docs_uri = 1 [deprecated = true]; // The destination where API teams want this client library to be published. repeated ClientLibraryDestination destinations = 2; // Configuration for which RPCs should be generated in the GAPIC client. // // Note: This field should not be used in most cases. SelectiveGapicGeneration selective_gapic_generation = 3; } // Details about how and where to publish client libraries. message ClientLibrarySettings { // Version of the API to apply these settings to. This is the full protobuf // package for the API, ending in the version element. // Examples: "google.cloud.speech.v1" and "google.spanner.admin.database.v1". string version = 1; // Launch stage of this version of the API. LaunchStage launch_stage = 2; // When using transport=rest, the client request will encode enums as // numbers rather than strings. bool rest_numeric_enums = 3; // Settings for legacy Java features, supported in the Service YAML. JavaSettings java_settings = 21; // Settings for C++ client libraries. CppSettings cpp_settings = 22; // Settings for PHP client libraries. PhpSettings php_settings = 23; // Settings for Python client libraries. PythonSettings python_settings = 24; // Settings for Node client libraries. NodeSettings node_settings = 25; // Settings for .NET client libraries. DotnetSettings dotnet_settings = 26; // Settings for Ruby client libraries. RubySettings ruby_settings = 27; // Settings for Go client libraries. GoSettings go_settings = 28; } // This message configures the settings for publishing [Google Cloud Client // libraries](https://cloud.google.com/apis/docs/cloud-client-libraries) // generated from the service config. message Publishing { // A list of API method settings, e.g. the behavior for methods that use the // long-running operation pattern. repeated MethodSettings method_settings = 2; // Link to a *public* URI where users can report issues. Example: // https://issuetracker.google.com/issues/new?component=190865&template=1161103 string new_issue_uri = 101; // Link to product home page. Example: // https://cloud.google.com/asset-inventory/docs/overview string documentation_uri = 102; // Used as a tracking tag when collecting data about the APIs developer // relations artifacts like docs, packages delivered to package managers, // etc. Example: "speech". string api_short_name = 103; // GitHub label to apply to issues and pull requests opened for this API. string github_label = 104; // GitHub teams to be added to CODEOWNERS in the directory in GitHub // containing source code for the client libraries for this API. repeated string codeowner_github_teams = 105; // A prefix used in sample code when demarking regions to be included in // documentation. string doc_tag_prefix = 106; // For whom the client library is being published. ClientLibraryOrganization organization = 107; // Client library settings. If the same version string appears multiple // times in this list, then the last one wins. Settings from earlier // settings with the same version string are discarded. repeated ClientLibrarySettings library_settings = 109; // Optional link to proto reference documentation. Example: // https://cloud.google.com/pubsub/lite/docs/reference/rpc string proto_reference_documentation_uri = 110; // Optional link to REST reference documentation. Example: // https://cloud.google.com/pubsub/lite/docs/reference/rest string rest_reference_documentation_uri = 111; } // Settings for Java client libraries. message JavaSettings { // The package name to use in Java. Clobbers the java_package option // set in the protobuf. This should be used **only** by APIs // who have already set the language_settings.java.package_name" field // in gapic.yaml. API teams should use the protobuf java_package option // where possible. // // Example of a YAML configuration:: // // publishing: // library_settings: // java_settings: // library_package: com.google.cloud.pubsub.v1 string library_package = 1; // Configure the Java class name to use instead of the service's for its // corresponding generated GAPIC client. Keys are fully-qualified // service names as they appear in the protobuf (including the full // the language_settings.java.interface_names" field in gapic.yaml. API // teams should otherwise use the service name as it appears in the // protobuf. // // Example of a YAML configuration:: // // publishing: // java_settings: // service_class_names: // - google.pubsub.v1.Publisher: TopicAdmin // - google.pubsub.v1.Subscriber: SubscriptionAdmin map service_class_names = 2; // Some settings. CommonLanguageSettings common = 3; } // Settings for C++ client libraries. message CppSettings { // Some settings. CommonLanguageSettings common = 1; } // Settings for Php client libraries. message PhpSettings { // Some settings. CommonLanguageSettings common = 1; // The package name to use in Php. Clobbers the php_namespace option // set in the protobuf. This should be used **only** by APIs // who have already set the language_settings.php.package_name" field // in gapic.yaml. API teams should use the protobuf php_namespace option // where possible. // // Example of a YAML configuration:: // // publishing: // library_settings: // php_settings: // library_package: Google\Cloud\PubSub\V1 string library_package = 2; } // Settings for Python client libraries. message PythonSettings { // Experimental features to be included during client library generation. // These fields will be deprecated once the feature graduates and is enabled // by default. message ExperimentalFeatures { // Enables generation of asynchronous REST clients if `rest` transport is // enabled. By default, asynchronous REST clients will not be generated. // This feature will be enabled by default 1 month after launching the // feature in preview packages. bool rest_async_io_enabled = 1; // Enables generation of protobuf code using new types that are more // Pythonic which are included in `protobuf>=5.29.x`. This feature will be // enabled by default 1 month after launching the feature in preview // packages. bool protobuf_pythonic_types_enabled = 2; // Disables generation of an unversioned Python package for this client // library. This means that the module names will need to be versioned in // import statements. For example `import google.cloud.library_v2` instead // of `import google.cloud.library`. bool unversioned_package_disabled = 3; } // Some settings. CommonLanguageSettings common = 1; // Experimental features to be included during client library generation. ExperimentalFeatures experimental_features = 2; } // Settings for Node client libraries. message NodeSettings { // Some settings. CommonLanguageSettings common = 1; } // Settings for Dotnet client libraries. message DotnetSettings { // Some settings. CommonLanguageSettings common = 1; // Map from original service names to renamed versions. // This is used when the default generated types // would cause a naming conflict. (Neither name is // fully-qualified.) // Example: Subscriber to SubscriberServiceApi. map renamed_services = 2; // Map from full resource types to the effective short name // for the resource. This is used when otherwise resource // named from different services would cause naming collisions. // Example entry: // "datalabeling.googleapis.com/Dataset": "DataLabelingDataset" map renamed_resources = 3; // List of full resource types to ignore during generation. // This is typically used for API-specific Location resources, // which should be handled by the generator as if they were actually // the common Location resources. // Example entry: "documentai.googleapis.com/Location" repeated string ignored_resources = 4; // Namespaces which must be aliased in snippets due to // a known (but non-generator-predictable) naming collision repeated string forced_namespace_aliases = 5; // Method signatures (in the form "service.method(signature)") // which are provided separately, so shouldn't be generated. // Snippets *calling* these methods are still generated, however. repeated string handwritten_signatures = 6; } // Settings for Ruby client libraries. message RubySettings { // Some settings. CommonLanguageSettings common = 1; } // Settings for Go client libraries. message GoSettings { // Some settings. CommonLanguageSettings common = 1; // Map of service names to renamed services. Keys are the package relative // service names and values are the name to be used for the service client // and call options. // // Example: // // publishing: // go_settings: // renamed_services: // Publisher: TopicAdmin map renamed_services = 2; } // Describes the generator configuration for a method. message MethodSettings { // Describes settings to use when generating API methods that use the // long-running operation pattern. // All default values below are from those used in the client library // generators (e.g. // [Java](https://github.com/googleapis/gapic-generator-java/blob/04c2faa191a9b5a10b92392fe8482279c4404803/src/main/java/com/google/api/generator/gapic/composer/common/RetrySettingsComposer.java)). message LongRunning { // Initial delay after which the first poll request will be made. // Default value: 5 seconds. google.protobuf.Duration initial_poll_delay = 1; // Multiplier to gradually increase delay between subsequent polls until it // reaches max_poll_delay. // Default value: 1.5. float poll_delay_multiplier = 2; // Maximum time between two subsequent poll requests. // Default value: 45 seconds. google.protobuf.Duration max_poll_delay = 3; // Total polling timeout. // Default value: 5 minutes. google.protobuf.Duration total_poll_timeout = 4; } // The fully qualified name of the method, for which the options below apply. // This is used to find the method to apply the options. // // Example: // // publishing: // method_settings: // - selector: google.storage.control.v2.StorageControl.CreateFolder // # method settings for CreateFolder... string selector = 1; // Describes settings to use for long-running operations when generating // API methods for RPCs. Complements RPCs that use the annotations in // google/longrunning/operations.proto. // // Example of a YAML configuration:: // // publishing: // method_settings: // - selector: google.cloud.speech.v2.Speech.BatchRecognize // long_running: // initial_poll_delay: 60s # 1 minute // poll_delay_multiplier: 1.5 // max_poll_delay: 360s # 6 minutes // total_poll_timeout: 54000s # 90 minutes LongRunning long_running = 2; // List of top-level fields of the request message, that should be // automatically populated by the client libraries based on their // (google.api.field_info).format. Currently supported format: UUID4. // // Example of a YAML configuration: // // publishing: // method_settings: // - selector: google.example.v1.ExampleService.CreateExample // auto_populated_fields: // - request_id repeated string auto_populated_fields = 3; // Batching configuration for an API method in client libraries. // // Example of a YAML configuration: // // publishing: // method_settings: // - selector: google.example.v1.ExampleService.BatchCreateExample // batching: // element_count_threshold: 1000 // request_byte_threshold: 100000000 // delay_threshold_millis: 10 BatchingConfigProto batching = 4; } // The organization for which the client libraries are being published. // Affects the url where generated docs are published, etc. enum ClientLibraryOrganization { // Not useful. CLIENT_LIBRARY_ORGANIZATION_UNSPECIFIED = 0; // Google Cloud Platform Org. CLOUD = 1; // Ads (Advertising) Org. ADS = 2; // Photos Org. PHOTOS = 3; // Street View Org. STREET_VIEW = 4; // Shopping Org. SHOPPING = 5; // Geo Org. GEO = 6; // Generative AI - https://developers.generativeai.google GENERATIVE_AI = 7; } // To where should client libraries be published? enum ClientLibraryDestination { // Client libraries will neither be generated nor published to package // managers. CLIENT_LIBRARY_DESTINATION_UNSPECIFIED = 0; // Generate the client library in a repo under github.com/googleapis, // but don't publish it to package managers. GITHUB = 10; // Publish the library to package managers like nuget.org and npmjs.com. PACKAGE_MANAGER = 20; } // This message is used to configure the generation of a subset of the RPCs in // a service for client libraries. // // Note: This feature should not be used in most cases. message SelectiveGapicGeneration { // An allowlist of the fully qualified names of RPCs that should be included // on public client surfaces. repeated string methods = 1; // Setting this to true indicates to the client generators that methods // that would be excluded from the generation should instead be generated // in a way that indicates these methods should not be consumed by // end users. How this is expressed is up to individual language // implementations to decide. Some examples may be: added annotations, // obfuscated identifiers, or other language idiomatic patterns. bool generate_omitted_as_internal = 2; } // `BatchingConfigProto` defines the batching configuration for an API method. message BatchingConfigProto { // The thresholds which trigger a batched request to be sent. BatchingSettingsProto thresholds = 1; // The request and response fields used in batching. BatchingDescriptorProto batch_descriptor = 2; } // `BatchingSettingsProto` specifies a set of batching thresholds, each of // which acts as a trigger to send a batch of messages as a request. At least // one threshold must be positive nonzero. message BatchingSettingsProto { // The number of elements of a field collected into a batch which, if // exceeded, causes the batch to be sent. int32 element_count_threshold = 1; // The aggregated size of the batched field which, if exceeded, causes the // batch to be sent. This size is computed by aggregating the sizes of the // request field to be batched, not of the entire request message. int64 request_byte_threshold = 2; // The duration after which a batch should be sent, starting from the addition // of the first message to that batch. google.protobuf.Duration delay_threshold = 3; // The maximum number of elements collected in a batch that could be accepted // by server. int32 element_count_limit = 4; // The maximum size of the request that could be accepted by server. int32 request_byte_limit = 5; // The maximum number of elements allowed by flow control. int32 flow_control_element_limit = 6; // The maximum size of data allowed by flow control. int32 flow_control_byte_limit = 7; // The behavior to take when the flow control limit is exceeded. FlowControlLimitExceededBehaviorProto flow_control_limit_exceeded_behavior = 8; } // The behavior to take when the flow control limit is exceeded. enum FlowControlLimitExceededBehaviorProto { // Default behavior, system-defined. UNSET_BEHAVIOR = 0; // Stop operation, raise error. THROW_EXCEPTION = 1; // Pause operation until limit clears. BLOCK = 2; // Continue operation, disregard limit. IGNORE = 3; } // `BatchingDescriptorProto` specifies the fields of the request message to be // used for batching, and, optionally, the fields of the response message to be // used for demultiplexing. message BatchingDescriptorProto { // The repeated field in the request message to be aggregated by batching. string batched_field = 1; // A list of the fields in the request message. Two requests will be batched // together only if the values of every field specified in // `request_discriminator_fields` is equal between the two requests. repeated string discriminator_fields = 2; // Optional. When present, indicates the field in the response message to be // used to demultiplex the response into multiple response messages, in // correspondence with the multiple request messages originally batched // together. string subresponse_field = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/client_pb2.py0000644000000000000000000003104315177035225022101 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/client.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 from google.api import launch_stage_pb2 as google_dot_api_dot_launch__stage__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x17google/api/client.proto\x12\ngoogle.api\x1a\x1dgoogle/api/launch_stage.proto\x1a google/protobuf/descriptor.proto\x1a\x1egoogle/protobuf/duration.proto"\xbe\x01\n\x16\x43ommonLanguageSettings\x12\x1e\n\x12reference_docs_uri\x18\x01 \x01(\tB\x02\x18\x01\x12:\n\x0c\x64\x65stinations\x18\x02 \x03(\x0e\x32$.google.api.ClientLibraryDestination\x12H\n\x1aselective_gapic_generation\x18\x03 \x01(\x0b\x32$.google.api.SelectiveGapicGeneration"\xfb\x03\n\x15\x43lientLibrarySettings\x12\x0f\n\x07version\x18\x01 \x01(\t\x12-\n\x0claunch_stage\x18\x02 \x01(\x0e\x32\x17.google.api.LaunchStage\x12\x1a\n\x12rest_numeric_enums\x18\x03 \x01(\x08\x12/\n\rjava_settings\x18\x15 \x01(\x0b\x32\x18.google.api.JavaSettings\x12-\n\x0c\x63pp_settings\x18\x16 \x01(\x0b\x32\x17.google.api.CppSettings\x12-\n\x0cphp_settings\x18\x17 \x01(\x0b\x32\x17.google.api.PhpSettings\x12\x33\n\x0fpython_settings\x18\x18 \x01(\x0b\x32\x1a.google.api.PythonSettings\x12/\n\rnode_settings\x18\x19 \x01(\x0b\x32\x18.google.api.NodeSettings\x12\x33\n\x0f\x64otnet_settings\x18\x1a \x01(\x0b\x32\x1a.google.api.DotnetSettings\x12/\n\rruby_settings\x18\x1b \x01(\x0b\x32\x18.google.api.RubySettings\x12+\n\x0bgo_settings\x18\x1c \x01(\x0b\x32\x16.google.api.GoSettings"\xa8\x03\n\nPublishing\x12\x33\n\x0fmethod_settings\x18\x02 \x03(\x0b\x32\x1a.google.api.MethodSettings\x12\x15\n\rnew_issue_uri\x18\x65 \x01(\t\x12\x19\n\x11\x64ocumentation_uri\x18\x66 \x01(\t\x12\x16\n\x0e\x61pi_short_name\x18g \x01(\t\x12\x14\n\x0cgithub_label\x18h \x01(\t\x12\x1e\n\x16\x63odeowner_github_teams\x18i \x03(\t\x12\x16\n\x0e\x64oc_tag_prefix\x18j \x01(\t\x12;\n\x0corganization\x18k \x01(\x0e\x32%.google.api.ClientLibraryOrganization\x12;\n\x10library_settings\x18m \x03(\x0b\x32!.google.api.ClientLibrarySettings\x12)\n!proto_reference_documentation_uri\x18n \x01(\t\x12(\n rest_reference_documentation_uri\x18o \x01(\t"\xe3\x01\n\x0cJavaSettings\x12\x17\n\x0flibrary_package\x18\x01 \x01(\t\x12L\n\x13service_class_names\x18\x02 \x03(\x0b\x32/.google.api.JavaSettings.ServiceClassNamesEntry\x12\x32\n\x06\x63ommon\x18\x03 \x01(\x0b\x32".google.api.CommonLanguageSettings\x1a\x38\n\x16ServiceClassNamesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"A\n\x0b\x43ppSettings\x12\x32\n\x06\x63ommon\x18\x01 \x01(\x0b\x32".google.api.CommonLanguageSettings"Z\n\x0bPhpSettings\x12\x32\n\x06\x63ommon\x18\x01 \x01(\x0b\x32".google.api.CommonLanguageSettings\x12\x17\n\x0flibrary_package\x18\x02 \x01(\t"\x9b\x02\n\x0ePythonSettings\x12\x32\n\x06\x63ommon\x18\x01 \x01(\x0b\x32".google.api.CommonLanguageSettings\x12N\n\x15\x65xperimental_features\x18\x02 \x01(\x0b\x32/.google.api.PythonSettings.ExperimentalFeatures\x1a\x84\x01\n\x14\x45xperimentalFeatures\x12\x1d\n\x15rest_async_io_enabled\x18\x01 \x01(\x08\x12\'\n\x1fprotobuf_pythonic_types_enabled\x18\x02 \x01(\x08\x12$\n\x1cunversioned_package_disabled\x18\x03 \x01(\x08"B\n\x0cNodeSettings\x12\x32\n\x06\x63ommon\x18\x01 \x01(\x0b\x32".google.api.CommonLanguageSettings"\xaa\x03\n\x0e\x44otnetSettings\x12\x32\n\x06\x63ommon\x18\x01 \x01(\x0b\x32".google.api.CommonLanguageSettings\x12I\n\x10renamed_services\x18\x02 \x03(\x0b\x32/.google.api.DotnetSettings.RenamedServicesEntry\x12K\n\x11renamed_resources\x18\x03 \x03(\x0b\x32\x30.google.api.DotnetSettings.RenamedResourcesEntry\x12\x19\n\x11ignored_resources\x18\x04 \x03(\t\x12 \n\x18\x66orced_namespace_aliases\x18\x05 \x03(\t\x12\x1e\n\x16handwritten_signatures\x18\x06 \x03(\t\x1a\x36\n\x14RenamedServicesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x37\n\x15RenamedResourcesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"B\n\x0cRubySettings\x12\x32\n\x06\x63ommon\x18\x01 \x01(\x0b\x32".google.api.CommonLanguageSettings"\xbf\x01\n\nGoSettings\x12\x32\n\x06\x63ommon\x18\x01 \x01(\x0b\x32".google.api.CommonLanguageSettings\x12\x45\n\x10renamed_services\x18\x02 \x03(\x0b\x32+.google.api.GoSettings.RenamedServicesEntry\x1a\x36\n\x14RenamedServicesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x82\x03\n\x0eMethodSettings\x12\x10\n\x08selector\x18\x01 \x01(\t\x12<\n\x0clong_running\x18\x02 \x01(\x0b\x32&.google.api.MethodSettings.LongRunning\x12\x1d\n\x15\x61uto_populated_fields\x18\x03 \x03(\t\x12\x31\n\x08\x62\x61tching\x18\x04 \x01(\x0b\x32\x1f.google.api.BatchingConfigProto\x1a\xcd\x01\n\x0bLongRunning\x12\x35\n\x12initial_poll_delay\x18\x01 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x1d\n\x15poll_delay_multiplier\x18\x02 \x01(\x02\x12\x31\n\x0emax_poll_delay\x18\x03 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x35\n\x12total_poll_timeout\x18\x04 \x01(\x0b\x32\x19.google.protobuf.Duration"Q\n\x18SelectiveGapicGeneration\x12\x0f\n\x07methods\x18\x01 \x03(\t\x12$\n\x1cgenerate_omitted_as_internal\x18\x02 \x01(\x08"\x8b\x01\n\x13\x42\x61tchingConfigProto\x12\x35\n\nthresholds\x18\x01 \x01(\x0b\x32!.google.api.BatchingSettingsProto\x12=\n\x10\x62\x61tch_descriptor\x18\x02 \x01(\x0b\x32#.google.api.BatchingDescriptorProto"\xeb\x02\n\x15\x42\x61tchingSettingsProto\x12\x1f\n\x17\x65lement_count_threshold\x18\x01 \x01(\x05\x12\x1e\n\x16request_byte_threshold\x18\x02 \x01(\x03\x12\x32\n\x0f\x64\x65lay_threshold\x18\x03 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x1b\n\x13\x65lement_count_limit\x18\x04 \x01(\x05\x12\x1a\n\x12request_byte_limit\x18\x05 \x01(\x05\x12"\n\x1a\x66low_control_element_limit\x18\x06 \x01(\x05\x12\x1f\n\x17\x66low_control_byte_limit\x18\x07 \x01(\x05\x12_\n$flow_control_limit_exceeded_behavior\x18\x08 \x01(\x0e\x32\x31.google.api.FlowControlLimitExceededBehaviorProto"i\n\x17\x42\x61tchingDescriptorProto\x12\x15\n\rbatched_field\x18\x01 \x01(\t\x12\x1c\n\x14\x64iscriminator_fields\x18\x02 \x03(\t\x12\x19\n\x11subresponse_field\x18\x03 \x01(\t*\xa3\x01\n\x19\x43lientLibraryOrganization\x12+\n\'CLIENT_LIBRARY_ORGANIZATION_UNSPECIFIED\x10\x00\x12\t\n\x05\x43LOUD\x10\x01\x12\x07\n\x03\x41\x44S\x10\x02\x12\n\n\x06PHOTOS\x10\x03\x12\x0f\n\x0bSTREET_VIEW\x10\x04\x12\x0c\n\x08SHOPPING\x10\x05\x12\x07\n\x03GEO\x10\x06\x12\x11\n\rGENERATIVE_AI\x10\x07*g\n\x18\x43lientLibraryDestination\x12*\n&CLIENT_LIBRARY_DESTINATION_UNSPECIFIED\x10\x00\x12\n\n\x06GITHUB\x10\n\x12\x13\n\x0fPACKAGE_MANAGER\x10\x14*g\n%FlowControlLimitExceededBehaviorProto\x12\x12\n\x0eUNSET_BEHAVIOR\x10\x00\x12\x13\n\x0fTHROW_EXCEPTION\x10\x01\x12\t\n\x05\x42LOCK\x10\x02\x12\n\n\x06IGNORE\x10\x03:9\n\x10method_signature\x12\x1e.google.protobuf.MethodOptions\x18\x9b\x08 \x03(\t:6\n\x0c\x64\x65\x66\x61ult_host\x12\x1f.google.protobuf.ServiceOptions\x18\x99\x08 \x01(\t:6\n\x0coauth_scopes\x12\x1f.google.protobuf.ServiceOptions\x18\x9a\x08 \x01(\t:8\n\x0b\x61pi_version\x12\x1f.google.protobuf.ServiceOptions\x18\xc1\xba\xab\xfa\x01 \x01(\tBi\n\x0e\x63om.google.apiB\x0b\x43lientProtoP\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.client_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\013ClientProtoP\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\242\002\004GAPI" _globals["_COMMONLANGUAGESETTINGS"].fields_by_name[ "reference_docs_uri" ]._options = None _globals["_COMMONLANGUAGESETTINGS"].fields_by_name[ "reference_docs_uri" ]._serialized_options = b"\030\001" _globals["_JAVASETTINGS_SERVICECLASSNAMESENTRY"]._options = None _globals["_JAVASETTINGS_SERVICECLASSNAMESENTRY"]._serialized_options = b"8\001" _globals["_DOTNETSETTINGS_RENAMEDSERVICESENTRY"]._options = None _globals["_DOTNETSETTINGS_RENAMEDSERVICESENTRY"]._serialized_options = b"8\001" _globals["_DOTNETSETTINGS_RENAMEDRESOURCESENTRY"]._options = None _globals["_DOTNETSETTINGS_RENAMEDRESOURCESENTRY"]._serialized_options = b"8\001" _globals["_GOSETTINGS_RENAMEDSERVICESENTRY"]._options = None _globals["_GOSETTINGS_RENAMEDSERVICESENTRY"]._serialized_options = b"8\001" _globals["_CLIENTLIBRARYORGANIZATION"]._serialized_start = 3788 _globals["_CLIENTLIBRARYORGANIZATION"]._serialized_end = 3951 _globals["_CLIENTLIBRARYDESTINATION"]._serialized_start = 3953 _globals["_CLIENTLIBRARYDESTINATION"]._serialized_end = 4056 _globals["_FLOWCONTROLLIMITEXCEEDEDBEHAVIORPROTO"]._serialized_start = 4058 _globals["_FLOWCONTROLLIMITEXCEEDEDBEHAVIORPROTO"]._serialized_end = 4161 _globals["_COMMONLANGUAGESETTINGS"]._serialized_start = 137 _globals["_COMMONLANGUAGESETTINGS"]._serialized_end = 327 _globals["_CLIENTLIBRARYSETTINGS"]._serialized_start = 330 _globals["_CLIENTLIBRARYSETTINGS"]._serialized_end = 837 _globals["_PUBLISHING"]._serialized_start = 840 _globals["_PUBLISHING"]._serialized_end = 1264 _globals["_JAVASETTINGS"]._serialized_start = 1267 _globals["_JAVASETTINGS"]._serialized_end = 1494 _globals["_JAVASETTINGS_SERVICECLASSNAMESENTRY"]._serialized_start = 1438 _globals["_JAVASETTINGS_SERVICECLASSNAMESENTRY"]._serialized_end = 1494 _globals["_CPPSETTINGS"]._serialized_start = 1496 _globals["_CPPSETTINGS"]._serialized_end = 1561 _globals["_PHPSETTINGS"]._serialized_start = 1563 _globals["_PHPSETTINGS"]._serialized_end = 1653 _globals["_PYTHONSETTINGS"]._serialized_start = 1656 _globals["_PYTHONSETTINGS"]._serialized_end = 1939 _globals["_PYTHONSETTINGS_EXPERIMENTALFEATURES"]._serialized_start = 1807 _globals["_PYTHONSETTINGS_EXPERIMENTALFEATURES"]._serialized_end = 1939 _globals["_NODESETTINGS"]._serialized_start = 1941 _globals["_NODESETTINGS"]._serialized_end = 2007 _globals["_DOTNETSETTINGS"]._serialized_start = 2010 _globals["_DOTNETSETTINGS"]._serialized_end = 2436 _globals["_DOTNETSETTINGS_RENAMEDSERVICESENTRY"]._serialized_start = 2325 _globals["_DOTNETSETTINGS_RENAMEDSERVICESENTRY"]._serialized_end = 2379 _globals["_DOTNETSETTINGS_RENAMEDRESOURCESENTRY"]._serialized_start = 2381 _globals["_DOTNETSETTINGS_RENAMEDRESOURCESENTRY"]._serialized_end = 2436 _globals["_RUBYSETTINGS"]._serialized_start = 2438 _globals["_RUBYSETTINGS"]._serialized_end = 2504 _globals["_GOSETTINGS"]._serialized_start = 2507 _globals["_GOSETTINGS"]._serialized_end = 2698 _globals["_GOSETTINGS_RENAMEDSERVICESENTRY"]._serialized_start = 2325 _globals["_GOSETTINGS_RENAMEDSERVICESENTRY"]._serialized_end = 2379 _globals["_METHODSETTINGS"]._serialized_start = 2701 _globals["_METHODSETTINGS"]._serialized_end = 3087 _globals["_METHODSETTINGS_LONGRUNNING"]._serialized_start = 2882 _globals["_METHODSETTINGS_LONGRUNNING"]._serialized_end = 3087 _globals["_SELECTIVEGAPICGENERATION"]._serialized_start = 3089 _globals["_SELECTIVEGAPICGENERATION"]._serialized_end = 3170 _globals["_BATCHINGCONFIGPROTO"]._serialized_start = 3173 _globals["_BATCHINGCONFIGPROTO"]._serialized_end = 3312 _globals["_BATCHINGSETTINGSPROTO"]._serialized_start = 3315 _globals["_BATCHINGSETTINGSPROTO"]._serialized_end = 3678 _globals["_BATCHINGDESCRIPTORPROTO"]._serialized_start = 3680 _globals["_BATCHINGDESCRIPTORPROTO"]._serialized_end = 3785 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/client_pb2.pyi0000644000000000000000000004645115177035222022260 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf import duration_pb2 as _duration_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper from google.api import launch_stage_pb2 as _launch_stage_pb2 DESCRIPTOR: _descriptor.FileDescriptor class ClientLibraryOrganization(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () CLIENT_LIBRARY_ORGANIZATION_UNSPECIFIED: _ClassVar[ClientLibraryOrganization] CLOUD: _ClassVar[ClientLibraryOrganization] ADS: _ClassVar[ClientLibraryOrganization] PHOTOS: _ClassVar[ClientLibraryOrganization] STREET_VIEW: _ClassVar[ClientLibraryOrganization] SHOPPING: _ClassVar[ClientLibraryOrganization] GEO: _ClassVar[ClientLibraryOrganization] GENERATIVE_AI: _ClassVar[ClientLibraryOrganization] class ClientLibraryDestination(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () CLIENT_LIBRARY_DESTINATION_UNSPECIFIED: _ClassVar[ClientLibraryDestination] GITHUB: _ClassVar[ClientLibraryDestination] PACKAGE_MANAGER: _ClassVar[ClientLibraryDestination] class FlowControlLimitExceededBehaviorProto( int, metaclass=_enum_type_wrapper.EnumTypeWrapper ): __slots__ = () UNSET_BEHAVIOR: _ClassVar[FlowControlLimitExceededBehaviorProto] THROW_EXCEPTION: _ClassVar[FlowControlLimitExceededBehaviorProto] BLOCK: _ClassVar[FlowControlLimitExceededBehaviorProto] IGNORE: _ClassVar[FlowControlLimitExceededBehaviorProto] CLIENT_LIBRARY_ORGANIZATION_UNSPECIFIED: ClientLibraryOrganization CLOUD: ClientLibraryOrganization ADS: ClientLibraryOrganization PHOTOS: ClientLibraryOrganization STREET_VIEW: ClientLibraryOrganization SHOPPING: ClientLibraryOrganization GEO: ClientLibraryOrganization GENERATIVE_AI: ClientLibraryOrganization CLIENT_LIBRARY_DESTINATION_UNSPECIFIED: ClientLibraryDestination GITHUB: ClientLibraryDestination PACKAGE_MANAGER: ClientLibraryDestination UNSET_BEHAVIOR: FlowControlLimitExceededBehaviorProto THROW_EXCEPTION: FlowControlLimitExceededBehaviorProto BLOCK: FlowControlLimitExceededBehaviorProto IGNORE: FlowControlLimitExceededBehaviorProto METHOD_SIGNATURE_FIELD_NUMBER: _ClassVar[int] method_signature: _descriptor.FieldDescriptor DEFAULT_HOST_FIELD_NUMBER: _ClassVar[int] default_host: _descriptor.FieldDescriptor OAUTH_SCOPES_FIELD_NUMBER: _ClassVar[int] oauth_scopes: _descriptor.FieldDescriptor API_VERSION_FIELD_NUMBER: _ClassVar[int] api_version: _descriptor.FieldDescriptor class CommonLanguageSettings(_message.Message): __slots__ = ("reference_docs_uri", "destinations", "selective_gapic_generation") REFERENCE_DOCS_URI_FIELD_NUMBER: _ClassVar[int] DESTINATIONS_FIELD_NUMBER: _ClassVar[int] SELECTIVE_GAPIC_GENERATION_FIELD_NUMBER: _ClassVar[int] reference_docs_uri: str destinations: _containers.RepeatedScalarFieldContainer[ClientLibraryDestination] selective_gapic_generation: SelectiveGapicGeneration def __init__( self, reference_docs_uri: _Optional[str] = ..., destinations: _Optional[_Iterable[_Union[ClientLibraryDestination, str]]] = ..., selective_gapic_generation: _Optional[ _Union[SelectiveGapicGeneration, _Mapping] ] = ..., ) -> None: ... class ClientLibrarySettings(_message.Message): __slots__ = ( "version", "launch_stage", "rest_numeric_enums", "java_settings", "cpp_settings", "php_settings", "python_settings", "node_settings", "dotnet_settings", "ruby_settings", "go_settings", ) VERSION_FIELD_NUMBER: _ClassVar[int] LAUNCH_STAGE_FIELD_NUMBER: _ClassVar[int] REST_NUMERIC_ENUMS_FIELD_NUMBER: _ClassVar[int] JAVA_SETTINGS_FIELD_NUMBER: _ClassVar[int] CPP_SETTINGS_FIELD_NUMBER: _ClassVar[int] PHP_SETTINGS_FIELD_NUMBER: _ClassVar[int] PYTHON_SETTINGS_FIELD_NUMBER: _ClassVar[int] NODE_SETTINGS_FIELD_NUMBER: _ClassVar[int] DOTNET_SETTINGS_FIELD_NUMBER: _ClassVar[int] RUBY_SETTINGS_FIELD_NUMBER: _ClassVar[int] GO_SETTINGS_FIELD_NUMBER: _ClassVar[int] version: str launch_stage: _launch_stage_pb2.LaunchStage rest_numeric_enums: bool java_settings: JavaSettings cpp_settings: CppSettings php_settings: PhpSettings python_settings: PythonSettings node_settings: NodeSettings dotnet_settings: DotnetSettings ruby_settings: RubySettings go_settings: GoSettings def __init__( self, version: _Optional[str] = ..., launch_stage: _Optional[_Union[_launch_stage_pb2.LaunchStage, str]] = ..., rest_numeric_enums: bool = ..., java_settings: _Optional[_Union[JavaSettings, _Mapping]] = ..., cpp_settings: _Optional[_Union[CppSettings, _Mapping]] = ..., php_settings: _Optional[_Union[PhpSettings, _Mapping]] = ..., python_settings: _Optional[_Union[PythonSettings, _Mapping]] = ..., node_settings: _Optional[_Union[NodeSettings, _Mapping]] = ..., dotnet_settings: _Optional[_Union[DotnetSettings, _Mapping]] = ..., ruby_settings: _Optional[_Union[RubySettings, _Mapping]] = ..., go_settings: _Optional[_Union[GoSettings, _Mapping]] = ..., ) -> None: ... class Publishing(_message.Message): __slots__ = ( "method_settings", "new_issue_uri", "documentation_uri", "api_short_name", "github_label", "codeowner_github_teams", "doc_tag_prefix", "organization", "library_settings", "proto_reference_documentation_uri", "rest_reference_documentation_uri", ) METHOD_SETTINGS_FIELD_NUMBER: _ClassVar[int] NEW_ISSUE_URI_FIELD_NUMBER: _ClassVar[int] DOCUMENTATION_URI_FIELD_NUMBER: _ClassVar[int] API_SHORT_NAME_FIELD_NUMBER: _ClassVar[int] GITHUB_LABEL_FIELD_NUMBER: _ClassVar[int] CODEOWNER_GITHUB_TEAMS_FIELD_NUMBER: _ClassVar[int] DOC_TAG_PREFIX_FIELD_NUMBER: _ClassVar[int] ORGANIZATION_FIELD_NUMBER: _ClassVar[int] LIBRARY_SETTINGS_FIELD_NUMBER: _ClassVar[int] PROTO_REFERENCE_DOCUMENTATION_URI_FIELD_NUMBER: _ClassVar[int] REST_REFERENCE_DOCUMENTATION_URI_FIELD_NUMBER: _ClassVar[int] method_settings: _containers.RepeatedCompositeFieldContainer[MethodSettings] new_issue_uri: str documentation_uri: str api_short_name: str github_label: str codeowner_github_teams: _containers.RepeatedScalarFieldContainer[str] doc_tag_prefix: str organization: ClientLibraryOrganization library_settings: _containers.RepeatedCompositeFieldContainer[ClientLibrarySettings] proto_reference_documentation_uri: str rest_reference_documentation_uri: str def __init__( self, method_settings: _Optional[_Iterable[_Union[MethodSettings, _Mapping]]] = ..., new_issue_uri: _Optional[str] = ..., documentation_uri: _Optional[str] = ..., api_short_name: _Optional[str] = ..., github_label: _Optional[str] = ..., codeowner_github_teams: _Optional[_Iterable[str]] = ..., doc_tag_prefix: _Optional[str] = ..., organization: _Optional[_Union[ClientLibraryOrganization, str]] = ..., library_settings: _Optional[ _Iterable[_Union[ClientLibrarySettings, _Mapping]] ] = ..., proto_reference_documentation_uri: _Optional[str] = ..., rest_reference_documentation_uri: _Optional[str] = ..., ) -> None: ... class JavaSettings(_message.Message): __slots__ = ("library_package", "service_class_names", "common") class ServiceClassNamesEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... LIBRARY_PACKAGE_FIELD_NUMBER: _ClassVar[int] SERVICE_CLASS_NAMES_FIELD_NUMBER: _ClassVar[int] COMMON_FIELD_NUMBER: _ClassVar[int] library_package: str service_class_names: _containers.ScalarMap[str, str] common: CommonLanguageSettings def __init__( self, library_package: _Optional[str] = ..., service_class_names: _Optional[_Mapping[str, str]] = ..., common: _Optional[_Union[CommonLanguageSettings, _Mapping]] = ..., ) -> None: ... class CppSettings(_message.Message): __slots__ = ("common",) COMMON_FIELD_NUMBER: _ClassVar[int] common: CommonLanguageSettings def __init__( self, common: _Optional[_Union[CommonLanguageSettings, _Mapping]] = ... ) -> None: ... class PhpSettings(_message.Message): __slots__ = ("common", "library_package") COMMON_FIELD_NUMBER: _ClassVar[int] LIBRARY_PACKAGE_FIELD_NUMBER: _ClassVar[int] common: CommonLanguageSettings library_package: str def __init__( self, common: _Optional[_Union[CommonLanguageSettings, _Mapping]] = ..., library_package: _Optional[str] = ..., ) -> None: ... class PythonSettings(_message.Message): __slots__ = ("common", "experimental_features") class ExperimentalFeatures(_message.Message): __slots__ = ( "rest_async_io_enabled", "protobuf_pythonic_types_enabled", "unversioned_package_disabled", ) REST_ASYNC_IO_ENABLED_FIELD_NUMBER: _ClassVar[int] PROTOBUF_PYTHONIC_TYPES_ENABLED_FIELD_NUMBER: _ClassVar[int] UNVERSIONED_PACKAGE_DISABLED_FIELD_NUMBER: _ClassVar[int] rest_async_io_enabled: bool protobuf_pythonic_types_enabled: bool unversioned_package_disabled: bool def __init__( self, rest_async_io_enabled: bool = ..., protobuf_pythonic_types_enabled: bool = ..., unversioned_package_disabled: bool = ..., ) -> None: ... COMMON_FIELD_NUMBER: _ClassVar[int] EXPERIMENTAL_FEATURES_FIELD_NUMBER: _ClassVar[int] common: CommonLanguageSettings experimental_features: PythonSettings.ExperimentalFeatures def __init__( self, common: _Optional[_Union[CommonLanguageSettings, _Mapping]] = ..., experimental_features: _Optional[ _Union[PythonSettings.ExperimentalFeatures, _Mapping] ] = ..., ) -> None: ... class NodeSettings(_message.Message): __slots__ = ("common",) COMMON_FIELD_NUMBER: _ClassVar[int] common: CommonLanguageSettings def __init__( self, common: _Optional[_Union[CommonLanguageSettings, _Mapping]] = ... ) -> None: ... class DotnetSettings(_message.Message): __slots__ = ( "common", "renamed_services", "renamed_resources", "ignored_resources", "forced_namespace_aliases", "handwritten_signatures", ) class RenamedServicesEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... class RenamedResourcesEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... COMMON_FIELD_NUMBER: _ClassVar[int] RENAMED_SERVICES_FIELD_NUMBER: _ClassVar[int] RENAMED_RESOURCES_FIELD_NUMBER: _ClassVar[int] IGNORED_RESOURCES_FIELD_NUMBER: _ClassVar[int] FORCED_NAMESPACE_ALIASES_FIELD_NUMBER: _ClassVar[int] HANDWRITTEN_SIGNATURES_FIELD_NUMBER: _ClassVar[int] common: CommonLanguageSettings renamed_services: _containers.ScalarMap[str, str] renamed_resources: _containers.ScalarMap[str, str] ignored_resources: _containers.RepeatedScalarFieldContainer[str] forced_namespace_aliases: _containers.RepeatedScalarFieldContainer[str] handwritten_signatures: _containers.RepeatedScalarFieldContainer[str] def __init__( self, common: _Optional[_Union[CommonLanguageSettings, _Mapping]] = ..., renamed_services: _Optional[_Mapping[str, str]] = ..., renamed_resources: _Optional[_Mapping[str, str]] = ..., ignored_resources: _Optional[_Iterable[str]] = ..., forced_namespace_aliases: _Optional[_Iterable[str]] = ..., handwritten_signatures: _Optional[_Iterable[str]] = ..., ) -> None: ... class RubySettings(_message.Message): __slots__ = ("common",) COMMON_FIELD_NUMBER: _ClassVar[int] common: CommonLanguageSettings def __init__( self, common: _Optional[_Union[CommonLanguageSettings, _Mapping]] = ... ) -> None: ... class GoSettings(_message.Message): __slots__ = ("common", "renamed_services") class RenamedServicesEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... COMMON_FIELD_NUMBER: _ClassVar[int] RENAMED_SERVICES_FIELD_NUMBER: _ClassVar[int] common: CommonLanguageSettings renamed_services: _containers.ScalarMap[str, str] def __init__( self, common: _Optional[_Union[CommonLanguageSettings, _Mapping]] = ..., renamed_services: _Optional[_Mapping[str, str]] = ..., ) -> None: ... class MethodSettings(_message.Message): __slots__ = ("selector", "long_running", "auto_populated_fields", "batching") class LongRunning(_message.Message): __slots__ = ( "initial_poll_delay", "poll_delay_multiplier", "max_poll_delay", "total_poll_timeout", ) INITIAL_POLL_DELAY_FIELD_NUMBER: _ClassVar[int] POLL_DELAY_MULTIPLIER_FIELD_NUMBER: _ClassVar[int] MAX_POLL_DELAY_FIELD_NUMBER: _ClassVar[int] TOTAL_POLL_TIMEOUT_FIELD_NUMBER: _ClassVar[int] initial_poll_delay: _duration_pb2.Duration poll_delay_multiplier: float max_poll_delay: _duration_pb2.Duration total_poll_timeout: _duration_pb2.Duration def __init__( self, initial_poll_delay: _Optional[ _Union[_duration_pb2.Duration, _Mapping] ] = ..., poll_delay_multiplier: _Optional[float] = ..., max_poll_delay: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., total_poll_timeout: _Optional[ _Union[_duration_pb2.Duration, _Mapping] ] = ..., ) -> None: ... SELECTOR_FIELD_NUMBER: _ClassVar[int] LONG_RUNNING_FIELD_NUMBER: _ClassVar[int] AUTO_POPULATED_FIELDS_FIELD_NUMBER: _ClassVar[int] BATCHING_FIELD_NUMBER: _ClassVar[int] selector: str long_running: MethodSettings.LongRunning auto_populated_fields: _containers.RepeatedScalarFieldContainer[str] batching: BatchingConfigProto def __init__( self, selector: _Optional[str] = ..., long_running: _Optional[_Union[MethodSettings.LongRunning, _Mapping]] = ..., auto_populated_fields: _Optional[_Iterable[str]] = ..., batching: _Optional[_Union[BatchingConfigProto, _Mapping]] = ..., ) -> None: ... class SelectiveGapicGeneration(_message.Message): __slots__ = ("methods", "generate_omitted_as_internal") METHODS_FIELD_NUMBER: _ClassVar[int] GENERATE_OMITTED_AS_INTERNAL_FIELD_NUMBER: _ClassVar[int] methods: _containers.RepeatedScalarFieldContainer[str] generate_omitted_as_internal: bool def __init__( self, methods: _Optional[_Iterable[str]] = ..., generate_omitted_as_internal: bool = ..., ) -> None: ... class BatchingConfigProto(_message.Message): __slots__ = ("thresholds", "batch_descriptor") THRESHOLDS_FIELD_NUMBER: _ClassVar[int] BATCH_DESCRIPTOR_FIELD_NUMBER: _ClassVar[int] thresholds: BatchingSettingsProto batch_descriptor: BatchingDescriptorProto def __init__( self, thresholds: _Optional[_Union[BatchingSettingsProto, _Mapping]] = ..., batch_descriptor: _Optional[_Union[BatchingDescriptorProto, _Mapping]] = ..., ) -> None: ... class BatchingSettingsProto(_message.Message): __slots__ = ( "element_count_threshold", "request_byte_threshold", "delay_threshold", "element_count_limit", "request_byte_limit", "flow_control_element_limit", "flow_control_byte_limit", "flow_control_limit_exceeded_behavior", ) ELEMENT_COUNT_THRESHOLD_FIELD_NUMBER: _ClassVar[int] REQUEST_BYTE_THRESHOLD_FIELD_NUMBER: _ClassVar[int] DELAY_THRESHOLD_FIELD_NUMBER: _ClassVar[int] ELEMENT_COUNT_LIMIT_FIELD_NUMBER: _ClassVar[int] REQUEST_BYTE_LIMIT_FIELD_NUMBER: _ClassVar[int] FLOW_CONTROL_ELEMENT_LIMIT_FIELD_NUMBER: _ClassVar[int] FLOW_CONTROL_BYTE_LIMIT_FIELD_NUMBER: _ClassVar[int] FLOW_CONTROL_LIMIT_EXCEEDED_BEHAVIOR_FIELD_NUMBER: _ClassVar[int] element_count_threshold: int request_byte_threshold: int delay_threshold: _duration_pb2.Duration element_count_limit: int request_byte_limit: int flow_control_element_limit: int flow_control_byte_limit: int flow_control_limit_exceeded_behavior: FlowControlLimitExceededBehaviorProto def __init__( self, element_count_threshold: _Optional[int] = ..., request_byte_threshold: _Optional[int] = ..., delay_threshold: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., element_count_limit: _Optional[int] = ..., request_byte_limit: _Optional[int] = ..., flow_control_element_limit: _Optional[int] = ..., flow_control_byte_limit: _Optional[int] = ..., flow_control_limit_exceeded_behavior: _Optional[ _Union[FlowControlLimitExceededBehaviorProto, str] ] = ..., ) -> None: ... class BatchingDescriptorProto(_message.Message): __slots__ = ("batched_field", "discriminator_fields", "subresponse_field") BATCHED_FIELD_FIELD_NUMBER: _ClassVar[int] DISCRIMINATOR_FIELDS_FIELD_NUMBER: _ClassVar[int] SUBRESPONSE_FIELD_FIELD_NUMBER: _ClassVar[int] batched_field: str discriminator_fields: _containers.RepeatedScalarFieldContainer[str] subresponse_field: str def __init__( self, batched_field: _Optional[str] = ..., discriminator_fields: _Optional[_Iterable[str]] = ..., subresponse_field: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/config_change.proto0000644000000000000000000000613615177035227023354 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/configchange;configchange"; option java_multiple_files = true; option java_outer_classname = "ConfigChangeProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Output generated from semantically comparing two versions of a service // configuration. // // Includes detailed information about a field that have changed with // applicable advice about potential consequences for the change, such as // backwards-incompatibility. message ConfigChange { // Object hierarchy path to the change, with levels separated by a '.' // character. For repeated fields, an applicable unique identifier field is // used for the index (usually selector, name, or id). For maps, the term // 'key' is used. If the field has no unique identifier, the numeric index // is used. // Examples: // - visibility.rules[selector=="google.LibraryService.ListBooks"].restriction // - quota.metric_rules[selector=="google"].metric_costs[key=="reads"].value // - logging.producer_destinations[0] string element = 1; // Value of the changed object in the old Service configuration, // in JSON format. This field will not be populated if ChangeType == ADDED. string old_value = 2; // Value of the changed object in the new Service configuration, // in JSON format. This field will not be populated if ChangeType == REMOVED. string new_value = 3; // The type for this change, either ADDED, REMOVED, or MODIFIED. ChangeType change_type = 4; // Collection of advice provided for this change, useful for determining the // possible impact of this change. repeated Advice advices = 5; } // Generated advice about this change, used for providing more // information about how a change will affect the existing service. message Advice { // Useful description for why this advice was applied and what actions should // be taken to mitigate any implied risks. string description = 2; } // Classifies set of possible modifications to an object in the service // configuration. enum ChangeType { // No value was provided. CHANGE_TYPE_UNSPECIFIED = 0; // The changed object exists in the 'new' service configuration, but not // in the 'old' service configuration. ADDED = 1; // The changed object exists in the 'old' service configuration, but not // in the 'new' service configuration. REMOVED = 2; // The changed object exists in both service configurations, but its value // is different. MODIFIED = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/config_change_pb2.py0000644000000000000000000000520615177035224023376 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/config_change.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1egoogle/api/config_change.proto\x12\ngoogle.api"\x97\x01\n\x0c\x43onfigChange\x12\x0f\n\x07\x65lement\x18\x01 \x01(\t\x12\x11\n\told_value\x18\x02 \x01(\t\x12\x11\n\tnew_value\x18\x03 \x01(\t\x12+\n\x0b\x63hange_type\x18\x04 \x01(\x0e\x32\x16.google.api.ChangeType\x12#\n\x07\x61\x64vices\x18\x05 \x03(\x0b\x32\x12.google.api.Advice"\x1d\n\x06\x41\x64vice\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t*O\n\nChangeType\x12\x1b\n\x17\x43HANGE_TYPE_UNSPECIFIED\x10\x00\x12\t\n\x05\x41\x44\x44\x45\x44\x10\x01\x12\x0b\n\x07REMOVED\x10\x02\x12\x0c\n\x08MODIFIED\x10\x03\x42q\n\x0e\x63om.google.apiB\x11\x43onfigChangeProtoP\x01ZCgoogle.golang.org/genproto/googleapis/api/configchange;configchange\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.config_change_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\021ConfigChangeProtoP\001ZCgoogle.golang.org/genproto/googleapis/api/configchange;configchange\242\002\004GAPI" _globals["_CHANGETYPE"]._serialized_start = 231 _globals["_CHANGETYPE"]._serialized_end = 310 _globals["_CONFIGCHANGE"]._serialized_start = 47 _globals["_CONFIGCHANGE"]._serialized_end = 198 _globals["_ADVICE"]._serialized_start = 200 _globals["_ADVICE"]._serialized_end = 229 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/config_change_pb2.pyi0000644000000000000000000000452015177035222023543 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class ChangeType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () CHANGE_TYPE_UNSPECIFIED: _ClassVar[ChangeType] ADDED: _ClassVar[ChangeType] REMOVED: _ClassVar[ChangeType] MODIFIED: _ClassVar[ChangeType] CHANGE_TYPE_UNSPECIFIED: ChangeType ADDED: ChangeType REMOVED: ChangeType MODIFIED: ChangeType class ConfigChange(_message.Message): __slots__ = ("element", "old_value", "new_value", "change_type", "advices") ELEMENT_FIELD_NUMBER: _ClassVar[int] OLD_VALUE_FIELD_NUMBER: _ClassVar[int] NEW_VALUE_FIELD_NUMBER: _ClassVar[int] CHANGE_TYPE_FIELD_NUMBER: _ClassVar[int] ADVICES_FIELD_NUMBER: _ClassVar[int] element: str old_value: str new_value: str change_type: ChangeType advices: _containers.RepeatedCompositeFieldContainer[Advice] def __init__( self, element: _Optional[str] = ..., old_value: _Optional[str] = ..., new_value: _Optional[str] = ..., change_type: _Optional[_Union[ChangeType, str]] = ..., advices: _Optional[_Iterable[_Union[Advice, _Mapping]]] = ..., ) -> None: ... class Advice(_message.Message): __slots__ = ("description",) DESCRIPTION_FIELD_NUMBER: _ClassVar[int] description: str def __init__(self, description: _Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/consumer.proto0000644000000000000000000000523515177035222022427 0ustar00rootroot// Copyright 2025 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "ConsumerProto"; option java_package = "com.google.api"; // A descriptor for defining project properties for a service. One service may // have many consumer projects, and the service may want to behave differently // depending on some properties on the project. For example, a project may be // associated with a school, or a business, or a government agency, a business // type property on the project may affect how a service responds to the client. // This descriptor defines which properties are allowed to be set on a project. // // Example: // // project_properties: // properties: // - name: NO_WATERMARK // type: BOOL // description: Allows usage of the API without watermarks. // - name: EXTENDED_TILE_CACHE_PERIOD // type: INT64 message ProjectProperties { // List of per consumer project-specific properties. repeated Property properties = 1; } // Defines project properties. // // API services can define properties that can be assigned to consumer projects // so that backends can perform response customization without having to make // additional calls or maintain additional storage. For example, Maps API // defines properties that controls map tile cache period, or whether to embed a // watermark in a result. // // These values can be set via API producer console. Only API providers can // define and set these properties. message Property { // Supported data type of the property values enum PropertyType { // The type is unspecified, and will result in an error. UNSPECIFIED = 0; // The type is `int64`. INT64 = 1; // The type is `bool`. BOOL = 2; // The type is `string`. STRING = 3; // The type is 'double'. DOUBLE = 4; } // The name of the property (a.k.a key). string name = 1; // The type of this property. PropertyType type = 2; // The description of the property string description = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/consumer_pb2.py0000644000000000000000000000501715177035223022456 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/consumer.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x19google/api/consumer.proto\x12\ngoogle.api"=\n\x11ProjectProperties\x12(\n\nproperties\x18\x01 \x03(\x0b\x32\x14.google.api.Property"\xac\x01\n\x08Property\x12\x0c\n\x04name\x18\x01 \x01(\t\x12/\n\x04type\x18\x02 \x01(\x0e\x32!.google.api.Property.PropertyType\x12\x13\n\x0b\x64\x65scription\x18\x03 \x01(\t"L\n\x0cPropertyType\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\t\n\x05INT64\x10\x01\x12\x08\n\x04\x42OOL\x10\x02\x12\n\n\x06STRING\x10\x03\x12\n\n\x06\x44OUBLE\x10\x04\x42h\n\x0e\x63om.google.apiB\rConsumerProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfigb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.consumer_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\rConsumerProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig" _globals["_PROJECTPROPERTIES"]._serialized_start = 41 _globals["_PROJECTPROPERTIES"]._serialized_end = 102 _globals["_PROPERTY"]._serialized_start = 105 _globals["_PROPERTY"]._serialized_end = 277 _globals["_PROPERTY_PROPERTYTYPE"]._serialized_start = 201 _globals["_PROPERTY_PROPERTYTYPE"]._serialized_end = 277 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/consumer_pb2.pyi0000644000000000000000000000445515177035224022635 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class ProjectProperties(_message.Message): __slots__ = ("properties",) PROPERTIES_FIELD_NUMBER: _ClassVar[int] properties: _containers.RepeatedCompositeFieldContainer[Property] def __init__( self, properties: _Optional[_Iterable[_Union[Property, _Mapping]]] = ... ) -> None: ... class Property(_message.Message): __slots__ = ("name", "type", "description") class PropertyType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () UNSPECIFIED: _ClassVar[Property.PropertyType] INT64: _ClassVar[Property.PropertyType] BOOL: _ClassVar[Property.PropertyType] STRING: _ClassVar[Property.PropertyType] DOUBLE: _ClassVar[Property.PropertyType] UNSPECIFIED: Property.PropertyType INT64: Property.PropertyType BOOL: Property.PropertyType STRING: Property.PropertyType DOUBLE: Property.PropertyType NAME_FIELD_NUMBER: _ClassVar[int] TYPE_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] name: str type: Property.PropertyType description: str def __init__( self, name: _Optional[str] = ..., type: _Optional[_Union[Property.PropertyType, str]] = ..., description: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/context.proto0000644000000000000000000000623515177035224022263 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "ContextProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // `Context` defines which contexts an API requests. // // Example: // // context: // rules: // - selector: "*" // requested: // - google.rpc.context.ProjectContext // - google.rpc.context.OriginContext // // The above specifies that all methods in the API request // `google.rpc.context.ProjectContext` and // `google.rpc.context.OriginContext`. // // Available context types are defined in package // `google.rpc.context`. // // This also provides mechanism to allowlist any protobuf message extension that // can be sent in grpc metadata using “x-goog-ext--bin” and // “x-goog-ext--jspb” format. For example, list any service // specific protobuf types that can appear in grpc metadata as follows in your // yaml file: // // Example: // // context: // rules: // - selector: "google.example.library.v1.LibraryService.CreateBook" // allowed_request_extensions: // - google.foo.v1.NewExtension // allowed_response_extensions: // - google.foo.v1.NewExtension // // You can also specify extension ID instead of fully qualified extension name // here. message Context { // A list of RPC context rules that apply to individual API methods. // // **NOTE:** All service configuration rules follow "last one wins" order. repeated ContextRule rules = 1; } // A context rule provides information about the context for an individual API // element. message ContextRule { // Selects the methods to which this rule applies. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. string selector = 1; // A list of full type names of requested contexts, only the requested context // will be made available to the backend. repeated string requested = 2; // A list of full type names of provided contexts. It is used to support // propagating HTTP headers and ETags from the response extension. repeated string provided = 3; // A list of full type names or extension IDs of extensions allowed in grpc // side channel from client to backend. repeated string allowed_request_extensions = 4; // A list of full type names or extension IDs of extensions allowed in grpc // side channel from backend to client. repeated string allowed_response_extensions = 5; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/context_pb2.py0000644000000000000000000000451115177035226022310 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/context.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x18google/api/context.proto\x12\ngoogle.api"1\n\x07\x43ontext\x12&\n\x05rules\x18\x01 \x03(\x0b\x32\x17.google.api.ContextRule"\x8d\x01\n\x0b\x43ontextRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12\x11\n\trequested\x18\x02 \x03(\t\x12\x10\n\x08provided\x18\x03 \x03(\t\x12"\n\x1a\x61llowed_request_extensions\x18\x04 \x03(\t\x12#\n\x1b\x61llowed_response_extensions\x18\x05 \x03(\tBn\n\x0e\x63om.google.apiB\x0c\x43ontextProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.context_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\014ContextProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_CONTEXT"]._serialized_start = 40 _globals["_CONTEXT"]._serialized_end = 89 _globals["_CONTEXTRULE"]._serialized_start = 92 _globals["_CONTEXTRULE"]._serialized_end = 233 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/context_pb2.pyi0000644000000000000000000000444315177035225022464 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Context(_message.Message): __slots__ = ("rules",) RULES_FIELD_NUMBER: _ClassVar[int] rules: _containers.RepeatedCompositeFieldContainer[ContextRule] def __init__( self, rules: _Optional[_Iterable[_Union[ContextRule, _Mapping]]] = ... ) -> None: ... class ContextRule(_message.Message): __slots__ = ( "selector", "requested", "provided", "allowed_request_extensions", "allowed_response_extensions", ) SELECTOR_FIELD_NUMBER: _ClassVar[int] REQUESTED_FIELD_NUMBER: _ClassVar[int] PROVIDED_FIELD_NUMBER: _ClassVar[int] ALLOWED_REQUEST_EXTENSIONS_FIELD_NUMBER: _ClassVar[int] ALLOWED_RESPONSE_EXTENSIONS_FIELD_NUMBER: _ClassVar[int] selector: str requested: _containers.RepeatedScalarFieldContainer[str] provided: _containers.RepeatedScalarFieldContainer[str] allowed_request_extensions: _containers.RepeatedScalarFieldContainer[str] allowed_response_extensions: _containers.RepeatedScalarFieldContainer[str] def __init__( self, selector: _Optional[str] = ..., requested: _Optional[_Iterable[str]] = ..., provided: _Optional[_Iterable[str]] = ..., allowed_request_extensions: _Optional[_Iterable[str]] = ..., allowed_response_extensions: _Optional[_Iterable[str]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/control.proto0000644000000000000000000000263615177035226022262 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/api/policy.proto"; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "ControlProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Selects and configures the service controller used by the service. // // Example: // // control: // environment: servicecontrol.googleapis.com message Control { // The service controller environment to use. If empty, no control plane // features (like quota and billing) will be enabled. The recommended value // for most services is servicecontrol.googleapis.com. string environment = 1; // Defines policies applying to the API methods of the service. repeated MethodPolicy method_policies = 4; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/control_pb2.py0000644000000000000000000000420215177035226022301 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/control.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.api import policy_pb2 as google_dot_api_dot_policy__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x18google/api/control.proto\x12\ngoogle.api\x1a\x17google/api/policy.proto"Q\n\x07\x43ontrol\x12\x13\n\x0b\x65nvironment\x18\x01 \x01(\t\x12\x31\n\x0fmethod_policies\x18\x04 \x03(\x0b\x32\x18.google.api.MethodPolicyBn\n\x0e\x63om.google.apiB\x0c\x43ontrolProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.control_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\014ControlProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_CONTROL"]._serialized_start = 65 _globals["_CONTROL"]._serialized_end = 146 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/control_pb2.pyi0000644000000000000000000000301215177035225022447 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.api import policy_pb2 as _policy_pb2 DESCRIPTOR: _descriptor.FileDescriptor class Control(_message.Message): __slots__ = ("environment", "method_policies") ENVIRONMENT_FIELD_NUMBER: _ClassVar[int] METHOD_POLICIES_FIELD_NUMBER: _ClassVar[int] environment: str method_policies: _containers.RepeatedCompositeFieldContainer[ _policy_pb2.MethodPolicy ] def __init__( self, environment: _Optional[str] = ..., method_policies: _Optional[ _Iterable[_Union[_policy_pb2.MethodPolicy, _Mapping]] ] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/distribution.proto0000644000000000000000000002072415177035227023320 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/any.proto"; import "google/protobuf/timestamp.proto"; option go_package = "google.golang.org/genproto/googleapis/api/distribution;distribution"; option java_multiple_files = true; option java_outer_classname = "DistributionProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // `Distribution` contains summary statistics for a population of values. It // optionally contains a histogram representing the distribution of those values // across a set of buckets. // // The summary statistics are the count, mean, sum of the squared deviation from // the mean, the minimum, and the maximum of the set of population of values. // The histogram is based on a sequence of buckets and gives a count of values // that fall into each bucket. The boundaries of the buckets are given either // explicitly or by formulas for buckets of fixed or exponentially increasing // widths. // // Although it is not forbidden, it is generally a bad idea to include // non-finite values (infinities or NaNs) in the population of values, as this // will render the `mean` and `sum_of_squared_deviation` fields meaningless. message Distribution { // The range of the population values. message Range { // The minimum of the population values. double min = 1; // The maximum of the population values. double max = 2; } // `BucketOptions` describes the bucket boundaries used to create a histogram // for the distribution. The buckets can be in a linear sequence, an // exponential sequence, or each bucket can be specified explicitly. // `BucketOptions` does not include the number of values in each bucket. // // A bucket has an inclusive lower bound and exclusive upper bound for the // values that are counted for that bucket. The upper bound of a bucket must // be strictly greater than the lower bound. The sequence of N buckets for a // distribution consists of an underflow bucket (number 0), zero or more // finite buckets (number 1 through N - 2) and an overflow bucket (number N - // 1). The buckets are contiguous: the lower bound of bucket i (i > 0) is the // same as the upper bound of bucket i - 1. The buckets span the whole range // of finite values: lower bound of the underflow bucket is -infinity and the // upper bound of the overflow bucket is +infinity. The finite buckets are // so-called because both bounds are finite. message BucketOptions { // Specifies a linear sequence of buckets that all have the same width // (except overflow and underflow). Each bucket represents a constant // absolute uncertainty on the specific value in the bucket. // // There are `num_finite_buckets + 2` (= N) buckets. Bucket `i` has the // following boundaries: // // Upper bound (0 <= i < N-1): offset + (width * i). // // Lower bound (1 <= i < N): offset + (width * (i - 1)). message Linear { // Must be greater than 0. int32 num_finite_buckets = 1; // Must be greater than 0. double width = 2; // Lower bound of the first bucket. double offset = 3; } // Specifies an exponential sequence of buckets that have a width that is // proportional to the value of the lower bound. Each bucket represents a // constant relative uncertainty on a specific value in the bucket. // // There are `num_finite_buckets + 2` (= N) buckets. Bucket `i` has the // following boundaries: // // Upper bound (0 <= i < N-1): scale * (growth_factor ^ i). // // Lower bound (1 <= i < N): scale * (growth_factor ^ (i - 1)). message Exponential { // Must be greater than 0. int32 num_finite_buckets = 1; // Must be greater than 1. double growth_factor = 2; // Must be greater than 0. double scale = 3; } // Specifies a set of buckets with arbitrary widths. // // There are `size(bounds) + 1` (= N) buckets. Bucket `i` has the following // boundaries: // // Upper bound (0 <= i < N-1): bounds[i] // Lower bound (1 <= i < N); bounds[i - 1] // // The `bounds` field must contain at least one element. If `bounds` has // only one element, then there are no finite buckets, and that single // element is the common boundary of the overflow and underflow buckets. message Explicit { // The values must be monotonically increasing. repeated double bounds = 1; } // Exactly one of these three fields must be set. oneof options { // The linear bucket. Linear linear_buckets = 1; // The exponential buckets. Exponential exponential_buckets = 2; // The explicit buckets. Explicit explicit_buckets = 3; } } // Exemplars are example points that may be used to annotate aggregated // distribution values. They are metadata that gives information about a // particular value added to a Distribution bucket, such as a trace ID that // was active when a value was added. They may contain further information, // such as a example values and timestamps, origin, etc. message Exemplar { // Value of the exemplar point. This value determines to which bucket the // exemplar belongs. double value = 1; // The observation (sampling) time of the above value. google.protobuf.Timestamp timestamp = 2; // Contextual information about the example value. Examples are: // // Trace: type.googleapis.com/google.monitoring.v3.SpanContext // // Literal string: type.googleapis.com/google.protobuf.StringValue // // Labels dropped during aggregation: // type.googleapis.com/google.monitoring.v3.DroppedLabels // // There may be only a single attachment of any given message type in a // single exemplar, and this is enforced by the system. repeated google.protobuf.Any attachments = 3; } // The number of values in the population. Must be non-negative. This value // must equal the sum of the values in `bucket_counts` if a histogram is // provided. int64 count = 1; // The arithmetic mean of the values in the population. If `count` is zero // then this field must be zero. double mean = 2; // The sum of squared deviations from the mean of the values in the // population. For values x_i this is: // // Sum[i=1..n]((x_i - mean)^2) // // Knuth, "The Art of Computer Programming", Vol. 2, page 232, 3rd edition // describes Welford's method for accumulating this sum in one pass. // // If `count` is zero then this field must be zero. double sum_of_squared_deviation = 3; // If specified, contains the range of the population values. The field // must not be present if the `count` is zero. Range range = 4; // Defines the histogram bucket boundaries. If the distribution does not // contain a histogram, then omit this field. BucketOptions bucket_options = 6; // The number of values in each bucket of the histogram, as described in // `bucket_options`. If the distribution does not have a histogram, then omit // this field. If there is a histogram, then the sum of the values in // `bucket_counts` must equal the value in the `count` field of the // distribution. // // If present, `bucket_counts` should contain N values, where N is the number // of buckets specified in `bucket_options`. If you supply fewer than N // values, the remaining values are assumed to be 0. // // The order of the values in `bucket_counts` follows the bucket numbering // schemes described for the three bucket types. The first value must be the // count for the underflow bucket (number 0). The next N-2 values are the // counts for the finite buckets (number 1 through N-2). The N'th value in // `bucket_counts` is the count for the overflow bucket (number N-1). repeated int64 bucket_counts = 7; // Must be in increasing order of `value` field. repeated Exemplar exemplars = 10; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/distribution_pb2.py0000644000000000000000000001060515177035225023343 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/distribution.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1dgoogle/api/distribution.proto\x12\ngoogle.api\x1a\x19google/protobuf/any.proto\x1a\x1fgoogle/protobuf/timestamp.proto"\xd9\x06\n\x0c\x44istribution\x12\r\n\x05\x63ount\x18\x01 \x01(\x03\x12\x0c\n\x04mean\x18\x02 \x01(\x01\x12 \n\x18sum_of_squared_deviation\x18\x03 \x01(\x01\x12-\n\x05range\x18\x04 \x01(\x0b\x32\x1e.google.api.Distribution.Range\x12>\n\x0e\x62ucket_options\x18\x06 \x01(\x0b\x32&.google.api.Distribution.BucketOptions\x12\x15\n\rbucket_counts\x18\x07 \x03(\x03\x12\x34\n\texemplars\x18\n \x03(\x0b\x32!.google.api.Distribution.Exemplar\x1a!\n\x05Range\x12\x0b\n\x03min\x18\x01 \x01(\x01\x12\x0b\n\x03max\x18\x02 \x01(\x01\x1a\xb5\x03\n\rBucketOptions\x12G\n\x0elinear_buckets\x18\x01 \x01(\x0b\x32-.google.api.Distribution.BucketOptions.LinearH\x00\x12Q\n\x13\x65xponential_buckets\x18\x02 \x01(\x0b\x32\x32.google.api.Distribution.BucketOptions.ExponentialH\x00\x12K\n\x10\x65xplicit_buckets\x18\x03 \x01(\x0b\x32/.google.api.Distribution.BucketOptions.ExplicitH\x00\x1a\x43\n\x06Linear\x12\x1a\n\x12num_finite_buckets\x18\x01 \x01(\x05\x12\r\n\x05width\x18\x02 \x01(\x01\x12\x0e\n\x06offset\x18\x03 \x01(\x01\x1aO\n\x0b\x45xponential\x12\x1a\n\x12num_finite_buckets\x18\x01 \x01(\x05\x12\x15\n\rgrowth_factor\x18\x02 \x01(\x01\x12\r\n\x05scale\x18\x03 \x01(\x01\x1a\x1a\n\x08\x45xplicit\x12\x0e\n\x06\x62ounds\x18\x01 \x03(\x01\x42\t\n\x07options\x1as\n\x08\x45xemplar\x12\r\n\x05value\x18\x01 \x01(\x01\x12-\n\ttimestamp\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12)\n\x0b\x61ttachments\x18\x03 \x03(\x0b\x32\x14.google.protobuf.AnyBq\n\x0e\x63om.google.apiB\x11\x44istributionProtoP\x01ZCgoogle.golang.org/genproto/googleapis/api/distribution;distribution\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.distribution_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\021DistributionProtoP\001ZCgoogle.golang.org/genproto/googleapis/api/distribution;distribution\242\002\004GAPI" _globals["_DISTRIBUTION"]._serialized_start = 106 _globals["_DISTRIBUTION"]._serialized_end = 963 _globals["_DISTRIBUTION_RANGE"]._serialized_start = 373 _globals["_DISTRIBUTION_RANGE"]._serialized_end = 406 _globals["_DISTRIBUTION_BUCKETOPTIONS"]._serialized_start = 409 _globals["_DISTRIBUTION_BUCKETOPTIONS"]._serialized_end = 846 _globals["_DISTRIBUTION_BUCKETOPTIONS_LINEAR"]._serialized_start = 659 _globals["_DISTRIBUTION_BUCKETOPTIONS_LINEAR"]._serialized_end = 726 _globals["_DISTRIBUTION_BUCKETOPTIONS_EXPONENTIAL"]._serialized_start = 728 _globals["_DISTRIBUTION_BUCKETOPTIONS_EXPONENTIAL"]._serialized_end = 807 _globals["_DISTRIBUTION_BUCKETOPTIONS_EXPLICIT"]._serialized_start = 809 _globals["_DISTRIBUTION_BUCKETOPTIONS_EXPLICIT"]._serialized_end = 835 _globals["_DISTRIBUTION_EXEMPLAR"]._serialized_start = 848 _globals["_DISTRIBUTION_EXEMPLAR"]._serialized_end = 963 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/distribution_pb2.pyi0000644000000000000000000001321015177035226023510 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import any_pb2 as _any_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import timestamp_pb2 as _timestamp_pb2 from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Distribution(_message.Message): __slots__ = ( "count", "mean", "sum_of_squared_deviation", "range", "bucket_options", "bucket_counts", "exemplars", ) class Range(_message.Message): __slots__ = ("min", "max") MIN_FIELD_NUMBER: _ClassVar[int] MAX_FIELD_NUMBER: _ClassVar[int] min: float max: float def __init__( self, min: _Optional[float] = ..., max: _Optional[float] = ... ) -> None: ... class BucketOptions(_message.Message): __slots__ = ("linear_buckets", "exponential_buckets", "explicit_buckets") class Linear(_message.Message): __slots__ = ("num_finite_buckets", "width", "offset") NUM_FINITE_BUCKETS_FIELD_NUMBER: _ClassVar[int] WIDTH_FIELD_NUMBER: _ClassVar[int] OFFSET_FIELD_NUMBER: _ClassVar[int] num_finite_buckets: int width: float offset: float def __init__( self, num_finite_buckets: _Optional[int] = ..., width: _Optional[float] = ..., offset: _Optional[float] = ..., ) -> None: ... class Exponential(_message.Message): __slots__ = ("num_finite_buckets", "growth_factor", "scale") NUM_FINITE_BUCKETS_FIELD_NUMBER: _ClassVar[int] GROWTH_FACTOR_FIELD_NUMBER: _ClassVar[int] SCALE_FIELD_NUMBER: _ClassVar[int] num_finite_buckets: int growth_factor: float scale: float def __init__( self, num_finite_buckets: _Optional[int] = ..., growth_factor: _Optional[float] = ..., scale: _Optional[float] = ..., ) -> None: ... class Explicit(_message.Message): __slots__ = ("bounds",) BOUNDS_FIELD_NUMBER: _ClassVar[int] bounds: _containers.RepeatedScalarFieldContainer[float] def __init__(self, bounds: _Optional[_Iterable[float]] = ...) -> None: ... LINEAR_BUCKETS_FIELD_NUMBER: _ClassVar[int] EXPONENTIAL_BUCKETS_FIELD_NUMBER: _ClassVar[int] EXPLICIT_BUCKETS_FIELD_NUMBER: _ClassVar[int] linear_buckets: Distribution.BucketOptions.Linear exponential_buckets: Distribution.BucketOptions.Exponential explicit_buckets: Distribution.BucketOptions.Explicit def __init__( self, linear_buckets: _Optional[ _Union[Distribution.BucketOptions.Linear, _Mapping] ] = ..., exponential_buckets: _Optional[ _Union[Distribution.BucketOptions.Exponential, _Mapping] ] = ..., explicit_buckets: _Optional[ _Union[Distribution.BucketOptions.Explicit, _Mapping] ] = ..., ) -> None: ... class Exemplar(_message.Message): __slots__ = ("value", "timestamp", "attachments") VALUE_FIELD_NUMBER: _ClassVar[int] TIMESTAMP_FIELD_NUMBER: _ClassVar[int] ATTACHMENTS_FIELD_NUMBER: _ClassVar[int] value: float timestamp: _timestamp_pb2.Timestamp attachments: _containers.RepeatedCompositeFieldContainer[_any_pb2.Any] def __init__( self, value: _Optional[float] = ..., timestamp: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., attachments: _Optional[_Iterable[_Union[_any_pb2.Any, _Mapping]]] = ..., ) -> None: ... COUNT_FIELD_NUMBER: _ClassVar[int] MEAN_FIELD_NUMBER: _ClassVar[int] SUM_OF_SQUARED_DEVIATION_FIELD_NUMBER: _ClassVar[int] RANGE_FIELD_NUMBER: _ClassVar[int] BUCKET_OPTIONS_FIELD_NUMBER: _ClassVar[int] BUCKET_COUNTS_FIELD_NUMBER: _ClassVar[int] EXEMPLARS_FIELD_NUMBER: _ClassVar[int] count: int mean: float sum_of_squared_deviation: float range: Distribution.Range bucket_options: Distribution.BucketOptions bucket_counts: _containers.RepeatedScalarFieldContainer[int] exemplars: _containers.RepeatedCompositeFieldContainer[Distribution.Exemplar] def __init__( self, count: _Optional[int] = ..., mean: _Optional[float] = ..., sum_of_squared_deviation: _Optional[float] = ..., range: _Optional[_Union[Distribution.Range, _Mapping]] = ..., bucket_options: _Optional[_Union[Distribution.BucketOptions, _Mapping]] = ..., bucket_counts: _Optional[_Iterable[int]] = ..., exemplars: _Optional[_Iterable[_Union[Distribution.Exemplar, _Mapping]]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/documentation.proto0000644000000000000000000001541515177035221023445 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "DocumentationProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // `Documentation` provides the information for describing a service. // // Example: // 
documentation:
//   summary: >
//     The Google Calendar API gives access
//     to most calendar features.
//   pages:
//   - name: Overview
//     content: (== include google/foo/overview.md ==)
//   - name: Tutorial
//     content: (== include google/foo/tutorial.md ==)
//     subpages:
//     - name: Java
//       content: (== include google/foo/tutorial_java.md ==)
//   rules:
//   - selector: google.calendar.Calendar.Get
//     description: >
//       ...
//   - selector: google.calendar.Calendar.Put
//     description: >
//       ...
//
// Documentation is provided in markdown syntax. In addition to // standard markdown features, definition lists, tables and fenced // code blocks are supported. Section headers can be provided and are // interpreted relative to the section nesting of the context where // a documentation fragment is embedded. // // Documentation from the IDL is merged with documentation defined // via the config at normalization time, where documentation provided // by config rules overrides IDL provided. // // A number of constructs specific to the API platform are supported // in documentation text. // // In order to reference a proto element, the following // notation can be used: // 
[fully.qualified.proto.name][]
// To override the display text used for the link, this can be used: // 
[display text][fully.qualified.proto.name]
// Text can be excluded from doc using the following notation: // 
(-- internal comment --)
// // A few directives are available in documentation. Note that // directives must appear on a single line to be properly // identified. The `include` directive includes a markdown file from // an external source: // 
(== include path/to/file ==)
// The `resource_for` directive marks a message to be the resource of // a collection in REST view. If it is not specified, tools attempt // to infer the resource from the operations in a collection: // 
(== resource_for v1.shelves.books ==)
// The directive `suppress_warning` does not directly affect documentation // and is documented together with service config validation. message Documentation { // A short description of what the service does. The summary must be plain // text. It becomes the overview of the service displayed in Google Cloud // Console. // NOTE: This field is equivalent to the standard field `description`. string summary = 1; // The top level pages for the documentation set. repeated Page pages = 5; // A list of documentation rules that apply to individual API elements. // // **NOTE:** All service configuration rules follow "last one wins" order. repeated DocumentationRule rules = 3; // The URL to the root of documentation. string documentation_root_url = 4; // Specifies the service root url if the default one (the service name // from the yaml file) is not suitable. This can be seen in any fully // specified service urls as well as sections that show a base that other // urls are relative to. string service_root_url = 6; // Declares a single overview page. For example: // 
documentation:
  //   summary: ...
  //   overview: (== include overview.md ==)
  //
// This is a shortcut for the following declaration (using pages style): // 
documentation:
  //   summary: ...
  //   pages:
  //   - name: Overview
  //     content: (== include overview.md ==)
  //
// Note: you cannot specify both `overview` field and `pages` field. string overview = 2; } // A documentation rule provides information about individual API elements. message DocumentationRule { // The selector is a comma-separated list of patterns for any element such as // a method, a field, an enum value. Each pattern is a qualified name of the // element which may end in "*", indicating a wildcard. Wildcards are only // allowed at the end and for a whole component of the qualified name, // i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". A wildcard will match // one or more components. To specify a default for all applicable elements, // the whole pattern "*" is used. string selector = 1; // Description of the selected proto element (e.g. a message, a method, a // 'service' definition, or a field). Defaults to leading & trailing comments // taken from the proto source definition of the proto element. string description = 2; // Deprecation description of the selected element(s). It can be provided if // an element is marked as `deprecated`. string deprecation_description = 3; } // Represents a documentation page. A page can contain subpages to represent // nested documentation set structure. message Page { // The name of the page. It will be used as an identity of the page to // generate URI of the page, text of the link to this page in navigation, // etc. The full page name (start from the root page name to this page // concatenated with `.`) can be used as reference to the page in your // documentation. For example: // 
pages:
  // - name: Tutorial
  //   content: (== include tutorial.md ==)
  //   subpages:
  //   - name: Java
  //     content: (== include tutorial_java.md ==)
  //
// You can reference `Java` page using Markdown reference link syntax: // `[Java][Tutorial.Java]`. string name = 1; // The Markdown content of the page. You can use ```(== include {path} // ==)``` to include content from a Markdown file. The content can be used // to produce the documentation page such as HTML format page. string content = 2; // Subpages of this page. The order of subpages specified here will be // honored in the generated docset. repeated Page subpages = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/documentation_pb2.py0000644000000000000000000000543415177035223023477 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/documentation.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1egoogle/api/documentation.proto\x12\ngoogle.api"\xbb\x01\n\rDocumentation\x12\x0f\n\x07summary\x18\x01 \x01(\t\x12\x1f\n\x05pages\x18\x05 \x03(\x0b\x32\x10.google.api.Page\x12,\n\x05rules\x18\x03 \x03(\x0b\x32\x1d.google.api.DocumentationRule\x12\x1e\n\x16\x64ocumentation_root_url\x18\x04 \x01(\t\x12\x18\n\x10service_root_url\x18\x06 \x01(\t\x12\x10\n\x08overview\x18\x02 \x01(\t"[\n\x11\x44ocumentationRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x1f\n\x17\x64\x65precation_description\x18\x03 \x01(\t"I\n\x04Page\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0f\n\x07\x63ontent\x18\x02 \x01(\t\x12"\n\x08subpages\x18\x03 \x03(\x0b\x32\x10.google.api.PageBt\n\x0e\x63om.google.apiB\x12\x44ocumentationProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.documentation_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\022DocumentationProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_DOCUMENTATION"]._serialized_start = 47 _globals["_DOCUMENTATION"]._serialized_end = 234 _globals["_DOCUMENTATIONRULE"]._serialized_start = 236 _globals["_DOCUMENTATIONRULE"]._serialized_end = 327 _globals["_PAGE"]._serialized_start = 329 _globals["_PAGE"]._serialized_end = 402 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/documentation_pb2.pyi0000644000000000000000000000576615177035223023660 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Documentation(_message.Message): __slots__ = ( "summary", "pages", "rules", "documentation_root_url", "service_root_url", "overview", ) SUMMARY_FIELD_NUMBER: _ClassVar[int] PAGES_FIELD_NUMBER: _ClassVar[int] RULES_FIELD_NUMBER: _ClassVar[int] DOCUMENTATION_ROOT_URL_FIELD_NUMBER: _ClassVar[int] SERVICE_ROOT_URL_FIELD_NUMBER: _ClassVar[int] OVERVIEW_FIELD_NUMBER: _ClassVar[int] summary: str pages: _containers.RepeatedCompositeFieldContainer[Page] rules: _containers.RepeatedCompositeFieldContainer[DocumentationRule] documentation_root_url: str service_root_url: str overview: str def __init__( self, summary: _Optional[str] = ..., pages: _Optional[_Iterable[_Union[Page, _Mapping]]] = ..., rules: _Optional[_Iterable[_Union[DocumentationRule, _Mapping]]] = ..., documentation_root_url: _Optional[str] = ..., service_root_url: _Optional[str] = ..., overview: _Optional[str] = ..., ) -> None: ... class DocumentationRule(_message.Message): __slots__ = ("selector", "description", "deprecation_description") SELECTOR_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] DEPRECATION_DESCRIPTION_FIELD_NUMBER: _ClassVar[int] selector: str description: str deprecation_description: str def __init__( self, selector: _Optional[str] = ..., description: _Optional[str] = ..., deprecation_description: _Optional[str] = ..., ) -> None: ... class Page(_message.Message): __slots__ = ("name", "content", "subpages") NAME_FIELD_NUMBER: _ClassVar[int] CONTENT_FIELD_NUMBER: _ClassVar[int] SUBPAGES_FIELD_NUMBER: _ClassVar[int] name: str content: str subpages: _containers.RepeatedCompositeFieldContainer[Page] def __init__( self, name: _Optional[str] = ..., content: _Optional[str] = ..., subpages: _Optional[_Iterable[_Union[Page, _Mapping]]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/endpoint.proto0000644000000000000000000000551315177035222022413 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "EndpointProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // `Endpoint` describes a network address of a service that serves a set of // APIs. It is commonly known as a service endpoint. A service may expose // any number of service endpoints, and all service endpoints share the same // service definition, such as quota limits and monitoring metrics. // // Example: // // type: google.api.Service // name: library-example.googleapis.com // endpoints: // # Declares network address `https://library-example.googleapis.com` // # for service `library-example.googleapis.com`. The `https` scheme // # is implicit for all service endpoints. Other schemes may be // # supported in the future. // - name: library-example.googleapis.com // allow_cors: false // - name: content-staging-library-example.googleapis.com // # Allows HTTP OPTIONS calls to be passed to the API frontend, for it // # to decide whether the subsequent cross-origin request is allowed // # to proceed. // allow_cors: true message Endpoint { // The canonical name of this endpoint. string name = 1; // Aliases for this endpoint, these will be served by the same UrlMap as the // parent endpoint, and will be provisioned in the GCP stack for the Regional // Endpoints. repeated string aliases = 2; // The specification of an Internet routable address of API frontend that will // handle requests to this [API // Endpoint](https://cloud.google.com/apis/design/glossary). It should be // either a valid IPv4 address or a fully-qualified domain name. For example, // "8.8.8.8" or "myservice.appspot.com". string target = 101; // Allowing // [CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing), aka // cross-domain traffic, would allow the backends served from this endpoint to // receive and respond to HTTP OPTIONS requests. The response will be used by // the browser to determine whether the subsequent cross-origin request is // allowed to proceed. bool allow_cors = 5; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/endpoint_pb2.py0000644000000000000000000000407515177035222022445 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/endpoint.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x19google/api/endpoint.proto\x12\ngoogle.api"M\n\x08\x45ndpoint\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0f\n\x07\x61liases\x18\x02 \x03(\t\x12\x0e\n\x06target\x18\x65 \x01(\t\x12\x12\n\nallow_cors\x18\x05 \x01(\x08\x42o\n\x0e\x63om.google.apiB\rEndpointProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.endpoint_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\rEndpointProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_ENDPOINT"]._serialized_start = 41 _globals["_ENDPOINT"]._serialized_end = 118 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/endpoint_pb2.pyi0000644000000000000000000000270715177035226022622 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Endpoint(_message.Message): __slots__ = ("name", "aliases", "target", "allow_cors") NAME_FIELD_NUMBER: _ClassVar[int] ALIASES_FIELD_NUMBER: _ClassVar[int] TARGET_FIELD_NUMBER: _ClassVar[int] ALLOW_CORS_FIELD_NUMBER: _ClassVar[int] name: str aliases: _containers.RepeatedScalarFieldContainer[str] target: str allow_cors: bool def __init__( self, name: _Optional[str] = ..., aliases: _Optional[_Iterable[str]] = ..., target: _Optional[str] = ..., allow_cors: bool = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/error_reason.proto0000644000000000000000000007271115177035224023301 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/error_reason;error_reason"; option java_multiple_files = true; option java_outer_classname = "ErrorReasonProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Defines the supported values for `google.rpc.ErrorInfo.reason` for the // `googleapis.com` error domain. This error domain is reserved for [Service // Infrastructure](https://cloud.google.com/service-infrastructure/docs/overview). // For each error info of this domain, the metadata key "service" refers to the // logical identifier of an API service, such as "pubsub.googleapis.com". The // "consumer" refers to the entity that consumes an API Service. It typically is // a Google project that owns the client application or the server resource, // such as "projects/123". Other metadata keys are specific to each error // reason. For more information, see the definition of the specific error // reason. enum ErrorReason { // Do not use this default value. ERROR_REASON_UNSPECIFIED = 0; // The request is calling a disabled service for a consumer. // // Example of an ErrorInfo when the consumer "projects/123" contacting // "pubsub.googleapis.com" service which is disabled: // // { "reason": "SERVICE_DISABLED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "pubsub.googleapis.com" // } // } // // This response indicates the "pubsub.googleapis.com" has been disabled in // "projects/123". SERVICE_DISABLED = 1; // The request whose associated billing account is disabled. // // Example of an ErrorInfo when the consumer "projects/123" fails to contact // "pubsub.googleapis.com" service because the associated billing account is // disabled: // // { "reason": "BILLING_DISABLED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "pubsub.googleapis.com" // } // } // // This response indicates the billing account associated has been disabled. BILLING_DISABLED = 2; // The request is denied because the provided [API // key](https://cloud.google.com/docs/authentication/api-keys) is invalid. It // may be in a bad format, cannot be found, or has been expired). // // Example of an ErrorInfo when the request is contacting // "storage.googleapis.com" service with an invalid API key: // // { "reason": "API_KEY_INVALID", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com", // } // } API_KEY_INVALID = 3; // The request is denied because it violates [API key API // restrictions](https://cloud.google.com/docs/authentication/api-keys#adding_api_restrictions). // // Example of an ErrorInfo when the consumer "projects/123" fails to call the // "storage.googleapis.com" service because this service is restricted in the // API key: // // { "reason": "API_KEY_SERVICE_BLOCKED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com" // } // } API_KEY_SERVICE_BLOCKED = 4; // The request is denied because it violates [API key HTTP // restrictions](https://cloud.google.com/docs/authentication/api-keys#adding_http_restrictions). // // Example of an ErrorInfo when the consumer "projects/123" fails to call // "storage.googleapis.com" service because the http referrer of the request // violates API key HTTP restrictions: // // { "reason": "API_KEY_HTTP_REFERRER_BLOCKED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com", // } // } API_KEY_HTTP_REFERRER_BLOCKED = 7; // The request is denied because it violates [API key IP address // restrictions](https://cloud.google.com/docs/authentication/api-keys#adding_application_restrictions). // // Example of an ErrorInfo when the consumer "projects/123" fails to call // "storage.googleapis.com" service because the caller IP of the request // violates API key IP address restrictions: // // { "reason": "API_KEY_IP_ADDRESS_BLOCKED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com", // } // } API_KEY_IP_ADDRESS_BLOCKED = 8; // The request is denied because it violates [API key Android application // restrictions](https://cloud.google.com/docs/authentication/api-keys#adding_application_restrictions). // // Example of an ErrorInfo when the consumer "projects/123" fails to call // "storage.googleapis.com" service because the request from the Android apps // violates the API key Android application restrictions: // // { "reason": "API_KEY_ANDROID_APP_BLOCKED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com" // } // } API_KEY_ANDROID_APP_BLOCKED = 9; // The request is denied because it violates [API key iOS application // restrictions](https://cloud.google.com/docs/authentication/api-keys#adding_application_restrictions). // // Example of an ErrorInfo when the consumer "projects/123" fails to call // "storage.googleapis.com" service because the request from the iOS apps // violates the API key iOS application restrictions: // // { "reason": "API_KEY_IOS_APP_BLOCKED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com" // } // } API_KEY_IOS_APP_BLOCKED = 13; // The request is denied because there is not enough rate quota for the // consumer. // // Example of an ErrorInfo when the consumer "projects/123" fails to contact // "pubsub.googleapis.com" service because consumer's rate quota usage has // reached the maximum value set for the quota limit // "ReadsPerMinutePerProject" on the quota metric // "pubsub.googleapis.com/read_requests": // // { "reason": "RATE_LIMIT_EXCEEDED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "pubsub.googleapis.com", // "quota_metric": "pubsub.googleapis.com/read_requests", // "quota_limit": "ReadsPerMinutePerProject" // } // } // // Example of an ErrorInfo when the consumer "projects/123" checks quota on // the service "dataflow.googleapis.com" and hits the organization quota // limit "DefaultRequestsPerMinutePerOrganization" on the metric // "dataflow.googleapis.com/default_requests". // // { "reason": "RATE_LIMIT_EXCEEDED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "dataflow.googleapis.com", // "quota_metric": "dataflow.googleapis.com/default_requests", // "quota_limit": "DefaultRequestsPerMinutePerOrganization" // } // } RATE_LIMIT_EXCEEDED = 5; // The request is denied because there is not enough resource quota for the // consumer. // // Example of an ErrorInfo when the consumer "projects/123" fails to contact // "compute.googleapis.com" service because consumer's resource quota usage // has reached the maximum value set for the quota limit "VMsPerProject" // on the quota metric "compute.googleapis.com/vms": // // { "reason": "RESOURCE_QUOTA_EXCEEDED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "compute.googleapis.com", // "quota_metric": "compute.googleapis.com/vms", // "quota_limit": "VMsPerProject" // } // } // // Example of an ErrorInfo when the consumer "projects/123" checks resource // quota on the service "dataflow.googleapis.com" and hits the organization // quota limit "jobs-per-organization" on the metric // "dataflow.googleapis.com/job_count". // // { "reason": "RESOURCE_QUOTA_EXCEEDED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "dataflow.googleapis.com", // "quota_metric": "dataflow.googleapis.com/job_count", // "quota_limit": "jobs-per-organization" // } // } RESOURCE_QUOTA_EXCEEDED = 6; // The request whose associated billing account address is in a tax restricted // location, violates the local tax restrictions when creating resources in // the restricted region. // // Example of an ErrorInfo when creating the Cloud Storage Bucket in the // container "projects/123" under a tax restricted region // "locations/asia-northeast3": // // { "reason": "LOCATION_TAX_POLICY_VIOLATED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com", // "location": "locations/asia-northeast3" // } // } // // This response indicates creating the Cloud Storage Bucket in // "locations/asia-northeast3" violates the location tax restriction. LOCATION_TAX_POLICY_VIOLATED = 10; // The request is denied because the caller does not have required permission // on the user project "projects/123" or the user project is invalid. For more // information, check the [userProject System // Parameters](https://cloud.google.com/apis/docs/system-parameters). // // Example of an ErrorInfo when the caller is calling Cloud Storage service // with insufficient permissions on the user project: // // { "reason": "USER_PROJECT_DENIED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com" // } // } USER_PROJECT_DENIED = 11; // The request is denied because the consumer "projects/123" is suspended due // to Terms of Service(Tos) violations. Check [Project suspension // guidelines](https://cloud.google.com/resource-manager/docs/project-suspension-guidelines) // for more information. // // Example of an ErrorInfo when calling Cloud Storage service with the // suspended consumer "projects/123": // // { "reason": "CONSUMER_SUSPENDED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com" // } // } CONSUMER_SUSPENDED = 12; // The request is denied because the associated consumer is invalid. It may be // in a bad format, cannot be found, or have been deleted. // // Example of an ErrorInfo when calling Cloud Storage service with the // invalid consumer "projects/123": // // { "reason": "CONSUMER_INVALID", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com" // } // } CONSUMER_INVALID = 14; // The request is denied because it violates [VPC Service // Controls](https://cloud.google.com/vpc-service-controls/docs/overview). // The 'uid' field is a random generated identifier that customer can use it // to search the audit log for a request rejected by VPC Service Controls. For // more information, please refer [VPC Service Controls // Troubleshooting](https://cloud.google.com/vpc-service-controls/docs/troubleshooting#unique-id) // // Example of an ErrorInfo when the consumer "projects/123" fails to call // Cloud Storage service because the request is prohibited by the VPC Service // Controls. // // { "reason": "SECURITY_POLICY_VIOLATED", // "domain": "googleapis.com", // "metadata": { // "uid": "123456789abcde", // "consumer": "projects/123", // "service": "storage.googleapis.com" // } // } SECURITY_POLICY_VIOLATED = 15; // The request is denied because the provided access token has expired. // // Example of an ErrorInfo when the request is calling Cloud Storage service // with an expired access token: // // { "reason": "ACCESS_TOKEN_EXPIRED", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com", // "method": "google.storage.v1.Storage.GetObject" // } // } ACCESS_TOKEN_EXPIRED = 16; // The request is denied because the provided access token doesn't have at // least one of the acceptable scopes required for the API. Please check // [OAuth 2.0 Scopes for Google // APIs](https://developers.google.com/identity/protocols/oauth2/scopes) for // the list of the OAuth 2.0 scopes that you might need to request to access // the API. // // Example of an ErrorInfo when the request is calling Cloud Storage service // with an access token that is missing required scopes: // // { "reason": "ACCESS_TOKEN_SCOPE_INSUFFICIENT", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com", // "method": "google.storage.v1.Storage.GetObject" // } // } ACCESS_TOKEN_SCOPE_INSUFFICIENT = 17; // The request is denied because the account associated with the provided // access token is in an invalid state, such as disabled or deleted. // For more information, see https://cloud.google.com/docs/authentication. // // Warning: For privacy reasons, the server may not be able to disclose the // email address for some accounts. The client MUST NOT depend on the // availability of the `email` attribute. // // Example of an ErrorInfo when the request is to the Cloud Storage API with // an access token that is associated with a disabled or deleted [service // account](http://cloud/iam/docs/service-accounts): // // { "reason": "ACCOUNT_STATE_INVALID", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com", // "method": "google.storage.v1.Storage.GetObject", // "email": "user@123.iam.gserviceaccount.com" // } // } ACCOUNT_STATE_INVALID = 18; // The request is denied because the type of the provided access token is not // supported by the API being called. // // Example of an ErrorInfo when the request is to the Cloud Storage API with // an unsupported token type. // // { "reason": "ACCESS_TOKEN_TYPE_UNSUPPORTED", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com", // "method": "google.storage.v1.Storage.GetObject" // } // } ACCESS_TOKEN_TYPE_UNSUPPORTED = 19; // The request is denied because the request doesn't have any authentication // credentials. For more information regarding the supported authentication // strategies for Google Cloud APIs, see // https://cloud.google.com/docs/authentication. // // Example of an ErrorInfo when the request is to the Cloud Storage API // without any authentication credentials. // // { "reason": "CREDENTIALS_MISSING", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com", // "method": "google.storage.v1.Storage.GetObject" // } // } CREDENTIALS_MISSING = 20; // The request is denied because the provided project owning the resource // which acts as the [API // consumer](https://cloud.google.com/apis/design/glossary#api_consumer) is // invalid. It may be in a bad format or empty. // // Example of an ErrorInfo when the request is to the Cloud Functions API, // but the offered resource project in the request in a bad format which can't // perform the ListFunctions method. // // { "reason": "RESOURCE_PROJECT_INVALID", // "domain": "googleapis.com", // "metadata": { // "service": "cloudfunctions.googleapis.com", // "method": // "google.cloud.functions.v1.CloudFunctionsService.ListFunctions" // } // } RESOURCE_PROJECT_INVALID = 21; // The request is denied because the provided session cookie is missing, // invalid or failed to decode. // // Example of an ErrorInfo when the request is calling Cloud Storage service // with a SID cookie which can't be decoded. // // { "reason": "SESSION_COOKIE_INVALID", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com", // "method": "google.storage.v1.Storage.GetObject", // "cookie": "SID" // } // } SESSION_COOKIE_INVALID = 23; // The request is denied because the user is from a Google Workspace customer // that blocks their users from accessing a particular service. // // Example scenario: https://support.google.com/a/answer/9197205?hl=en // // Example of an ErrorInfo when access to Google Cloud Storage service is // blocked by the Google Workspace administrator: // // { "reason": "USER_BLOCKED_BY_ADMIN", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com", // "method": "google.storage.v1.Storage.GetObject", // } // } USER_BLOCKED_BY_ADMIN = 24; // The request is denied because the resource service usage is restricted // by administrators according to the organization policy constraint. // For more information see // https://cloud.google.com/resource-manager/docs/organization-policy/restricting-services. // // Example of an ErrorInfo when access to Google Cloud Storage service is // restricted by Resource Usage Restriction policy: // // { "reason": "RESOURCE_USAGE_RESTRICTION_VIOLATED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/project-123", // "service": "storage.googleapis.com" // } // } RESOURCE_USAGE_RESTRICTION_VIOLATED = 25; // Unimplemented. Do not use. // // The request is denied because it contains unsupported system parameters in // URL query parameters or HTTP headers. For more information, // see https://cloud.google.com/apis/docs/system-parameters // // Example of an ErrorInfo when access "pubsub.googleapis.com" service with // a request header of "x-goog-user-ip": // // { "reason": "SYSTEM_PARAMETER_UNSUPPORTED", // "domain": "googleapis.com", // "metadata": { // "service": "pubsub.googleapis.com" // "parameter": "x-goog-user-ip" // } // } SYSTEM_PARAMETER_UNSUPPORTED = 26; // The request is denied because it violates Org Restriction: the requested // resource does not belong to allowed organizations specified in // "X-Goog-Allowed-Resources" header. // // Example of an ErrorInfo when accessing a GCP resource that is restricted by // Org Restriction for "pubsub.googleapis.com" service. // // { // reason: "ORG_RESTRICTION_VIOLATION" // domain: "googleapis.com" // metadata { // "consumer":"projects/123456" // "service": "pubsub.googleapis.com" // } // } ORG_RESTRICTION_VIOLATION = 27; // The request is denied because "X-Goog-Allowed-Resources" header is in a bad // format. // // Example of an ErrorInfo when // accessing "pubsub.googleapis.com" service with an invalid // "X-Goog-Allowed-Resources" request header. // // { // reason: "ORG_RESTRICTION_HEADER_INVALID" // domain: "googleapis.com" // metadata { // "consumer":"projects/123456" // "service": "pubsub.googleapis.com" // } // } ORG_RESTRICTION_HEADER_INVALID = 28; // Unimplemented. Do not use. // // The request is calling a service that is not visible to the consumer. // // Example of an ErrorInfo when the consumer "projects/123" contacting // "pubsub.googleapis.com" service which is not visible to the consumer. // // { "reason": "SERVICE_NOT_VISIBLE", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "pubsub.googleapis.com" // } // } // // This response indicates the "pubsub.googleapis.com" is not visible to // "projects/123" (or it may not exist). SERVICE_NOT_VISIBLE = 29; // The request is related to a project for which GCP access is suspended. // // Example of an ErrorInfo when the consumer "projects/123" fails to contact // "pubsub.googleapis.com" service because GCP access is suspended: // // { "reason": "GCP_SUSPENDED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "pubsub.googleapis.com" // } // } // // This response indicates the associated GCP account has been suspended. GCP_SUSPENDED = 30; // The request violates the location policies when creating resources in // the restricted region. // // Example of an ErrorInfo when creating the Cloud Storage Bucket by // "projects/123" for service storage.googleapis.com: // // { "reason": "LOCATION_POLICY_VIOLATED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "storage.googleapis.com", // } // } // // This response indicates creating the Cloud Storage Bucket in // "locations/asia-northeast3" violates at least one location policy. // The troubleshooting guidance is provided in the Help links. LOCATION_POLICY_VIOLATED = 31; // The request is denied because origin request header is missing. // // Example of an ErrorInfo when // accessing "pubsub.googleapis.com" service with an empty "Origin" request // header. // // { // reason: "MISSING_ORIGIN" // domain: "googleapis.com" // metadata { // "consumer":"projects/123456" // "service": "pubsub.googleapis.com" // } // } MISSING_ORIGIN = 33; // The request is denied because the request contains more than one credential // type that are individually acceptable, but not together. The customer // should retry their request with only one set of credentials. // // Example of an ErrorInfo when // accessing "pubsub.googleapis.com" service with overloaded credentials. // // { // reason: "OVERLOADED_CREDENTIALS" // domain: "googleapis.com" // metadata { // "consumer":"projects/123456" // "service": "pubsub.googleapis.com" // } // } OVERLOADED_CREDENTIALS = 34; // The request whose associated location violates the location org policy // restrictions when creating resources in the restricted region. // // Example of an ErrorInfo when creating the Cloud Storage Bucket in the // container "projects/123" under a restricted region // "locations/asia-northeast3": // // { // "reason": "LOCATION_ORG_POLICY_VIOLATED", // "domain": "googleapis.com", // "metadata": { // "resource": "projects/123", // "location": "locations/asia-northeast3" // } // } // // This response indicates creating the Cloud Storage Bucket in // "locations/asia-northeast3" violates the location org policy restriction. LOCATION_ORG_POLICY_VIOLATED = 35; // The request is denied because it access data of regulated customers using // TLS 1.0 and 1.1. // // Example of an ErrorInfo when accessing a GCP resource "projects/123" that // is restricted by TLS Version Restriction for "pubsub.googleapis.com" // service. // // { // "reason": "TLS_ORG_POLICY_VIOLATED", // "domain": "googleapis.com", // "metadata": { // "service": "pubsub.googleapis.com" // "resource": "projects/123", // "policyName": "constraints/gcp.restrictTLSVersion", // "tlsVersion": "TLS_VERSION_1" // } // } TLS_ORG_POLICY_VIOLATED = 36; // The request is denied because the associated project has exceeded the // emulator quota limit. // // Example of an ErrorInfo when the associated "projects/123" has exceeded the // emulator quota limit. // // { // "reason": "EMULATOR_QUOTA_EXCEEDED", // "domain": "googleapis.com", // "metadata": { // "service": "pubsub.googleapis.com" // "consumer": "projects/123" // } // } EMULATOR_QUOTA_EXCEEDED = 38; // The request is denied because the associated application credential header // is invalid for an Android applications. // // Example of an ErrorInfo when the request from an Android application to the // "pubsub.googleapis.com" with an invalid application credential header. // // { // "reason": "CREDENTIAL_ANDROID_APP_INVALID", // "domain": "googleapis.com", // "metadata": { // "service": "pubsub.googleapis.com" // } // } CREDENTIAL_ANDROID_APP_INVALID = 39; // The request is denied because IAM permission on resource is denied. // // Example of an ErrorInfo when the IAM permission `aiplatform.datasets.list` // is denied on resource `projects/123`. // // { // "reason": "IAM_PERMISSION_DENIED", // "domain": "googleapis.com", // "metadata": { // "resource": "projects/123" // "permission": "aiplatform.datasets.list" // } // } IAM_PERMISSION_DENIED = 41; // The request is denied because it contains the invalid JWT token. // // Example of an ErrorInfo when the request contains an invalid JWT token for // service `storage.googleapis.com`. // // { // "reason": "JWT_TOKEN_INVALID", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com" // } // } JWT_TOKEN_INVALID = 42; // The request is denied because it contains credential with type that is // unsupported. // // Example of an ErrorInfo when the request contains an unsupported credential // type for service `storage.googleapis.com`. // // { // "reason": "CREDENTIAL_TYPE_UNSUPPORTED", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com" // } // } CREDENTIAL_TYPE_UNSUPPORTED = 43; // The request is denied because it contains unsupported account type. // // Example of an ErrorInfo when the request contains an unsupported account // type for service `storage.googleapis.com`. // // { // "reason": "ACCOUNT_TYPE_UNSUPPORTED", // "domain": "googleapis.com", // "metadata": { // "service": "storage.googleapis.com" // } // } ACCOUNT_TYPE_UNSUPPORTED = 44; // The request is denied because the API endpoint is restricted by // administrators according to the organization policy constraint. // For more information see // https://cloud.google.com/assured-workloads/docs/restrict-endpoint-usage. // // Example of an ErrorInfo when access to Google Cloud Storage service is // restricted by Restrict Endpoint Usage policy: // // { // "reason": "ENDPOINT_USAGE_RESTRICTION_VIOLATED", // "domain": "googleapis.com/policies/endpointUsageRestriction", // "metadata": { // "policy_name": "constraints/gcp.restrictEndpointUsage", // "checked_value": "storage.googleapis.com" // "consumer": "organization/123" // "service": "storage.googleapis.com" // } // } ENDPOINT_USAGE_RESTRICTION_VIOLATED = 45; // The request is denied because the TLS Cipher Suite is restricted by // administrators according to the organization policy constraint. // For more information see // https://cloud.google.com/assured-workloads/docs/restrict-tls-cipher-suites // // Example of an ErrorInfo when access to Google Cloud BigQuery service is // restricted by Restrict TLS Cipher Suites policy: // // { // "reason": "TLS_CIPHER_RESTRICTION_VIOLATED", // "domain": "googleapis.com/policies/tlsCipherRestriction", // "metadata": { // "policy_name": "constraints/gcp.restrictTLSCipherSuites", // "checked_value": "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 // "consumer": "organization/123" // "service": "bigquery.googleapis.com" // } // } TLS_CIPHER_RESTRICTION_VIOLATED = 46; // The request is denied because the MCP activation check fails. // // Example of an ErrorInfo when the container "projects/123" contacting // "pubsub.googleapis.com" service which is disabled by MCP: // // { "reason": "MCP_SERVER_DISABLED", // "domain": "googleapis.com", // "metadata": { // "consumer": "projects/123", // "service": "pubsub.googleapis.com" // } // } // // This response indicates the "pubsub.googleapis.com" has been disabled in // "projects/123" for MCP. MCP_SERVER_DISABLED = 47; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/error_reason_pb2.py0000644000000000000000000000764015177035226023332 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/error_reason.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n\x1dgoogle/api/error_reason.proto\x12\ngoogle.api*\x92\n\n\x0b\x45rrorReason\x12\x1c\n\x18\x45RROR_REASON_UNSPECIFIED\x10\x00\x12\x14\n\x10SERVICE_DISABLED\x10\x01\x12\x14\n\x10\x42ILLING_DISABLED\x10\x02\x12\x13\n\x0f\x41PI_KEY_INVALID\x10\x03\x12\x1b\n\x17\x41PI_KEY_SERVICE_BLOCKED\x10\x04\x12!\n\x1d\x41PI_KEY_HTTP_REFERRER_BLOCKED\x10\x07\x12\x1e\n\x1a\x41PI_KEY_IP_ADDRESS_BLOCKED\x10\x08\x12\x1f\n\x1b\x41PI_KEY_ANDROID_APP_BLOCKED\x10\t\x12\x1b\n\x17\x41PI_KEY_IOS_APP_BLOCKED\x10\r\x12\x17\n\x13RATE_LIMIT_EXCEEDED\x10\x05\x12\x1b\n\x17RESOURCE_QUOTA_EXCEEDED\x10\x06\x12 \n\x1cLOCATION_TAX_POLICY_VIOLATED\x10\n\x12\x17\n\x13USER_PROJECT_DENIED\x10\x0b\x12\x16\n\x12\x43ONSUMER_SUSPENDED\x10\x0c\x12\x14\n\x10\x43ONSUMER_INVALID\x10\x0e\x12\x1c\n\x18SECURITY_POLICY_VIOLATED\x10\x0f\x12\x18\n\x14\x41\x43\x43\x45SS_TOKEN_EXPIRED\x10\x10\x12#\n\x1f\x41\x43\x43\x45SS_TOKEN_SCOPE_INSUFFICIENT\x10\x11\x12\x19\n\x15\x41\x43\x43OUNT_STATE_INVALID\x10\x12\x12!\n\x1d\x41\x43\x43\x45SS_TOKEN_TYPE_UNSUPPORTED\x10\x13\x12\x17\n\x13\x43REDENTIALS_MISSING\x10\x14\x12\x1c\n\x18RESOURCE_PROJECT_INVALID\x10\x15\x12\x1a\n\x16SESSION_COOKIE_INVALID\x10\x17\x12\x19\n\x15USER_BLOCKED_BY_ADMIN\x10\x18\x12'\n#RESOURCE_USAGE_RESTRICTION_VIOLATED\x10\x19\x12 \n\x1cSYSTEM_PARAMETER_UNSUPPORTED\x10\x1a\x12\x1d\n\x19ORG_RESTRICTION_VIOLATION\x10\x1b\x12\"\n\x1eORG_RESTRICTION_HEADER_INVALID\x10\x1c\x12\x17\n\x13SERVICE_NOT_VISIBLE\x10\x1d\x12\x11\n\rGCP_SUSPENDED\x10\x1e\x12\x1c\n\x18LOCATION_POLICY_VIOLATED\x10\x1f\x12\x12\n\x0eMISSING_ORIGIN\x10!\x12\x1a\n\x16OVERLOADED_CREDENTIALS\x10\"\x12 \n\x1cLOCATION_ORG_POLICY_VIOLATED\x10#\x12\x1b\n\x17TLS_ORG_POLICY_VIOLATED\x10$\x12\x1b\n\x17\x45MULATOR_QUOTA_EXCEEDED\x10&\x12\"\n\x1e\x43REDENTIAL_ANDROID_APP_INVALID\x10'\x12\x19\n\x15IAM_PERMISSION_DENIED\x10)\x12\x15\n\x11JWT_TOKEN_INVALID\x10*\x12\x1f\n\x1b\x43REDENTIAL_TYPE_UNSUPPORTED\x10+\x12\x1c\n\x18\x41\x43\x43OUNT_TYPE_UNSUPPORTED\x10,\x12'\n#ENDPOINT_USAGE_RESTRICTION_VIOLATED\x10-\x12#\n\x1fTLS_CIPHER_RESTRICTION_VIOLATED\x10.\x12\x17\n\x13MCP_SERVER_DISABLED\x10/Bp\n\x0e\x63om.google.apiB\x10\x45rrorReasonProtoP\x01ZCgoogle.golang.org/genproto/googleapis/api/error_reason;error_reason\xa2\x02\x04GAPIb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.error_reason_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\020ErrorReasonProtoP\001ZCgoogle.golang.org/genproto/googleapis/api/error_reason;error_reason\242\002\004GAPI" _globals["_ERRORREASON"]._serialized_start = 46 _globals["_ERRORREASON"]._serialized_end = 1344 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/error_reason_pb2.pyi0000644000000000000000000001131515177035222023471 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class ErrorReason(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () ERROR_REASON_UNSPECIFIED: _ClassVar[ErrorReason] SERVICE_DISABLED: _ClassVar[ErrorReason] BILLING_DISABLED: _ClassVar[ErrorReason] API_KEY_INVALID: _ClassVar[ErrorReason] API_KEY_SERVICE_BLOCKED: _ClassVar[ErrorReason] API_KEY_HTTP_REFERRER_BLOCKED: _ClassVar[ErrorReason] API_KEY_IP_ADDRESS_BLOCKED: _ClassVar[ErrorReason] API_KEY_ANDROID_APP_BLOCKED: _ClassVar[ErrorReason] API_KEY_IOS_APP_BLOCKED: _ClassVar[ErrorReason] RATE_LIMIT_EXCEEDED: _ClassVar[ErrorReason] RESOURCE_QUOTA_EXCEEDED: _ClassVar[ErrorReason] LOCATION_TAX_POLICY_VIOLATED: _ClassVar[ErrorReason] USER_PROJECT_DENIED: _ClassVar[ErrorReason] CONSUMER_SUSPENDED: _ClassVar[ErrorReason] CONSUMER_INVALID: _ClassVar[ErrorReason] SECURITY_POLICY_VIOLATED: _ClassVar[ErrorReason] ACCESS_TOKEN_EXPIRED: _ClassVar[ErrorReason] ACCESS_TOKEN_SCOPE_INSUFFICIENT: _ClassVar[ErrorReason] ACCOUNT_STATE_INVALID: _ClassVar[ErrorReason] ACCESS_TOKEN_TYPE_UNSUPPORTED: _ClassVar[ErrorReason] CREDENTIALS_MISSING: _ClassVar[ErrorReason] RESOURCE_PROJECT_INVALID: _ClassVar[ErrorReason] SESSION_COOKIE_INVALID: _ClassVar[ErrorReason] USER_BLOCKED_BY_ADMIN: _ClassVar[ErrorReason] RESOURCE_USAGE_RESTRICTION_VIOLATED: _ClassVar[ErrorReason] SYSTEM_PARAMETER_UNSUPPORTED: _ClassVar[ErrorReason] ORG_RESTRICTION_VIOLATION: _ClassVar[ErrorReason] ORG_RESTRICTION_HEADER_INVALID: _ClassVar[ErrorReason] SERVICE_NOT_VISIBLE: _ClassVar[ErrorReason] GCP_SUSPENDED: _ClassVar[ErrorReason] LOCATION_POLICY_VIOLATED: _ClassVar[ErrorReason] MISSING_ORIGIN: _ClassVar[ErrorReason] OVERLOADED_CREDENTIALS: _ClassVar[ErrorReason] LOCATION_ORG_POLICY_VIOLATED: _ClassVar[ErrorReason] TLS_ORG_POLICY_VIOLATED: _ClassVar[ErrorReason] EMULATOR_QUOTA_EXCEEDED: _ClassVar[ErrorReason] CREDENTIAL_ANDROID_APP_INVALID: _ClassVar[ErrorReason] IAM_PERMISSION_DENIED: _ClassVar[ErrorReason] JWT_TOKEN_INVALID: _ClassVar[ErrorReason] CREDENTIAL_TYPE_UNSUPPORTED: _ClassVar[ErrorReason] ACCOUNT_TYPE_UNSUPPORTED: _ClassVar[ErrorReason] ENDPOINT_USAGE_RESTRICTION_VIOLATED: _ClassVar[ErrorReason] TLS_CIPHER_RESTRICTION_VIOLATED: _ClassVar[ErrorReason] MCP_SERVER_DISABLED: _ClassVar[ErrorReason] ERROR_REASON_UNSPECIFIED: ErrorReason SERVICE_DISABLED: ErrorReason BILLING_DISABLED: ErrorReason API_KEY_INVALID: ErrorReason API_KEY_SERVICE_BLOCKED: ErrorReason API_KEY_HTTP_REFERRER_BLOCKED: ErrorReason API_KEY_IP_ADDRESS_BLOCKED: ErrorReason API_KEY_ANDROID_APP_BLOCKED: ErrorReason API_KEY_IOS_APP_BLOCKED: ErrorReason RATE_LIMIT_EXCEEDED: ErrorReason RESOURCE_QUOTA_EXCEEDED: ErrorReason LOCATION_TAX_POLICY_VIOLATED: ErrorReason USER_PROJECT_DENIED: ErrorReason CONSUMER_SUSPENDED: ErrorReason CONSUMER_INVALID: ErrorReason SECURITY_POLICY_VIOLATED: ErrorReason ACCESS_TOKEN_EXPIRED: ErrorReason ACCESS_TOKEN_SCOPE_INSUFFICIENT: ErrorReason ACCOUNT_STATE_INVALID: ErrorReason ACCESS_TOKEN_TYPE_UNSUPPORTED: ErrorReason CREDENTIALS_MISSING: ErrorReason RESOURCE_PROJECT_INVALID: ErrorReason SESSION_COOKIE_INVALID: ErrorReason USER_BLOCKED_BY_ADMIN: ErrorReason RESOURCE_USAGE_RESTRICTION_VIOLATED: ErrorReason SYSTEM_PARAMETER_UNSUPPORTED: ErrorReason ORG_RESTRICTION_VIOLATION: ErrorReason ORG_RESTRICTION_HEADER_INVALID: ErrorReason SERVICE_NOT_VISIBLE: ErrorReason GCP_SUSPENDED: ErrorReason LOCATION_POLICY_VIOLATED: ErrorReason MISSING_ORIGIN: ErrorReason OVERLOADED_CREDENTIALS: ErrorReason LOCATION_ORG_POLICY_VIOLATED: ErrorReason TLS_ORG_POLICY_VIOLATED: ErrorReason EMULATOR_QUOTA_EXCEEDED: ErrorReason CREDENTIAL_ANDROID_APP_INVALID: ErrorReason IAM_PERMISSION_DENIED: ErrorReason JWT_TOKEN_INVALID: ErrorReason CREDENTIAL_TYPE_UNSUPPORTED: ErrorReason ACCOUNT_TYPE_UNSUPPORTED: ErrorReason ENDPOINT_USAGE_RESTRICTION_VIOLATED: ErrorReason TLS_CIPHER_RESTRICTION_VIOLATED: ErrorReason MCP_SERVER_DISABLED: ErrorReason ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/field_behavior.proto0000644000000000000000000001032215177035223023530 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "FieldBehaviorProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.FieldOptions { // A designation of a specific field behavior (required, output only, etc.) // in protobuf messages. // // Examples: // // string name = 1 [(google.api.field_behavior) = REQUIRED]; // State state = 1 [(google.api.field_behavior) = OUTPUT_ONLY]; // google.protobuf.Duration ttl = 1 // [(google.api.field_behavior) = INPUT_ONLY]; // google.protobuf.Timestamp expire_time = 1 // [(google.api.field_behavior) = OUTPUT_ONLY, // (google.api.field_behavior) = IMMUTABLE]; repeated google.api.FieldBehavior field_behavior = 1052 [packed = false]; } // An indicator of the behavior of a given field (for example, that a field // is required in requests, or given as output but ignored as input). // This **does not** change the behavior in protocol buffers itself; it only // denotes the behavior and may affect how API tooling handles the field. // // Note: This enum **may** receive new values in the future. enum FieldBehavior { // Conventional default for enums. Do not use this. FIELD_BEHAVIOR_UNSPECIFIED = 0; // Specifically denotes a field as optional. // While all fields in protocol buffers are optional, this may be specified // for emphasis if appropriate. OPTIONAL = 1; // Denotes a field as required. // This indicates that the field **must** be provided as part of the request, // and failure to do so will cause an error (usually `INVALID_ARGUMENT`). REQUIRED = 2; // Denotes a field as output only. // This indicates that the field is provided in responses, but including the // field in a request does nothing (the server *must* ignore it and // *must not* throw an error as a result of the field's presence). OUTPUT_ONLY = 3; // Denotes a field as input only. // This indicates that the field is provided in requests, and the // corresponding field is not included in output. INPUT_ONLY = 4; // Denotes a field as immutable. // This indicates that the field may be set once in a request to create a // resource, but may not be changed thereafter. IMMUTABLE = 5; // Denotes that a (repeated) field is an unordered list. // This indicates that the service may provide the elements of the list // in any arbitrary order, rather than the order the user originally // provided. Additionally, the list's order may or may not be stable. UNORDERED_LIST = 6; // Denotes that this field returns a non-empty default value if not set. // This indicates that if the user provides the empty value in a request, // a non-empty value will be returned. The user will not be aware of what // non-empty value to expect. NON_EMPTY_DEFAULT = 7; // Denotes that the field in a resource (a message annotated with // google.api.resource) is used in the resource name to uniquely identify the // resource. For AIP-compliant APIs, this should only be applied to the // `name` field on the resource. // // This behavior should not be applied to references to other resources within // the message. // // The identifier field of resources often have different field behavior // depending on the request it is embedded in (e.g. for Create methods name // is optional and unused, while for Update methods it is required). Instead // of method-specific annotations, only `IDENTIFIER` is required. IDENTIFIER = 8; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/field_behavior_pb2.py0000644000000000000000000000517115177035223023566 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/field_behavior.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n\x1fgoogle/api/field_behavior.proto\x12\ngoogle.api\x1a google/protobuf/descriptor.proto*\xb6\x01\n\rFieldBehavior\x12\x1e\n\x1a\x46IELD_BEHAVIOR_UNSPECIFIED\x10\x00\x12\x0c\n\x08OPTIONAL\x10\x01\x12\x0c\n\x08REQUIRED\x10\x02\x12\x0f\n\x0bOUTPUT_ONLY\x10\x03\x12\x0e\n\nINPUT_ONLY\x10\x04\x12\r\n\tIMMUTABLE\x10\x05\x12\x12\n\x0eUNORDERED_LIST\x10\x06\x12\x15\n\x11NON_EMPTY_DEFAULT\x10\x07\x12\x0e\n\nIDENTIFIER\x10\x08:U\n\x0e\x66ield_behavior\x12\x1d.google.protobuf.FieldOptions\x18\x9c\x08 \x03(\x0e\x32\x19.google.api.FieldBehaviorB\x02\x10\x00\x42p\n\x0e\x63om.google.apiB\x12\x46ieldBehaviorProtoP\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xa2\x02\x04GAPIb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.field_behavior_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\022FieldBehaviorProtoP\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\242\002\004GAPI" _globals["field_behavior"]._options = None _globals["field_behavior"]._serialized_options = b"\020\000" _globals["_FIELDBEHAVIOR"]._serialized_start = 82 _globals["_FIELDBEHAVIOR"]._serialized_end = 264 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/field_behavior_pb2.pyi0000644000000000000000000000322015177035224023731 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class FieldBehavior(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () FIELD_BEHAVIOR_UNSPECIFIED: _ClassVar[FieldBehavior] OPTIONAL: _ClassVar[FieldBehavior] REQUIRED: _ClassVar[FieldBehavior] OUTPUT_ONLY: _ClassVar[FieldBehavior] INPUT_ONLY: _ClassVar[FieldBehavior] IMMUTABLE: _ClassVar[FieldBehavior] UNORDERED_LIST: _ClassVar[FieldBehavior] NON_EMPTY_DEFAULT: _ClassVar[FieldBehavior] IDENTIFIER: _ClassVar[FieldBehavior] FIELD_BEHAVIOR_UNSPECIFIED: FieldBehavior OPTIONAL: FieldBehavior REQUIRED: FieldBehavior OUTPUT_ONLY: FieldBehavior INPUT_ONLY: FieldBehavior IMMUTABLE: FieldBehavior UNORDERED_LIST: FieldBehavior NON_EMPTY_DEFAULT: FieldBehavior IDENTIFIER: FieldBehavior FIELD_BEHAVIOR_FIELD_NUMBER: _ClassVar[int] field_behavior: _descriptor.FieldDescriptor ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/field_info.proto0000644000000000000000000001055015177035226022672 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "FieldInfoProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.FieldOptions { // Rich semantic descriptor of an API field beyond the basic typing. // // Examples: // // string request_id = 1 [(google.api.field_info).format = UUID4]; // string old_ip_address = 2 [(google.api.field_info).format = IPV4]; // string new_ip_address = 3 [(google.api.field_info).format = IPV6]; // string actual_ip_address = 4 [ // (google.api.field_info).format = IPV4_OR_IPV6 // ]; // google.protobuf.Any generic_field = 5 [ // (google.api.field_info).referenced_types = {type_name: "ActualType"}, // (google.api.field_info).referenced_types = {type_name: "OtherType"}, // ]; // google.protobuf.Any generic_user_input = 5 [ // (google.api.field_info).referenced_types = {type_name: "*"}, // ]; google.api.FieldInfo field_info = 291403980; } // Rich semantic information of an API field beyond basic typing. message FieldInfo { // The standard format of a field value. The supported formats are all backed // by either an RFC defined by the IETF or a Google-defined AIP. enum Format { // Default, unspecified value. FORMAT_UNSPECIFIED = 0; // Universally Unique Identifier, version 4, value as defined by // https://datatracker.ietf.org/doc/html/rfc4122. The value may be // normalized to entirely lowercase letters. For example, the value // `F47AC10B-58CC-0372-8567-0E02B2C3D479` would be normalized to // `f47ac10b-58cc-0372-8567-0e02b2c3d479`. UUID4 = 1; // Internet Protocol v4 value as defined by [RFC // 791](https://datatracker.ietf.org/doc/html/rfc791). The value may be // condensed, with leading zeros in each octet stripped. For example, // `001.022.233.040` would be condensed to `1.22.233.40`. IPV4 = 2; // Internet Protocol v6 value as defined by [RFC // 2460](https://datatracker.ietf.org/doc/html/rfc2460). The value may be // normalized to entirely lowercase letters with zeros compressed, following // [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952). For example, // the value `2001:0DB8:0::0` would be normalized to `2001:db8::`. IPV6 = 3; // An IP address in either v4 or v6 format as described by the individual // values defined herein. See the comments on the IPV4 and IPV6 types for // allowed normalizations of each. IPV4_OR_IPV6 = 4; } // The standard format of a field value. This does not explicitly configure // any API consumer, just documents the API's format for the field it is // applied to. Format format = 1; // The type(s) that the annotated, generic field may represent. // // Currently, this must only be used on fields of type `google.protobuf.Any`. // Supporting other generic types may be considered in the future. repeated TypeReference referenced_types = 2; } // A reference to a message type, for use in [FieldInfo][google.api.FieldInfo]. message TypeReference { // The name of the type that the annotated, generic field may represent. // If the type is in the same protobuf package, the value can be the simple // message name e.g., `"MyMessage"`. Otherwise, the value must be the // fully-qualified message name e.g., `"google.library.v1.Book"`. // // If the type(s) are unknown to the service (e.g. the field accepts generic // user input), use the wildcard `"*"` to denote this behavior. // // See [AIP-202](https://google.aip.dev/202#type-references) for more details. string type_name = 1; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/field_info_pb2.py0000644000000000000000000000540215177035227022723 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/field_info.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1bgoogle/api/field_info.proto\x12\ngoogle.api\x1a google/protobuf/descriptor.proto"\xc1\x01\n\tFieldInfo\x12,\n\x06\x66ormat\x18\x01 \x01(\x0e\x32\x1c.google.api.FieldInfo.Format\x12\x33\n\x10referenced_types\x18\x02 \x03(\x0b\x32\x19.google.api.TypeReference"Q\n\x06\x46ormat\x12\x16\n\x12\x46ORMAT_UNSPECIFIED\x10\x00\x12\t\n\x05UUID4\x10\x01\x12\x08\n\x04IPV4\x10\x02\x12\x08\n\x04IPV6\x10\x03\x12\x10\n\x0cIPV4_OR_IPV6\x10\x04""\n\rTypeReference\x12\x11\n\ttype_name\x18\x01 \x01(\t:L\n\nfield_info\x12\x1d.google.protobuf.FieldOptions\x18\xcc\xf1\xf9\x8a\x01 \x01(\x0b\x32\x15.google.api.FieldInfoBl\n\x0e\x63om.google.apiB\x0e\x46ieldInfoProtoP\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.field_info_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\016FieldInfoProtoP\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\242\002\004GAPI" _globals["_FIELDINFO"]._serialized_start = 78 _globals["_FIELDINFO"]._serialized_end = 271 _globals["_FIELDINFO_FORMAT"]._serialized_start = 190 _globals["_FIELDINFO_FORMAT"]._serialized_end = 271 _globals["_TYPEREFERENCE"]._serialized_start = 273 _globals["_TYPEREFERENCE"]._serialized_end = 307 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/field_info_pb2.pyi0000644000000000000000000000450015177035226023071 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor FIELD_INFO_FIELD_NUMBER: _ClassVar[int] field_info: _descriptor.FieldDescriptor class FieldInfo(_message.Message): __slots__ = ("format", "referenced_types") class Format(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () FORMAT_UNSPECIFIED: _ClassVar[FieldInfo.Format] UUID4: _ClassVar[FieldInfo.Format] IPV4: _ClassVar[FieldInfo.Format] IPV6: _ClassVar[FieldInfo.Format] IPV4_OR_IPV6: _ClassVar[FieldInfo.Format] FORMAT_UNSPECIFIED: FieldInfo.Format UUID4: FieldInfo.Format IPV4: FieldInfo.Format IPV6: FieldInfo.Format IPV4_OR_IPV6: FieldInfo.Format FORMAT_FIELD_NUMBER: _ClassVar[int] REFERENCED_TYPES_FIELD_NUMBER: _ClassVar[int] format: FieldInfo.Format referenced_types: _containers.RepeatedCompositeFieldContainer[TypeReference] def __init__( self, format: _Optional[_Union[FieldInfo.Format, str]] = ..., referenced_types: _Optional[_Iterable[_Union[TypeReference, _Mapping]]] = ..., ) -> None: ... class TypeReference(_message.Message): __slots__ = ("type_name",) TYPE_NAME_FIELD_NUMBER: _ClassVar[int] type_name: str def __init__(self, type_name: _Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/http.proto0000644000000000000000000003532315177035224021556 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "HttpProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Defines the HTTP configuration for an API service. It contains a list of // [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method // to one or more HTTP REST API methods. message Http { // A list of HTTP configuration rules that apply to individual API methods. // // **NOTE:** All service configuration rules follow "last one wins" order. repeated HttpRule rules = 1; // When set to true, URL path parameters will be fully URI-decoded except in // cases of single segment matches in reserved expansion, where "%2F" will be // left encoded. // // The default behavior is to not decode RFC 6570 reserved characters in multi // segment matches. bool fully_decode_reserved_expansion = 2; } // gRPC Transcoding // // gRPC Transcoding is a feature for mapping between a gRPC method and one or // more HTTP REST endpoints. It allows developers to build a single API service // that supports both gRPC APIs and REST APIs. Many systems, including [Google // APIs](https://github.com/googleapis/googleapis), // [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC // Gateway](https://github.com/grpc-ecosystem/grpc-gateway), // and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature // and use it for large scale production services. // // `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies // how different portions of the gRPC request message are mapped to the URL // path, URL query parameters, and HTTP request body. It also controls how the // gRPC response message is mapped to the HTTP response body. `HttpRule` is // typically specified as an `google.api.http` annotation on the gRPC method. // // Each mapping specifies a URL path template and an HTTP method. The path // template may refer to one or more fields in the gRPC request message, as long // as each field is a non-repeated field with a primitive (non-message) type. // The path template controls how fields of the request message are mapped to // the URL path. // // Example: // // service Messaging { // rpc GetMessage(GetMessageRequest) returns (Message) { // option (google.api.http) = { // get: "/v1/{name=messages/*}" // }; // } // } // message GetMessageRequest { // string name = 1; // Mapped to URL path. // } // message Message { // string text = 1; // The resource content. // } // // This enables an HTTP REST to gRPC mapping as below: // // - HTTP: `GET /v1/messages/123456` // - gRPC: `GetMessage(name: "messages/123456")` // // Any fields in the request message which are not bound by the path template // automatically become HTTP query parameters if there is no HTTP request body. // For example: // // service Messaging { // rpc GetMessage(GetMessageRequest) returns (Message) { // option (google.api.http) = { // get:"/v1/messages/{message_id}" // }; // } // } // message GetMessageRequest { // message SubMessage { // string subfield = 1; // } // string message_id = 1; // Mapped to URL path. // int64 revision = 2; // Mapped to URL query parameter `revision`. // SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`. // } // // This enables a HTTP JSON to RPC mapping as below: // // - HTTP: `GET /v1/messages/123456?revision=2&sub.subfield=foo` // - gRPC: `GetMessage(message_id: "123456" revision: 2 sub: // SubMessage(subfield: "foo"))` // // Note that fields which are mapped to URL query parameters must have a // primitive type or a repeated primitive type or a non-repeated message type. // In the case of a repeated type, the parameter can be repeated in the URL // as `...?param=A¶m=B`. In the case of a message type, each field of the // message is mapped to a separate parameter, such as // `...?foo.a=A&foo.b=B&foo.c=C`. // // For HTTP methods that allow a request body, the `body` field // specifies the mapping. Consider a REST update method on the // message resource collection: // // service Messaging { // rpc UpdateMessage(UpdateMessageRequest) returns (Message) { // option (google.api.http) = { // patch: "/v1/messages/{message_id}" // body: "message" // }; // } // } // message UpdateMessageRequest { // string message_id = 1; // mapped to the URL // Message message = 2; // mapped to the body // } // // The following HTTP JSON to RPC mapping is enabled, where the // representation of the JSON in the request body is determined by // protos JSON encoding: // // - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }` // - gRPC: `UpdateMessage(message_id: "123456" message { text: "Hi!" })` // // The special name `*` can be used in the body mapping to define that // every field not bound by the path template should be mapped to the // request body. This enables the following alternative definition of // the update method: // // service Messaging { // rpc UpdateMessage(Message) returns (Message) { // option (google.api.http) = { // patch: "/v1/messages/{message_id}" // body: "*" // }; // } // } // message Message { // string message_id = 1; // string text = 2; // } // // // The following HTTP JSON to RPC mapping is enabled: // // - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }` // - gRPC: `UpdateMessage(message_id: "123456" text: "Hi!")` // // Note that when using `*` in the body mapping, it is not possible to // have HTTP parameters, as all fields not bound by the path end in // the body. This makes this option more rarely used in practice when // defining REST APIs. The common usage of `*` is in custom methods // which don't use the URL at all for transferring data. // // It is possible to define multiple HTTP methods for one RPC by using // the `additional_bindings` option. Example: // // service Messaging { // rpc GetMessage(GetMessageRequest) returns (Message) { // option (google.api.http) = { // get: "/v1/messages/{message_id}" // additional_bindings { // get: "/v1/users/{user_id}/messages/{message_id}" // } // }; // } // } // message GetMessageRequest { // string message_id = 1; // string user_id = 2; // } // // This enables the following two alternative HTTP JSON to RPC mappings: // // - HTTP: `GET /v1/messages/123456` // - gRPC: `GetMessage(message_id: "123456")` // // - HTTP: `GET /v1/users/me/messages/123456` // - gRPC: `GetMessage(user_id: "me" message_id: "123456")` // // Rules for HTTP mapping // // 1. Leaf request fields (recursive expansion nested messages in the request // message) are classified into three categories: // - Fields referred by the path template. They are passed via the URL path. // - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They // are passed via the HTTP // request body. // - All other fields are passed via the URL query parameters, and the // parameter name is the field path in the request message. A repeated // field can be represented as multiple query parameters under the same // name. // 2. If [HttpRule.body][google.api.HttpRule.body] is "*", there is no URL // query parameter, all fields // are passed via URL path and HTTP request body. // 3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP // request body, all // fields are passed via URL path and URL query parameters. // // Path template syntax // // Template = "/" Segments [ Verb ] ; // Segments = Segment { "/" Segment } ; // Segment = "*" | "**" | LITERAL | Variable ; // Variable = "{" FieldPath [ "=" Segments ] "}" ; // FieldPath = IDENT { "." IDENT } ; // Verb = ":" LITERAL ; // // The syntax `*` matches a single URL path segment. The syntax `**` matches // zero or more URL path segments, which must be the last part of the URL path // except the `Verb`. // // The syntax `Variable` matches part of the URL path as specified by its // template. A variable template must not contain other variables. If a variable // matches a single path segment, its template may be omitted, e.g. `{var}` // is equivalent to `{var=*}`. // // The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL` // contains any reserved character, such characters should be percent-encoded // before the matching. // // If a variable contains exactly one path segment, such as `"{var}"` or // `"{var=*}"`, when such a variable is expanded into a URL path on the client // side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The // server side does the reverse decoding. Such variables show up in the // [Discovery // Document](https://developers.google.com/discovery/v1/reference/apis) as // `{var}`. // // If a variable contains multiple path segments, such as `"{var=foo/*}"` // or `"{var=**}"`, when such a variable is expanded into a URL path on the // client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. // The server side does the reverse decoding, except "%2F" and "%2f" are left // unchanged. Such variables show up in the // [Discovery // Document](https://developers.google.com/discovery/v1/reference/apis) as // `{+var}`. // // Using gRPC API Service Configuration // // gRPC API Service Configuration (service config) is a configuration language // for configuring a gRPC service to become a user-facing product. The // service config is simply the YAML representation of the `google.api.Service` // proto message. // // As an alternative to annotating your proto file, you can configure gRPC // transcoding in your service config YAML files. You do this by specifying a // `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same // effect as the proto annotation. This can be particularly useful if you // have a proto that is reused in multiple services. Note that any transcoding // specified in the service config will override any matching transcoding // configuration in the proto. // // The following example selects a gRPC method and applies an `HttpRule` to it: // // http: // rules: // - selector: example.v1.Messaging.GetMessage // get: /v1/messages/{message_id}/{sub.subfield} // // Special notes // // When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the // proto to JSON conversion must follow the [proto3 // specification](https://developers.google.com/protocol-buffers/docs/proto3#json). // // While the single segment variable follows the semantics of // [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String // Expansion, the multi segment variable **does not** follow RFC 6570 Section // 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion // does not expand special characters like `?` and `#`, which would lead // to invalid URLs. As the result, gRPC Transcoding uses a custom encoding // for multi segment variables. // // The path variables **must not** refer to any repeated or mapped field, // because client libraries are not capable of handling such variable expansion. // // The path variables **must not** capture the leading "/" character. The reason // is that the most common use case "{var}" does not capture the leading "/" // character. For consistency, all path variables must share the same behavior. // // Repeated message fields must not be mapped to URL query parameters, because // no client library can support such complicated mapping. // // If an API needs to use a JSON array for request or response body, it can map // the request or response body to a repeated field. However, some gRPC // Transcoding implementations may not support this feature. message HttpRule { // Selects a method to which this rule applies. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. string selector = 1; // Determines the URL pattern is matched by this rules. This pattern can be // used with any of the {get|put|post|delete|patch} methods. A custom method // can be defined using the 'custom' field. oneof pattern { // Maps to HTTP GET. Used for listing and getting information about // resources. string get = 2; // Maps to HTTP PUT. Used for replacing a resource. string put = 3; // Maps to HTTP POST. Used for creating a resource or performing an action. string post = 4; // Maps to HTTP DELETE. Used for deleting a resource. string delete = 5; // Maps to HTTP PATCH. Used for updating a resource. string patch = 6; // The custom pattern is used for specifying an HTTP method that is not // included in the `pattern` field, such as HEAD, or "*" to leave the // HTTP method unspecified for this rule. The wild-card rule is useful // for services that provide content to Web (HTML) clients. CustomHttpPattern custom = 8; } // The name of the request field whose value is mapped to the HTTP request // body, or `*` for mapping all request fields not captured by the path // pattern to the HTTP body, or omitted for not having any HTTP request body. // // NOTE: the referred field must be present at the top-level of the request // message type. string body = 7; // Optional. The name of the response field whose value is mapped to the HTTP // response body. When omitted, the entire response message will be used // as the HTTP response body. // // NOTE: The referred field must be present at the top-level of the response // message type. string response_body = 12; // Additional HTTP bindings for the selector. Nested bindings must // not contain an `additional_bindings` field themselves (that is, // the nesting may only be one level deep). repeated HttpRule additional_bindings = 11; } // A custom pattern is used for defining custom HTTP verb. message CustomHttpPattern { // The name of this custom HTTP verb. string kind = 1; // The path matched by this custom verb. string path = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/http_pb2.py0000644000000000000000000000546615177035221021610 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/http.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x15google/api/http.proto\x12\ngoogle.api"T\n\x04Http\x12#\n\x05rules\x18\x01 \x03(\x0b\x32\x14.google.api.HttpRule\x12\'\n\x1f\x66ully_decode_reserved_expansion\x18\x02 \x01(\x08"\x81\x02\n\x08HttpRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12\r\n\x03get\x18\x02 \x01(\tH\x00\x12\r\n\x03put\x18\x03 \x01(\tH\x00\x12\x0e\n\x04post\x18\x04 \x01(\tH\x00\x12\x10\n\x06\x64\x65lete\x18\x05 \x01(\tH\x00\x12\x0f\n\x05patch\x18\x06 \x01(\tH\x00\x12/\n\x06\x63ustom\x18\x08 \x01(\x0b\x32\x1d.google.api.CustomHttpPatternH\x00\x12\x0c\n\x04\x62ody\x18\x07 \x01(\t\x12\x15\n\rresponse_body\x18\x0c \x01(\t\x12\x31\n\x13\x61\x64\x64itional_bindings\x18\x0b \x03(\x0b\x32\x14.google.api.HttpRuleB\t\n\x07pattern"/\n\x11\x43ustomHttpPattern\x12\x0c\n\x04kind\x18\x01 \x01(\t\x12\x0c\n\x04path\x18\x02 \x01(\tBg\n\x0e\x63om.google.apiB\tHttpProtoP\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.http_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\tHttpProtoP\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\242\002\004GAPI" _globals["_HTTP"]._serialized_start = 37 _globals["_HTTP"]._serialized_end = 121 _globals["_HTTPRULE"]._serialized_start = 124 _globals["_HTTPRULE"]._serialized_end = 381 _globals["_CUSTOMHTTPPATTERN"]._serialized_start = 383 _globals["_CUSTOMHTTPPATTERN"]._serialized_end = 430 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/http_pb2.pyi0000644000000000000000000000611315177035225021753 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Http(_message.Message): __slots__ = ("rules", "fully_decode_reserved_expansion") RULES_FIELD_NUMBER: _ClassVar[int] FULLY_DECODE_RESERVED_EXPANSION_FIELD_NUMBER: _ClassVar[int] rules: _containers.RepeatedCompositeFieldContainer[HttpRule] fully_decode_reserved_expansion: bool def __init__( self, rules: _Optional[_Iterable[_Union[HttpRule, _Mapping]]] = ..., fully_decode_reserved_expansion: bool = ..., ) -> None: ... class HttpRule(_message.Message): __slots__ = ( "selector", "get", "put", "post", "delete", "patch", "custom", "body", "response_body", "additional_bindings", ) SELECTOR_FIELD_NUMBER: _ClassVar[int] GET_FIELD_NUMBER: _ClassVar[int] PUT_FIELD_NUMBER: _ClassVar[int] POST_FIELD_NUMBER: _ClassVar[int] DELETE_FIELD_NUMBER: _ClassVar[int] PATCH_FIELD_NUMBER: _ClassVar[int] CUSTOM_FIELD_NUMBER: _ClassVar[int] BODY_FIELD_NUMBER: _ClassVar[int] RESPONSE_BODY_FIELD_NUMBER: _ClassVar[int] ADDITIONAL_BINDINGS_FIELD_NUMBER: _ClassVar[int] selector: str get: str put: str post: str delete: str patch: str custom: CustomHttpPattern body: str response_body: str additional_bindings: _containers.RepeatedCompositeFieldContainer[HttpRule] def __init__( self, selector: _Optional[str] = ..., get: _Optional[str] = ..., put: _Optional[str] = ..., post: _Optional[str] = ..., delete: _Optional[str] = ..., patch: _Optional[str] = ..., custom: _Optional[_Union[CustomHttpPattern, _Mapping]] = ..., body: _Optional[str] = ..., response_body: _Optional[str] = ..., additional_bindings: _Optional[_Iterable[_Union[HttpRule, _Mapping]]] = ..., ) -> None: ... class CustomHttpPattern(_message.Message): __slots__ = ("kind", "path") KIND_FIELD_NUMBER: _ClassVar[int] PATH_FIELD_NUMBER: _ClassVar[int] kind: str path: str def __init__( self, kind: _Optional[str] = ..., path: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/httpbody.proto0000644000000000000000000000514515177035227022436 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/any.proto"; option go_package = "google.golang.org/genproto/googleapis/api/httpbody;httpbody"; option java_multiple_files = true; option java_outer_classname = "HttpBodyProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Message that represents an arbitrary HTTP body. It should only be used for // payload formats that can't be represented as JSON, such as raw binary or // an HTML page. // // // This message can be used both in streaming and non-streaming API methods in // the request as well as the response. // // It can be used as a top-level request field, which is convenient if one // wants to extract parameters from either the URL or HTTP template into the // request fields and also want access to the raw HTTP body. // // Example: // // message GetResourceRequest { // // A unique request id. // string request_id = 1; // // // The raw HTTP body is bound to this field. // google.api.HttpBody http_body = 2; // // } // // service ResourceService { // rpc GetResource(GetResourceRequest) // returns (google.api.HttpBody); // rpc UpdateResource(google.api.HttpBody) // returns (google.protobuf.Empty); // // } // // Example with streaming methods: // // service CaldavService { // rpc GetCalendar(stream google.api.HttpBody) // returns (stream google.api.HttpBody); // rpc UpdateCalendar(stream google.api.HttpBody) // returns (stream google.api.HttpBody); // // } // // Use of this type only changes how the request and response bodies are // handled, all other features will continue to work unchanged. message HttpBody { // The HTTP Content-Type header value specifying the content type of the body. string content_type = 1; // The HTTP request/response body as raw binary. bytes data = 2; // Application specific response metadata. Must be set in the first response // for streaming APIs. repeated google.protobuf.Any extensions = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/httpbody_pb2.py0000644000000000000000000000421715177035223022461 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/httpbody.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x19google/api/httpbody.proto\x12\ngoogle.api\x1a\x19google/protobuf/any.proto"X\n\x08HttpBody\x12\x14\n\x0c\x63ontent_type\x18\x01 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x02 \x01(\x0c\x12(\n\nextensions\x18\x03 \x03(\x0b\x32\x14.google.protobuf.AnyBe\n\x0e\x63om.google.apiB\rHttpBodyProtoP\x01Z;google.golang.org/genproto/googleapis/api/httpbody;httpbody\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.httpbody_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\rHttpBodyProtoP\001Z;google.golang.org/genproto/googleapis/api/httpbody;httpbody\242\002\004GAPI" _globals["_HTTPBODY"]._serialized_start = 68 _globals["_HTTPBODY"]._serialized_end = 156 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/httpbody_pb2.pyi0000644000000000000000000000304115177035226022627 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import any_pb2 as _any_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class HttpBody(_message.Message): __slots__ = ("content_type", "data", "extensions") CONTENT_TYPE_FIELD_NUMBER: _ClassVar[int] DATA_FIELD_NUMBER: _ClassVar[int] EXTENSIONS_FIELD_NUMBER: _ClassVar[int] content_type: str data: bytes extensions: _containers.RepeatedCompositeFieldContainer[_any_pb2.Any] def __init__( self, content_type: _Optional[str] = ..., data: _Optional[bytes] = ..., extensions: _Optional[_Iterable[_Union[_any_pb2.Any, _Mapping]]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/label.proto0000644000000000000000000000251515177035223021652 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/label;label"; option java_multiple_files = true; option java_outer_classname = "LabelProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // A description of a label. message LabelDescriptor { // Value types that can be used as label values. enum ValueType { // A variable-length string. This is the default. STRING = 0; // Boolean; true or false. BOOL = 1; // A 64-bit signed integer. INT64 = 2; } // The label key. string key = 1; // The type of data that can be assigned to the label. ValueType value_type = 2; // A human-readable description for the label. string description = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/label_pb2.py0000644000000000000000000000442715177035223021706 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/label.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x16google/api/label.proto\x12\ngoogle.api"\x9c\x01\n\x0fLabelDescriptor\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x39\n\nvalue_type\x18\x02 \x01(\x0e\x32%.google.api.LabelDescriptor.ValueType\x12\x13\n\x0b\x64\x65scription\x18\x03 \x01(\t",\n\tValueType\x12\n\n\x06STRING\x10\x00\x12\x08\n\x04\x42OOL\x10\x01\x12\t\n\x05INT64\x10\x02\x42\\\n\x0e\x63om.google.apiB\nLabelProtoP\x01Z5google.golang.org/genproto/googleapis/api/label;label\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.label_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\nLabelProtoP\001Z5google.golang.org/genproto/googleapis/api/label;label\242\002\004GAPI" _globals["_LABELDESCRIPTOR"]._serialized_start = 39 _globals["_LABELDESCRIPTOR"]._serialized_end = 195 _globals["_LABELDESCRIPTOR_VALUETYPE"]._serialized_start = 151 _globals["_LABELDESCRIPTOR_VALUETYPE"]._serialized_end = 195 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/label_pb2.pyi0000644000000000000000000000336215177035222022053 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class LabelDescriptor(_message.Message): __slots__ = ("key", "value_type", "description") class ValueType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () STRING: _ClassVar[LabelDescriptor.ValueType] BOOL: _ClassVar[LabelDescriptor.ValueType] INT64: _ClassVar[LabelDescriptor.ValueType] STRING: LabelDescriptor.ValueType BOOL: LabelDescriptor.ValueType INT64: LabelDescriptor.ValueType KEY_FIELD_NUMBER: _ClassVar[int] VALUE_TYPE_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] key: str value_type: LabelDescriptor.ValueType description: str def __init__( self, key: _Optional[str] = ..., value_type: _Optional[_Union[LabelDescriptor.ValueType, str]] = ..., description: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/launch_stage.proto0000644000000000000000000000601315177035222023224 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api;api"; option java_multiple_files = true; option java_outer_classname = "LaunchStageProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // The launch stage as defined by [Google Cloud Platform // Launch Stages](https://cloud.google.com/terms/launch-stages). enum LaunchStage { // Do not use this default value. LAUNCH_STAGE_UNSPECIFIED = 0; // The feature is not yet implemented. Users can not use it. UNIMPLEMENTED = 6; // Prelaunch features are hidden from users and are only visible internally. PRELAUNCH = 7; // Early Access features are limited to a closed group of testers. To use // these features, you must sign up in advance and sign a Trusted Tester // agreement (which includes confidentiality provisions). These features may // be unstable, changed in backward-incompatible ways, and are not // guaranteed to be released. EARLY_ACCESS = 1; // Alpha is a limited availability test for releases before they are cleared // for widespread use. By Alpha, all significant design issues are resolved // and we are in the process of verifying functionality. Alpha customers // need to apply for access, agree to applicable terms, and have their // projects allowlisted. Alpha releases don't have to be feature complete, // no SLAs are provided, and there are no technical support obligations, but // they will be far enough along that customers can actually use them in // test environments or for limited-use tests -- just like they would in // normal production cases. ALPHA = 2; // Beta is the point at which we are ready to open a release for any // customer to use. There are no SLA or technical support obligations in a // Beta release. Products will be complete from a feature perspective, but // may have some open outstanding issues. Beta releases are suitable for // limited production use cases. BETA = 3; // GA features are open to all developers and are considered stable and // fully qualified for production use. GA = 4; // Deprecated features are scheduled to be shut down and removed. For more // information, see the "Deprecation Policy" section of our [Terms of // Service](https://cloud.google.com/terms/) // and the [Google Cloud Platform Subject to the Deprecation // Policy](https://cloud.google.com/terms/deprecation) documentation. DEPRECATED = 5; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/launch_stage_pb2.py0000644000000000000000000000424415177035227023265 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/launch_stage.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n\x1dgoogle/api/launch_stage.proto\x12\ngoogle.api*\x8c\x01\n\x0bLaunchStage\x12\x1c\n\x18LAUNCH_STAGE_UNSPECIFIED\x10\x00\x12\x11\n\rUNIMPLEMENTED\x10\x06\x12\r\n\tPRELAUNCH\x10\x07\x12\x10\n\x0c\x45\x41RLY_ACCESS\x10\x01\x12\t\n\x05\x41LPHA\x10\x02\x12\x08\n\x04\x42\x45TA\x10\x03\x12\x06\n\x02GA\x10\x04\x12\x0e\n\nDEPRECATED\x10\x05\x42Z\n\x0e\x63om.google.apiB\x10LaunchStageProtoP\x01Z-google.golang.org/genproto/googleapis/api;api\xa2\x02\x04GAPIb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.launch_stage_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\020LaunchStageProtoP\001Z-google.golang.org/genproto/googleapis/api;api\242\002\004GAPI" _globals["_LAUNCHSTAGE"]._serialized_start = 46 _globals["_LAUNCHSTAGE"]._serialized_end = 186 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/launch_stage_pb2.pyi0000644000000000000000000000254515177035226023437 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class LaunchStage(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () LAUNCH_STAGE_UNSPECIFIED: _ClassVar[LaunchStage] UNIMPLEMENTED: _ClassVar[LaunchStage] PRELAUNCH: _ClassVar[LaunchStage] EARLY_ACCESS: _ClassVar[LaunchStage] ALPHA: _ClassVar[LaunchStage] BETA: _ClassVar[LaunchStage] GA: _ClassVar[LaunchStage] DEPRECATED: _ClassVar[LaunchStage] LAUNCH_STAGE_UNSPECIFIED: LaunchStage UNIMPLEMENTED: LaunchStage PRELAUNCH: LaunchStage EARLY_ACCESS: LaunchStage ALPHA: LaunchStage BETA: LaunchStage GA: LaunchStage DEPRECATED: LaunchStage ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/log.proto0000644000000000000000000000377315177035222021362 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/api/label.proto"; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "LogProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // A description of a log type. Example in YAML format: // // - name: library.googleapis.com/activity_history // description: The history of borrowing and returning library items. // display_name: Activity // labels: // - key: /customer_id // description: Identifier of a library customer message LogDescriptor { // The name of the log. It must be less than 512 characters long and can // include the following characters: upper- and lower-case alphanumeric // characters [A-Za-z0-9], and punctuation characters including // slash, underscore, hyphen, period [/_-.]. string name = 1; // The set of labels that are available to describe a specific log entry. // Runtime requests that contain labels not specified here are // considered invalid. repeated LabelDescriptor labels = 2; // A human-readable description of this log. This information appears in // the documentation and can contain details. string description = 3; // The human-readable name for this log. This information appears on // the user interface and should be concise. string display_name = 4; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/log_pb2.py0000644000000000000000000000427615177035227021416 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/log.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.api import label_pb2 as google_dot_api_dot_label__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x14google/api/log.proto\x12\ngoogle.api\x1a\x16google/api/label.proto"u\n\rLogDescriptor\x12\x0c\n\x04name\x18\x01 \x01(\t\x12+\n\x06labels\x18\x02 \x03(\x0b\x32\x1b.google.api.LabelDescriptor\x12\x13\n\x0b\x64\x65scription\x18\x03 \x01(\t\x12\x14\n\x0c\x64isplay_name\x18\x04 \x01(\tBj\n\x0e\x63om.google.apiB\x08LogProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.log_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\010LogProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_LOGDESCRIPTOR"]._serialized_start = 60 _globals["_LOGDESCRIPTOR"]._serialized_end = 177 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/log_pb2.pyi0000644000000000000000000000330015177035227021552 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.api import label_pb2 as _label_pb2 DESCRIPTOR: _descriptor.FileDescriptor class LogDescriptor(_message.Message): __slots__ = ("name", "labels", "description", "display_name") NAME_FIELD_NUMBER: _ClassVar[int] LABELS_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] DISPLAY_NAME_FIELD_NUMBER: _ClassVar[int] name: str labels: _containers.RepeatedCompositeFieldContainer[_label_pb2.LabelDescriptor] description: str display_name: str def __init__( self, name: _Optional[str] = ..., labels: _Optional[ _Iterable[_Union[_label_pb2.LabelDescriptor, _Mapping]] ] = ..., description: _Optional[str] = ..., display_name: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/logging.proto0000644000000000000000000000614615177035225022227 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "LoggingProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Logging configuration of the service. // // The following example shows how to configure logs to be sent to the // producer and consumer projects. In the example, the `activity_history` // log is sent to both the producer and consumer projects, whereas the // `purchase_history` log is only sent to the producer project. // // monitored_resources: // - type: library.googleapis.com/branch // labels: // - key: /city // description: The city where the library branch is located in. // - key: /name // description: The name of the branch. // logs: // - name: activity_history // labels: // - key: /customer_id // - name: purchase_history // logging: // producer_destinations: // - monitored_resource: library.googleapis.com/branch // logs: // - activity_history // - purchase_history // consumer_destinations: // - monitored_resource: library.googleapis.com/branch // logs: // - activity_history message Logging { // Configuration of a specific logging destination (the producer project // or the consumer project). message LoggingDestination { // The monitored resource type. The type must be defined in the // [Service.monitored_resources][google.api.Service.monitored_resources] // section. string monitored_resource = 3; // Names of the logs to be sent to this destination. Each name must // be defined in the [Service.logs][google.api.Service.logs] section. If the // log name is not a domain scoped name, it will be automatically prefixed // with the service name followed by "/". repeated string logs = 1; } // Logging configurations for sending logs to the producer project. // There can be multiple producer destinations, each one must have a // different monitored resource type. A log can be used in at most // one producer destination. repeated LoggingDestination producer_destinations = 1; // Logging configurations for sending logs to the consumer project. // There can be multiple consumer destinations, each one must have a // different monitored resource type. A log can be used in at most // one consumer destination. repeated LoggingDestination consumer_destinations = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/logging_pb2.py0000644000000000000000000000453415177035227022260 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/logging.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x18google/api/logging.proto\x12\ngoogle.api"\xd7\x01\n\x07Logging\x12\x45\n\x15producer_destinations\x18\x01 \x03(\x0b\x32&.google.api.Logging.LoggingDestination\x12\x45\n\x15\x63onsumer_destinations\x18\x02 \x03(\x0b\x32&.google.api.Logging.LoggingDestination\x1a>\n\x12LoggingDestination\x12\x1a\n\x12monitored_resource\x18\x03 \x01(\t\x12\x0c\n\x04logs\x18\x01 \x03(\tBn\n\x0e\x63om.google.apiB\x0cLoggingProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.logging_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\014LoggingProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_LOGGING"]._serialized_start = 41 _globals["_LOGGING"]._serialized_end = 256 _globals["_LOGGING_LOGGINGDESTINATION"]._serialized_start = 194 _globals["_LOGGING_LOGGINGDESTINATION"]._serialized_end = 256 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/logging_pb2.pyi0000644000000000000000000000420215177035225022417 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Logging(_message.Message): __slots__ = ("producer_destinations", "consumer_destinations") class LoggingDestination(_message.Message): __slots__ = ("monitored_resource", "logs") MONITORED_RESOURCE_FIELD_NUMBER: _ClassVar[int] LOGS_FIELD_NUMBER: _ClassVar[int] monitored_resource: str logs: _containers.RepeatedScalarFieldContainer[str] def __init__( self, monitored_resource: _Optional[str] = ..., logs: _Optional[_Iterable[str]] = ..., ) -> None: ... PRODUCER_DESTINATIONS_FIELD_NUMBER: _ClassVar[int] CONSUMER_DESTINATIONS_FIELD_NUMBER: _ClassVar[int] producer_destinations: _containers.RepeatedCompositeFieldContainer[ Logging.LoggingDestination ] consumer_destinations: _containers.RepeatedCompositeFieldContainer[ Logging.LoggingDestination ] def __init__( self, producer_destinations: _Optional[ _Iterable[_Union[Logging.LoggingDestination, _Mapping]] ] = ..., consumer_destinations: _Optional[ _Iterable[_Union[Logging.LoggingDestination, _Mapping]] ] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/metric.proto0000644000000000000000000002563615177035223022067 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/api/label.proto"; import "google/api/launch_stage.proto"; import "google/protobuf/duration.proto"; option go_package = "google.golang.org/genproto/googleapis/api/metric;metric"; option java_multiple_files = true; option java_outer_classname = "MetricProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Defines a metric type and its schema. Once a metric descriptor is created, // deleting or altering it stops data collection and makes the metric type's // existing data unusable. // message MetricDescriptor { // The kind of measurement. It describes how the data is reported. // For information on setting the start time and end time based on // the MetricKind, see [TimeInterval][google.monitoring.v3.TimeInterval]. enum MetricKind { // Do not use this default value. METRIC_KIND_UNSPECIFIED = 0; // An instantaneous measurement of a value. GAUGE = 1; // The change in a value during a time interval. DELTA = 2; // A value accumulated over a time interval. Cumulative // measurements in a time series should have the same start time // and increasing end times, until an event resets the cumulative // value to zero and sets a new start time for the following // points. CUMULATIVE = 3; } // The value type of a metric. enum ValueType { // Do not use this default value. VALUE_TYPE_UNSPECIFIED = 0; // The value is a boolean. // This value type can be used only if the metric kind is `GAUGE`. BOOL = 1; // The value is a signed 64-bit integer. INT64 = 2; // The value is a double precision floating point number. DOUBLE = 3; // The value is a text string. // This value type can be used only if the metric kind is `GAUGE`. STRING = 4; // The value is a [`Distribution`][google.api.Distribution]. DISTRIBUTION = 5; // The value is money. MONEY = 6; } // Additional annotations that can be used to guide the usage of a metric. message MetricDescriptorMetadata { // The resource hierarchy level of the timeseries data of a metric. enum TimeSeriesResourceHierarchyLevel { // Do not use this default value. TIME_SERIES_RESOURCE_HIERARCHY_LEVEL_UNSPECIFIED = 0; // Scopes a metric to a project. PROJECT = 1; // Scopes a metric to an organization. ORGANIZATION = 2; // Scopes a metric to a folder. FOLDER = 3; } // Deprecated. Must use the // [MetricDescriptor.launch_stage][google.api.MetricDescriptor.launch_stage] // instead. LaunchStage launch_stage = 1 [deprecated = true]; // The sampling period of metric data points. For metrics which are written // periodically, consecutive data points are stored at this time interval, // excluding data loss due to errors. Metrics with a higher granularity have // a smaller sampling period. google.protobuf.Duration sample_period = 2; // The delay of data points caused by ingestion. Data points older than this // age are guaranteed to be ingested and available to be read, excluding // data loss due to errors. google.protobuf.Duration ingest_delay = 3; // The scope of the timeseries data of the metric. repeated TimeSeriesResourceHierarchyLevel time_series_resource_hierarchy_level = 4; } // The resource name of the metric descriptor. string name = 1; // The metric type, including its DNS name prefix. The type is not // URL-encoded. All user-defined metric types have the DNS name // `custom.googleapis.com` or `external.googleapis.com`. Metric types should // use a natural hierarchical grouping. For example: // // "custom.googleapis.com/invoice/paid/amount" // "external.googleapis.com/prometheus/up" // "appengine.googleapis.com/http/server/response_latencies" string type = 8; // The set of labels that can be used to describe a specific // instance of this metric type. For example, the // `appengine.googleapis.com/http/server/response_latencies` metric // type has a label for the HTTP response code, `response_code`, so // you can look at latencies for successful responses or just // for responses that failed. repeated LabelDescriptor labels = 2; // Whether the metric records instantaneous values, changes to a value, etc. // Some combinations of `metric_kind` and `value_type` might not be supported. MetricKind metric_kind = 3; // Whether the measurement is an integer, a floating-point number, etc. // Some combinations of `metric_kind` and `value_type` might not be supported. ValueType value_type = 4; // The units in which the metric value is reported. It is only applicable // if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The `unit` // defines the representation of the stored metric values. // // Different systems might scale the values to be more easily displayed (so a // value of `0.02kBy` _might_ be displayed as `20By`, and a value of // `3523kBy` _might_ be displayed as `3.5MBy`). However, if the `unit` is // `kBy`, then the value of the metric is always in thousands of bytes, no // matter how it might be displayed. // // If you want a custom metric to record the exact number of CPU-seconds used // by a job, you can create an `INT64 CUMULATIVE` metric whose `unit` is // `s{CPU}` (or equivalently `1s{CPU}` or just `s`). If the job uses 12,005 // CPU-seconds, then the value is written as `12005`. // // Alternatively, if you want a custom metric to record data in a more // granular way, you can create a `DOUBLE CUMULATIVE` metric whose `unit` is // `ks{CPU}`, and then write the value `12.005` (which is `12005/1000`), // or use `Kis{CPU}` and write `11.723` (which is `12005/1024`). // // The supported units are a subset of [The Unified Code for Units of // Measure](https://unitsofmeasure.org/ucum.html) standard: // // **Basic units (UNIT)** // // * `bit` bit // * `By` byte // * `s` second // * `min` minute // * `h` hour // * `d` day // * `1` dimensionless // // **Prefixes (PREFIX)** // // * `k` kilo (10^3) // * `M` mega (10^6) // * `G` giga (10^9) // * `T` tera (10^12) // * `P` peta (10^15) // * `E` exa (10^18) // * `Z` zetta (10^21) // * `Y` yotta (10^24) // // * `m` milli (10^-3) // * `u` micro (10^-6) // * `n` nano (10^-9) // * `p` pico (10^-12) // * `f` femto (10^-15) // * `a` atto (10^-18) // * `z` zepto (10^-21) // * `y` yocto (10^-24) // // * `Ki` kibi (2^10) // * `Mi` mebi (2^20) // * `Gi` gibi (2^30) // * `Ti` tebi (2^40) // * `Pi` pebi (2^50) // // **Grammar** // // The grammar also includes these connectors: // // * `/` division or ratio (as an infix operator). For examples, // `kBy/{email}` or `MiBy/10ms` (although you should almost never // have `/s` in a metric `unit`; rates should always be computed at // query time from the underlying cumulative or delta value). // * `.` multiplication or composition (as an infix operator). For // examples, `GBy.d` or `k{watt}.h`. // // The grammar for a unit is as follows: // // Expression = Component { "." Component } { "/" Component } ; // // Component = ( [ PREFIX ] UNIT | "%" ) [ Annotation ] // | Annotation // | "1" // ; // // Annotation = "{" NAME "}" ; // // Notes: // // * `Annotation` is just a comment if it follows a `UNIT`. If the annotation // is used alone, then the unit is equivalent to `1`. For examples, // `{request}/s == 1/s`, `By{transmitted}/s == By/s`. // * `NAME` is a sequence of non-blank printable ASCII characters not // containing `{` or `}`. // * `1` represents a unitary [dimensionless // unit](https://en.wikipedia.org/wiki/Dimensionless_quantity) of 1, such // as in `1/s`. It is typically used when none of the basic units are // appropriate. For example, "new users per day" can be represented as // `1/d` or `{new-users}/d` (and a metric value `5` would mean "5 new // users). Alternatively, "thousands of page views per day" would be // represented as `1000/d` or `k1/d` or `k{page_views}/d` (and a metric // value of `5.3` would mean "5300 page views per day"). // * `%` represents dimensionless value of 1/100, and annotates values giving // a percentage (so the metric values are typically in the range of 0..100, // and a metric value `3` means "3 percent"). // * `10^2.%` indicates a metric contains a ratio, typically in the range // 0..1, that will be multiplied by 100 and displayed as a percentage // (so a metric value `0.03` means "3 percent"). string unit = 5; // A detailed description of the metric, which can be used in documentation. string description = 6; // A concise name for the metric, which can be displayed in user interfaces. // Use sentence case without an ending period, for example "Request count". // This field is optional but it is recommended to be set for any metrics // associated with user-visible concepts, such as Quota. string display_name = 7; // Optional. Metadata which can be used to guide usage of the metric. MetricDescriptorMetadata metadata = 10; // Optional. The launch stage of the metric definition. LaunchStage launch_stage = 12; // Read-only. If present, then a [time // series][google.monitoring.v3.TimeSeries], which is identified partially by // a metric type and a // [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor], that // is associated with this metric type can only be associated with one of the // monitored resource types listed here. repeated string monitored_resource_types = 13; } // A specific metric, identified by specifying values for all of the // labels of a [`MetricDescriptor`][google.api.MetricDescriptor]. message Metric { // An existing metric type, see // [google.api.MetricDescriptor][google.api.MetricDescriptor]. For example, // `custom.googleapis.com/invoice/paid/amount`. string type = 3; // The set of label values that uniquely identify this metric. All // labels listed in the `MetricDescriptor` must be assigned values. map labels = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/metric_pb2.py0000644000000000000000000001253415177035225022112 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/metric.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 from google.api import label_pb2 as google_dot_api_dot_label__pb2 from google.api import launch_stage_pb2 as google_dot_api_dot_launch__stage__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x17google/api/metric.proto\x12\ngoogle.api\x1a\x16google/api/label.proto\x1a\x1dgoogle/api/launch_stage.proto\x1a\x1egoogle/protobuf/duration.proto"\xac\x08\n\x10MetricDescriptor\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x08 \x01(\t\x12+\n\x06labels\x18\x02 \x03(\x0b\x32\x1b.google.api.LabelDescriptor\x12<\n\x0bmetric_kind\x18\x03 \x01(\x0e\x32\'.google.api.MetricDescriptor.MetricKind\x12:\n\nvalue_type\x18\x04 \x01(\x0e\x32&.google.api.MetricDescriptor.ValueType\x12\x0c\n\x04unit\x18\x05 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x06 \x01(\t\x12\x14\n\x0c\x64isplay_name\x18\x07 \x01(\t\x12G\n\x08metadata\x18\n \x01(\x0b\x32\x35.google.api.MetricDescriptor.MetricDescriptorMetadata\x12-\n\x0claunch_stage\x18\x0c \x01(\x0e\x32\x17.google.api.LaunchStage\x12 \n\x18monitored_resource_types\x18\r \x03(\t\x1a\xbd\x03\n\x18MetricDescriptorMetadata\x12\x31\n\x0claunch_stage\x18\x01 \x01(\x0e\x32\x17.google.api.LaunchStageB\x02\x18\x01\x12\x30\n\rsample_period\x18\x02 \x01(\x0b\x32\x19.google.protobuf.Duration\x12/\n\x0cingest_delay\x18\x03 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x84\x01\n$time_series_resource_hierarchy_level\x18\x04 \x03(\x0e\x32V.google.api.MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel"\x83\x01\n TimeSeriesResourceHierarchyLevel\x12\x34\n0TIME_SERIES_RESOURCE_HIERARCHY_LEVEL_UNSPECIFIED\x10\x00\x12\x0b\n\x07PROJECT\x10\x01\x12\x10\n\x0cORGANIZATION\x10\x02\x12\n\n\x06\x46OLDER\x10\x03"O\n\nMetricKind\x12\x1b\n\x17METRIC_KIND_UNSPECIFIED\x10\x00\x12\t\n\x05GAUGE\x10\x01\x12\t\n\x05\x44\x45LTA\x10\x02\x12\x0e\n\nCUMULATIVE\x10\x03"q\n\tValueType\x12\x1a\n\x16VALUE_TYPE_UNSPECIFIED\x10\x00\x12\x08\n\x04\x42OOL\x10\x01\x12\t\n\x05INT64\x10\x02\x12\n\n\x06\x44OUBLE\x10\x03\x12\n\n\x06STRING\x10\x04\x12\x10\n\x0c\x44ISTRIBUTION\x10\x05\x12\t\n\x05MONEY\x10\x06"u\n\x06Metric\x12\x0c\n\x04type\x18\x03 \x01(\t\x12.\n\x06labels\x18\x02 \x03(\x0b\x32\x1e.google.api.Metric.LabelsEntry\x1a-\n\x0bLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42_\n\x0e\x63om.google.apiB\x0bMetricProtoP\x01Z7google.golang.org/genproto/googleapis/api/metric;metric\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.metric_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\013MetricProtoP\001Z7google.golang.org/genproto/googleapis/api/metric;metric\242\002\004GAPI" _globals["_METRICDESCRIPTOR_METRICDESCRIPTORMETADATA"].fields_by_name[ "launch_stage" ]._options = None _globals["_METRICDESCRIPTOR_METRICDESCRIPTORMETADATA"].fields_by_name[ "launch_stage" ]._serialized_options = b"\030\001" _globals["_METRIC_LABELSENTRY"]._options = None _globals["_METRIC_LABELSENTRY"]._serialized_options = b"8\001" _globals["_METRICDESCRIPTOR"]._serialized_start = 127 _globals["_METRICDESCRIPTOR"]._serialized_end = 1195 _globals["_METRICDESCRIPTOR_METRICDESCRIPTORMETADATA"]._serialized_start = 554 _globals["_METRICDESCRIPTOR_METRICDESCRIPTORMETADATA"]._serialized_end = 999 _globals[ "_METRICDESCRIPTOR_METRICDESCRIPTORMETADATA_TIMESERIESRESOURCEHIERARCHYLEVEL" ]._serialized_start = 868 _globals[ "_METRICDESCRIPTOR_METRICDESCRIPTORMETADATA_TIMESERIESRESOURCEHIERARCHYLEVEL" ]._serialized_end = 999 _globals["_METRICDESCRIPTOR_METRICKIND"]._serialized_start = 1001 _globals["_METRICDESCRIPTOR_METRICKIND"]._serialized_end = 1080 _globals["_METRICDESCRIPTOR_VALUETYPE"]._serialized_start = 1082 _globals["_METRICDESCRIPTOR_VALUETYPE"]._serialized_end = 1195 _globals["_METRIC"]._serialized_start = 1197 _globals["_METRIC"]._serialized_end = 1314 _globals["_METRIC_LABELSENTRY"]._serialized_start = 1269 _globals["_METRIC_LABELSENTRY"]._serialized_end = 1314 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/metric_pb2.pyi0000644000000000000000000001722115177035225022261 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import duration_pb2 as _duration_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper from google.api import label_pb2 as _label_pb2 from google.api import launch_stage_pb2 as _launch_stage_pb2 DESCRIPTOR: _descriptor.FileDescriptor class MetricDescriptor(_message.Message): __slots__ = ( "name", "type", "labels", "metric_kind", "value_type", "unit", "description", "display_name", "metadata", "launch_stage", "monitored_resource_types", ) class MetricKind(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () METRIC_KIND_UNSPECIFIED: _ClassVar[MetricDescriptor.MetricKind] GAUGE: _ClassVar[MetricDescriptor.MetricKind] DELTA: _ClassVar[MetricDescriptor.MetricKind] CUMULATIVE: _ClassVar[MetricDescriptor.MetricKind] METRIC_KIND_UNSPECIFIED: MetricDescriptor.MetricKind GAUGE: MetricDescriptor.MetricKind DELTA: MetricDescriptor.MetricKind CUMULATIVE: MetricDescriptor.MetricKind class ValueType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () VALUE_TYPE_UNSPECIFIED: _ClassVar[MetricDescriptor.ValueType] BOOL: _ClassVar[MetricDescriptor.ValueType] INT64: _ClassVar[MetricDescriptor.ValueType] DOUBLE: _ClassVar[MetricDescriptor.ValueType] STRING: _ClassVar[MetricDescriptor.ValueType] DISTRIBUTION: _ClassVar[MetricDescriptor.ValueType] MONEY: _ClassVar[MetricDescriptor.ValueType] VALUE_TYPE_UNSPECIFIED: MetricDescriptor.ValueType BOOL: MetricDescriptor.ValueType INT64: MetricDescriptor.ValueType DOUBLE: MetricDescriptor.ValueType STRING: MetricDescriptor.ValueType DISTRIBUTION: MetricDescriptor.ValueType MONEY: MetricDescriptor.ValueType class MetricDescriptorMetadata(_message.Message): __slots__ = ( "launch_stage", "sample_period", "ingest_delay", "time_series_resource_hierarchy_level", ) class TimeSeriesResourceHierarchyLevel( int, metaclass=_enum_type_wrapper.EnumTypeWrapper ): __slots__ = () TIME_SERIES_RESOURCE_HIERARCHY_LEVEL_UNSPECIFIED: _ClassVar[ MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ] PROJECT: _ClassVar[ MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ] ORGANIZATION: _ClassVar[ MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ] FOLDER: _ClassVar[ MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ] TIME_SERIES_RESOURCE_HIERARCHY_LEVEL_UNSPECIFIED: ( MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ) PROJECT: ( MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ) ORGANIZATION: ( MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ) FOLDER: ( MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ) LAUNCH_STAGE_FIELD_NUMBER: _ClassVar[int] SAMPLE_PERIOD_FIELD_NUMBER: _ClassVar[int] INGEST_DELAY_FIELD_NUMBER: _ClassVar[int] TIME_SERIES_RESOURCE_HIERARCHY_LEVEL_FIELD_NUMBER: _ClassVar[int] launch_stage: _launch_stage_pb2.LaunchStage sample_period: _duration_pb2.Duration ingest_delay: _duration_pb2.Duration time_series_resource_hierarchy_level: _containers.RepeatedScalarFieldContainer[ MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel ] def __init__( self, launch_stage: _Optional[_Union[_launch_stage_pb2.LaunchStage, str]] = ..., sample_period: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., ingest_delay: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., time_series_resource_hierarchy_level: _Optional[ _Iterable[ _Union[ MetricDescriptor.MetricDescriptorMetadata.TimeSeriesResourceHierarchyLevel, str, ] ] ] = ..., ) -> None: ... NAME_FIELD_NUMBER: _ClassVar[int] TYPE_FIELD_NUMBER: _ClassVar[int] LABELS_FIELD_NUMBER: _ClassVar[int] METRIC_KIND_FIELD_NUMBER: _ClassVar[int] VALUE_TYPE_FIELD_NUMBER: _ClassVar[int] UNIT_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] DISPLAY_NAME_FIELD_NUMBER: _ClassVar[int] METADATA_FIELD_NUMBER: _ClassVar[int] LAUNCH_STAGE_FIELD_NUMBER: _ClassVar[int] MONITORED_RESOURCE_TYPES_FIELD_NUMBER: _ClassVar[int] name: str type: str labels: _containers.RepeatedCompositeFieldContainer[_label_pb2.LabelDescriptor] metric_kind: MetricDescriptor.MetricKind value_type: MetricDescriptor.ValueType unit: str description: str display_name: str metadata: MetricDescriptor.MetricDescriptorMetadata launch_stage: _launch_stage_pb2.LaunchStage monitored_resource_types: _containers.RepeatedScalarFieldContainer[str] def __init__( self, name: _Optional[str] = ..., type: _Optional[str] = ..., labels: _Optional[ _Iterable[_Union[_label_pb2.LabelDescriptor, _Mapping]] ] = ..., metric_kind: _Optional[_Union[MetricDescriptor.MetricKind, str]] = ..., value_type: _Optional[_Union[MetricDescriptor.ValueType, str]] = ..., unit: _Optional[str] = ..., description: _Optional[str] = ..., display_name: _Optional[str] = ..., metadata: _Optional[ _Union[MetricDescriptor.MetricDescriptorMetadata, _Mapping] ] = ..., launch_stage: _Optional[_Union[_launch_stage_pb2.LaunchStage, str]] = ..., monitored_resource_types: _Optional[_Iterable[str]] = ..., ) -> None: ... class Metric(_message.Message): __slots__ = ("type", "labels") class LabelsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... TYPE_FIELD_NUMBER: _ClassVar[int] LABELS_FIELD_NUMBER: _ClassVar[int] type: str labels: _containers.ScalarMap[str, str] def __init__( self, type: _Optional[str] = ..., labels: _Optional[_Mapping[str, str]] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/monitored_resource.proto0000644000000000000000000001340015177035221024473 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/api/label.proto"; import "google/api/launch_stage.proto"; import "google/protobuf/struct.proto"; option go_package = "google.golang.org/genproto/googleapis/api/monitoredres;monitoredres"; option java_multiple_files = true; option java_outer_classname = "MonitoredResourceProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // An object that describes the schema of a // [MonitoredResource][google.api.MonitoredResource] object using a type name // and a set of labels. For example, the monitored resource descriptor for // Google Compute Engine VM instances has a type of // `"gce_instance"` and specifies the use of the labels `"instance_id"` and // `"zone"` to identify particular VM instances. // // Different APIs can support different monitored resource types. APIs generally // provide a `list` method that returns the monitored resource descriptors used // by the API. // message MonitoredResourceDescriptor { // Optional. The resource name of the monitored resource descriptor: // `"projects/{project_id}/monitoredResourceDescriptors/{type}"` where // {type} is the value of the `type` field in this object and // {project_id} is a project ID that provides API-specific context for // accessing the type. APIs that do not use project information can use the // resource name format `"monitoredResourceDescriptors/{type}"`. string name = 5; // Required. The monitored resource type. For example, the type // `"cloudsql_database"` represents databases in Google Cloud SQL. // For a list of types, see [Monitored resource // types](https://cloud.google.com/monitoring/api/resources) // and [Logging resource // types](https://cloud.google.com/logging/docs/api/v2/resource-list). string type = 1; // Optional. A concise name for the monitored resource type that might be // displayed in user interfaces. It should be a Title Cased Noun Phrase, // without any article or other determiners. For example, // `"Google Cloud SQL Database"`. string display_name = 2; // Optional. A detailed description of the monitored resource type that might // be used in documentation. string description = 3; // Required. A set of labels used to describe instances of this monitored // resource type. For example, an individual Google Cloud SQL database is // identified by values for the labels `"database_id"` and `"zone"`. repeated LabelDescriptor labels = 4; // Optional. The launch stage of the monitored resource definition. LaunchStage launch_stage = 7; } // An object representing a resource that can be used for monitoring, logging, // billing, or other purposes. Examples include virtual machine instances, // databases, and storage devices such as disks. The `type` field identifies a // [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor] object // that describes the resource's schema. Information in the `labels` field // identifies the actual resource and its attributes according to the schema. // For example, a particular Compute Engine VM instance could be represented by // the following object, because the // [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor] for // `"gce_instance"` has labels // `"project_id"`, `"instance_id"` and `"zone"`: // // { "type": "gce_instance", // "labels": { "project_id": "my-project", // "instance_id": "12345678901234", // "zone": "us-central1-a" }} message MonitoredResource { // Required. The monitored resource type. This field must match // the `type` field of a // [MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor] // object. For example, the type of a Compute Engine VM instance is // `gce_instance`. Some descriptors include the service name in the type; for // example, the type of a Datastream stream is // `datastream.googleapis.com/Stream`. string type = 1; // Required. Values for all of the labels listed in the associated monitored // resource descriptor. For example, Compute Engine VM instances use the // labels `"project_id"`, `"instance_id"`, and `"zone"`. map labels = 2; } // Auxiliary metadata for a [MonitoredResource][google.api.MonitoredResource] // object. [MonitoredResource][google.api.MonitoredResource] objects contain the // minimum set of information to uniquely identify a monitored resource // instance. There is some other useful auxiliary metadata. Monitoring and // Logging use an ingestion pipeline to extract metadata for cloud resources of // all types, and store the metadata in this message. message MonitoredResourceMetadata { // Output only. Values for predefined system metadata labels. // System labels are a kind of metadata extracted by Google, including // "machine_image", "vpc", "subnet_id", // "security_group", "name", etc. // System label values can be only strings, Boolean values, or a list of // strings. For example: // // { "name": "my-test-instance", // "security_group": ["a", "b", "c"], // "spot_instance": false } google.protobuf.Struct system_labels = 1; // Output only. A map of user-defined metadata labels. map user_labels = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/monitored_resource_pb2.py0000644000000000000000000001006315177035221024525 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/monitored_resource.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 from google.api import label_pb2 as google_dot_api_dot_label__pb2 from google.api import launch_stage_pb2 as google_dot_api_dot_launch__stage__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n#google/api/monitored_resource.proto\x12\ngoogle.api\x1a\x16google/api/label.proto\x1a\x1dgoogle/api/launch_stage.proto\x1a\x1cgoogle/protobuf/struct.proto"\xc0\x01\n\x1bMonitoredResourceDescriptor\x12\x0c\n\x04name\x18\x05 \x01(\t\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x14\n\x0c\x64isplay_name\x18\x02 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x03 \x01(\t\x12+\n\x06labels\x18\x04 \x03(\x0b\x32\x1b.google.api.LabelDescriptor\x12-\n\x0claunch_stage\x18\x07 \x01(\x0e\x32\x17.google.api.LaunchStage"\x8b\x01\n\x11MonitoredResource\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x39\n\x06labels\x18\x02 \x03(\x0b\x32).google.api.MonitoredResource.LabelsEntry\x1a-\n\x0bLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\xca\x01\n\x19MonitoredResourceMetadata\x12.\n\rsystem_labels\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\x12J\n\x0buser_labels\x18\x02 \x03(\x0b\x32\x35.google.api.MonitoredResourceMetadata.UserLabelsEntry\x1a\x31\n\x0fUserLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42v\n\x0e\x63om.google.apiB\x16MonitoredResourceProtoP\x01ZCgoogle.golang.org/genproto/googleapis/api/monitoredres;monitoredres\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.monitored_resource_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\026MonitoredResourceProtoP\001ZCgoogle.golang.org/genproto/googleapis/api/monitoredres;monitoredres\242\002\004GAPI" _globals["_MONITOREDRESOURCE_LABELSENTRY"]._options = None _globals["_MONITOREDRESOURCE_LABELSENTRY"]._serialized_options = b"8\001" _globals["_MONITOREDRESOURCEMETADATA_USERLABELSENTRY"]._options = None _globals[ "_MONITOREDRESOURCEMETADATA_USERLABELSENTRY" ]._serialized_options = b"8\001" _globals["_MONITOREDRESOURCEDESCRIPTOR"]._serialized_start = 137 _globals["_MONITOREDRESOURCEDESCRIPTOR"]._serialized_end = 329 _globals["_MONITOREDRESOURCE"]._serialized_start = 332 _globals["_MONITOREDRESOURCE"]._serialized_end = 471 _globals["_MONITOREDRESOURCE_LABELSENTRY"]._serialized_start = 426 _globals["_MONITOREDRESOURCE_LABELSENTRY"]._serialized_end = 471 _globals["_MONITOREDRESOURCEMETADATA"]._serialized_start = 474 _globals["_MONITOREDRESOURCEMETADATA"]._serialized_end = 676 _globals["_MONITOREDRESOURCEMETADATA_USERLABELSENTRY"]._serialized_start = 627 _globals["_MONITOREDRESOURCEMETADATA_USERLABELSENTRY"]._serialized_end = 676 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/monitored_resource_pb2.pyi0000644000000000000000000000707415177035226024713 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import struct_pb2 as _struct_pb2 from google.protobuf.internal import containers as _containers from google.api import label_pb2 as _label_pb2 from google.api import launch_stage_pb2 as _launch_stage_pb2 DESCRIPTOR: _descriptor.FileDescriptor class MonitoredResourceDescriptor(_message.Message): __slots__ = ( "name", "type", "display_name", "description", "labels", "launch_stage", ) NAME_FIELD_NUMBER: _ClassVar[int] TYPE_FIELD_NUMBER: _ClassVar[int] DISPLAY_NAME_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] LABELS_FIELD_NUMBER: _ClassVar[int] LAUNCH_STAGE_FIELD_NUMBER: _ClassVar[int] name: str type: str display_name: str description: str labels: _containers.RepeatedCompositeFieldContainer[_label_pb2.LabelDescriptor] launch_stage: _launch_stage_pb2.LaunchStage def __init__( self, name: _Optional[str] = ..., type: _Optional[str] = ..., display_name: _Optional[str] = ..., description: _Optional[str] = ..., labels: _Optional[ _Iterable[_Union[_label_pb2.LabelDescriptor, _Mapping]] ] = ..., launch_stage: _Optional[_Union[_launch_stage_pb2.LaunchStage, str]] = ..., ) -> None: ... class MonitoredResource(_message.Message): __slots__ = ("type", "labels") class LabelsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... TYPE_FIELD_NUMBER: _ClassVar[int] LABELS_FIELD_NUMBER: _ClassVar[int] type: str labels: _containers.ScalarMap[str, str] def __init__( self, type: _Optional[str] = ..., labels: _Optional[_Mapping[str, str]] = ... ) -> None: ... class MonitoredResourceMetadata(_message.Message): __slots__ = ("system_labels", "user_labels") class UserLabelsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... SYSTEM_LABELS_FIELD_NUMBER: _ClassVar[int] USER_LABELS_FIELD_NUMBER: _ClassVar[int] system_labels: _struct_pb2.Struct user_labels: _containers.ScalarMap[str, str] def __init__( self, system_labels: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., user_labels: _Optional[_Mapping[str, str]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/monitoring.proto0000644000000000000000000001055115177035226022762 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "MonitoringProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Monitoring configuration of the service. // // The example below shows how to configure monitored resources and metrics // for monitoring. In the example, a monitored resource and two metrics are // defined. The `library.googleapis.com/book/returned_count` metric is sent // to both producer and consumer projects, whereas the // `library.googleapis.com/book/num_overdue` metric is only sent to the // consumer project. // // monitored_resources: // - type: library.googleapis.com/Branch // display_name: "Library Branch" // description: "A branch of a library." // launch_stage: GA // labels: // - key: resource_container // description: "The Cloud container (ie. project id) for the Branch." // - key: location // description: "The location of the library branch." // - key: branch_id // description: "The id of the branch." // metrics: // - name: library.googleapis.com/book/returned_count // display_name: "Books Returned" // description: "The count of books that have been returned." // launch_stage: GA // metric_kind: DELTA // value_type: INT64 // unit: "1" // labels: // - key: customer_id // description: "The id of the customer." // - name: library.googleapis.com/book/num_overdue // display_name: "Books Overdue" // description: "The current number of overdue books." // launch_stage: GA // metric_kind: GAUGE // value_type: INT64 // unit: "1" // labels: // - key: customer_id // description: "The id of the customer." // monitoring: // producer_destinations: // - monitored_resource: library.googleapis.com/Branch // metrics: // - library.googleapis.com/book/returned_count // consumer_destinations: // - monitored_resource: library.googleapis.com/Branch // metrics: // - library.googleapis.com/book/returned_count // - library.googleapis.com/book/num_overdue message Monitoring { // Configuration of a specific monitoring destination (the producer project // or the consumer project). message MonitoringDestination { // The monitored resource type. The type must be defined in // [Service.monitored_resources][google.api.Service.monitored_resources] // section. string monitored_resource = 1; // Types of the metrics to report to this monitoring destination. // Each type must be defined in // [Service.metrics][google.api.Service.metrics] section. repeated string metrics = 2; } // Monitoring configurations for sending metrics to the producer project. // There can be multiple producer destinations. A monitored resource type may // appear in multiple monitoring destinations if different aggregations are // needed for different sets of metrics associated with that monitored // resource type. A monitored resource and metric pair may only be used once // in the Monitoring configuration. repeated MonitoringDestination producer_destinations = 1; // Monitoring configurations for sending metrics to the consumer project. // There can be multiple consumer destinations. A monitored resource type may // appear in multiple monitoring destinations if different aggregations are // needed for different sets of metrics associated with that monitored // resource type. A monitored resource and metric pair may only be used once // in the Monitoring configuration. repeated MonitoringDestination consumer_destinations = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/monitoring_pb2.py0000644000000000000000000000462315177035222023011 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/monitoring.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1bgoogle/api/monitoring.proto\x12\ngoogle.api"\xec\x01\n\nMonitoring\x12K\n\x15producer_destinations\x18\x01 \x03(\x0b\x32,.google.api.Monitoring.MonitoringDestination\x12K\n\x15\x63onsumer_destinations\x18\x02 \x03(\x0b\x32,.google.api.Monitoring.MonitoringDestination\x1a\x44\n\x15MonitoringDestination\x12\x1a\n\x12monitored_resource\x18\x01 \x01(\t\x12\x0f\n\x07metrics\x18\x02 \x03(\tBq\n\x0e\x63om.google.apiB\x0fMonitoringProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.monitoring_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\017MonitoringProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_MONITORING"]._serialized_start = 44 _globals["_MONITORING"]._serialized_end = 280 _globals["_MONITORING_MONITORINGDESTINATION"]._serialized_start = 212 _globals["_MONITORING_MONITORINGDESTINATION"]._serialized_end = 280 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/monitoring_pb2.pyi0000644000000000000000000000425415177035221023161 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Monitoring(_message.Message): __slots__ = ("producer_destinations", "consumer_destinations") class MonitoringDestination(_message.Message): __slots__ = ("monitored_resource", "metrics") MONITORED_RESOURCE_FIELD_NUMBER: _ClassVar[int] METRICS_FIELD_NUMBER: _ClassVar[int] monitored_resource: str metrics: _containers.RepeatedScalarFieldContainer[str] def __init__( self, monitored_resource: _Optional[str] = ..., metrics: _Optional[_Iterable[str]] = ..., ) -> None: ... PRODUCER_DESTINATIONS_FIELD_NUMBER: _ClassVar[int] CONSUMER_DESTINATIONS_FIELD_NUMBER: _ClassVar[int] producer_destinations: _containers.RepeatedCompositeFieldContainer[ Monitoring.MonitoringDestination ] consumer_destinations: _containers.RepeatedCompositeFieldContainer[ Monitoring.MonitoringDestination ] def __init__( self, producer_destinations: _Optional[ _Iterable[_Union[Monitoring.MonitoringDestination, _Mapping]] ] = ..., consumer_destinations: _Optional[ _Iterable[_Union[Monitoring.MonitoringDestination, _Mapping]] ] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/policy.proto0000644000000000000000000000604615177035223022075 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "PolicyProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.FieldOptions { // See [FieldPolicy][]. google.api.FieldPolicy field_policy = 158361448; } extend google.protobuf.MethodOptions { // See [MethodPolicy][]. google.api.MethodPolicy method_policy = 161893301; } // Google API Policy Annotation // // This message defines a simple API policy annotation that can be used to // annotate API request and response message fields with applicable policies. // One field may have multiple applicable policies that must all be satisfied // before a request can be processed. This policy annotation is used to // generate the overall policy that will be used for automatic runtime // policy enforcement and documentation generation. message FieldPolicy { // Selects one or more request or response message fields to apply this // `FieldPolicy`. // // When a `FieldPolicy` is used in proto annotation, the selector must // be left as empty. The service config generator will automatically fill // the correct value. // // When a `FieldPolicy` is used in service config, the selector must be a // comma-separated string with valid request or response field paths, // such as "foo.bar" or "foo.bar,foo.baz". string selector = 1; // Specifies the required permission(s) for the resource referred to by the // field. It requires the field contains a valid resource reference, and // the request must pass the permission checks to proceed. For example, // "resourcemanager.projects.get". string resource_permission = 2; // Specifies the resource type for the resource referred to by the field. string resource_type = 3; } // Defines policies applying to an RPC method. message MethodPolicy { // Selects a method to which these policies should be enforced, for example, // "google.pubsub.v1.Subscriber.CreateSubscription". // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. // // NOTE: This field must not be set in the proto annotation. It will be // automatically filled by the service config compiler . string selector = 9; // Policies that are applicable to the request message. repeated FieldPolicy request_policies = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/policy_pb2.py0000644000000000000000000000517615177035223022130 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/policy.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x17google/api/policy.proto\x12\ngoogle.api\x1a google/protobuf/descriptor.proto"S\n\x0b\x46ieldPolicy\x12\x10\n\x08selector\x18\x01 \x01(\t\x12\x1b\n\x13resource_permission\x18\x02 \x01(\t\x12\x15\n\rresource_type\x18\x03 \x01(\t"S\n\x0cMethodPolicy\x12\x10\n\x08selector\x18\t \x01(\t\x12\x31\n\x10request_policies\x18\x02 \x03(\x0b\x32\x17.google.api.FieldPolicy:O\n\x0c\x66ield_policy\x12\x1d.google.protobuf.FieldOptions\x18\xe8\xce\xc1K \x01(\x0b\x32\x17.google.api.FieldPolicy:R\n\rmethod_policy\x12\x1e.google.protobuf.MethodOptions\x18\xb5\x97\x99M \x01(\x0b\x32\x18.google.api.MethodPolicyBm\n\x0e\x63om.google.apiB\x0bPolicyProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.policy_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\013PolicyProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_FIELDPOLICY"]._serialized_start = 73 _globals["_FIELDPOLICY"]._serialized_end = 156 _globals["_METHODPOLICY"]._serialized_start = 158 _globals["_METHODPOLICY"]._serialized_end = 241 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/policy_pb2.pyi0000644000000000000000000000417115177035223022273 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor FIELD_POLICY_FIELD_NUMBER: _ClassVar[int] field_policy: _descriptor.FieldDescriptor METHOD_POLICY_FIELD_NUMBER: _ClassVar[int] method_policy: _descriptor.FieldDescriptor class FieldPolicy(_message.Message): __slots__ = ("selector", "resource_permission", "resource_type") SELECTOR_FIELD_NUMBER: _ClassVar[int] RESOURCE_PERMISSION_FIELD_NUMBER: _ClassVar[int] RESOURCE_TYPE_FIELD_NUMBER: _ClassVar[int] selector: str resource_permission: str resource_type: str def __init__( self, selector: _Optional[str] = ..., resource_permission: _Optional[str] = ..., resource_type: _Optional[str] = ..., ) -> None: ... class MethodPolicy(_message.Message): __slots__ = ("selector", "request_policies") SELECTOR_FIELD_NUMBER: _ClassVar[int] REQUEST_POLICIES_FIELD_NUMBER: _ClassVar[int] selector: str request_policies: _containers.RepeatedCompositeFieldContainer[FieldPolicy] def __init__( self, selector: _Optional[str] = ..., request_policies: _Optional[_Iterable[_Union[FieldPolicy, _Mapping]]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/quota.proto0000644000000000000000000001601415177035226021726 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "QuotaProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Quota configuration helps to achieve fairness and budgeting in service // usage. // // The metric based quota configuration works this way: // - The service configuration defines a set of metrics. // - For API calls, the quota.metric_rules maps methods to metrics with // corresponding costs. // - The quota.limits defines limits on the metrics, which will be used for // quota checks at runtime. // // An example quota configuration in yaml format: // // quota: // limits: // // - name: apiWriteQpsPerProject // metric: library.googleapis.com/write_calls // unit: "1/min/{project}" # rate limit for consumer projects // values: // STANDARD: 10000 // // // (The metric rules bind all methods to the read_calls metric, // except for the UpdateBook and DeleteBook methods. These two methods // are mapped to the write_calls metric, with the UpdateBook method // consuming at twice rate as the DeleteBook method.) // metric_rules: // - selector: "*" // metric_costs: // library.googleapis.com/read_calls: 1 // - selector: google.example.library.v1.LibraryService.UpdateBook // metric_costs: // library.googleapis.com/write_calls: 2 // - selector: google.example.library.v1.LibraryService.DeleteBook // metric_costs: // library.googleapis.com/write_calls: 1 // // Corresponding Metric definition: // // metrics: // - name: library.googleapis.com/read_calls // display_name: Read requests // metric_kind: DELTA // value_type: INT64 // // - name: library.googleapis.com/write_calls // display_name: Write requests // metric_kind: DELTA // value_type: INT64 // // message Quota { // List of QuotaLimit definitions for the service. repeated QuotaLimit limits = 3; // List of MetricRule definitions, each one mapping a selected method to one // or more metrics. repeated MetricRule metric_rules = 4; } // Bind API methods to metrics. Binding a method to a metric causes that // metric's configured quota behaviors to apply to the method call. message MetricRule { // Selects the methods to which this rule applies. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. string selector = 1; // Metrics to update when the selected methods are called, and the associated // cost applied to each metric. // // The key of the map is the metric name, and the values are the amount // increased for the metric against which the quota limits are defined. // The value must not be negative. map metric_costs = 2; } // `QuotaLimit` defines a specific limit that applies over a specified duration // for a limit type. There can be at most one limit for a duration and limit // type combination defined within a `QuotaGroup`. message QuotaLimit { // Name of the quota limit. // // The name must be provided, and it must be unique within the service. The // name can only include alphanumeric characters as well as '-'. // // The maximum length of the limit name is 64 characters. string name = 6; // Optional. User-visible, extended description for this quota limit. // Should be used only when more context is needed to understand this limit // than provided by the limit's display name (see: `display_name`). string description = 2; // Default number of tokens that can be consumed during the specified // duration. This is the number of tokens assigned when a client // application developer activates the service for his/her project. // // Specifying a value of 0 will block all requests. This can be used if you // are provisioning quota to selected consumers and blocking others. // Similarly, a value of -1 will indicate an unlimited quota. No other // negative values are allowed. // // Used by group-based quotas only. int64 default_limit = 3; // Maximum number of tokens that can be consumed during the specified // duration. Client application developers can override the default limit up // to this maximum. If specified, this value cannot be set to a value less // than the default limit. If not specified, it is set to the default limit. // // To allow clients to apply overrides with no upper bound, set this to -1, // indicating unlimited maximum quota. // // Used by group-based quotas only. int64 max_limit = 4; // Free tier value displayed in the Developers Console for this limit. // The free tier is the number of tokens that will be subtracted from the // billed amount when billing is enabled. // This field can only be set on a limit with duration "1d", in a billable // group; it is invalid on any other limit. If this field is not set, it // defaults to 0, indicating that there is no free tier for this service. // // Used by group-based quotas only. int64 free_tier = 7; // Duration of this limit in textual notation. Must be "100s" or "1d". // // Used by group-based quotas only. string duration = 5; // The name of the metric this quota limit applies to. The quota limits with // the same metric will be checked together during runtime. The metric must be // defined within the service config. string metric = 8; // Specify the unit of the quota limit. It uses the same syntax as // [MetricDescriptor.unit][google.api.MetricDescriptor.unit]. The supported // unit kinds are determined by the quota backend system. // // Here are some examples: // * "1/min/{project}" for quota per minute per project. // // Note: the order of unit components is insignificant. // The "1" at the beginning is required to follow the metric unit syntax. string unit = 9; // Tiered limit values. You must specify this as a key:value pair, with an // integer value that is the maximum number of requests allowed for the // specified unit. Currently only STANDARD is supported. map values = 10; // User-visible display name for this limit. // Optional. If not set, the UI will provide a default display name based on // the quota configuration. This field can be used to override the default // display name generated from the configuration. string display_name = 12; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/quota_pb2.py0000644000000000000000000000703515177035224021757 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/quota.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x16google/api/quota.proto\x12\ngoogle.api"]\n\x05Quota\x12&\n\x06limits\x18\x03 \x03(\x0b\x32\x16.google.api.QuotaLimit\x12,\n\x0cmetric_rules\x18\x04 \x03(\x0b\x32\x16.google.api.MetricRule"\x91\x01\n\nMetricRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12=\n\x0cmetric_costs\x18\x02 \x03(\x0b\x32\'.google.api.MetricRule.MetricCostsEntry\x1a\x32\n\x10MetricCostsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01"\x95\x02\n\nQuotaLimit\x12\x0c\n\x04name\x18\x06 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x15\n\rdefault_limit\x18\x03 \x01(\x03\x12\x11\n\tmax_limit\x18\x04 \x01(\x03\x12\x11\n\tfree_tier\x18\x07 \x01(\x03\x12\x10\n\x08\x64uration\x18\x05 \x01(\t\x12\x0e\n\x06metric\x18\x08 \x01(\t\x12\x0c\n\x04unit\x18\t \x01(\t\x12\x32\n\x06values\x18\n \x03(\x0b\x32".google.api.QuotaLimit.ValuesEntry\x12\x14\n\x0c\x64isplay_name\x18\x0c \x01(\t\x1a-\n\x0bValuesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\x42l\n\x0e\x63om.google.apiB\nQuotaProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.quota_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\nQuotaProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_METRICRULE_METRICCOSTSENTRY"]._options = None _globals["_METRICRULE_METRICCOSTSENTRY"]._serialized_options = b"8\001" _globals["_QUOTALIMIT_VALUESENTRY"]._options = None _globals["_QUOTALIMIT_VALUESENTRY"]._serialized_options = b"8\001" _globals["_QUOTA"]._serialized_start = 38 _globals["_QUOTA"]._serialized_end = 131 _globals["_METRICRULE"]._serialized_start = 134 _globals["_METRICRULE"]._serialized_end = 279 _globals["_METRICRULE_METRICCOSTSENTRY"]._serialized_start = 229 _globals["_METRICRULE_METRICCOSTSENTRY"]._serialized_end = 279 _globals["_QUOTALIMIT"]._serialized_start = 282 _globals["_QUOTALIMIT"]._serialized_end = 559 _globals["_QUOTALIMIT_VALUESENTRY"]._serialized_start = 514 _globals["_QUOTALIMIT_VALUESENTRY"]._serialized_end = 559 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/quota_pb2.pyi0000644000000000000000000000744415177035221022131 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Quota(_message.Message): __slots__ = ("limits", "metric_rules") LIMITS_FIELD_NUMBER: _ClassVar[int] METRIC_RULES_FIELD_NUMBER: _ClassVar[int] limits: _containers.RepeatedCompositeFieldContainer[QuotaLimit] metric_rules: _containers.RepeatedCompositeFieldContainer[MetricRule] def __init__( self, limits: _Optional[_Iterable[_Union[QuotaLimit, _Mapping]]] = ..., metric_rules: _Optional[_Iterable[_Union[MetricRule, _Mapping]]] = ..., ) -> None: ... class MetricRule(_message.Message): __slots__ = ("selector", "metric_costs") class MetricCostsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: int def __init__( self, key: _Optional[str] = ..., value: _Optional[int] = ... ) -> None: ... SELECTOR_FIELD_NUMBER: _ClassVar[int] METRIC_COSTS_FIELD_NUMBER: _ClassVar[int] selector: str metric_costs: _containers.ScalarMap[str, int] def __init__( self, selector: _Optional[str] = ..., metric_costs: _Optional[_Mapping[str, int]] = ..., ) -> None: ... class QuotaLimit(_message.Message): __slots__ = ( "name", "description", "default_limit", "max_limit", "free_tier", "duration", "metric", "unit", "values", "display_name", ) class ValuesEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: int def __init__( self, key: _Optional[str] = ..., value: _Optional[int] = ... ) -> None: ... NAME_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] DEFAULT_LIMIT_FIELD_NUMBER: _ClassVar[int] MAX_LIMIT_FIELD_NUMBER: _ClassVar[int] FREE_TIER_FIELD_NUMBER: _ClassVar[int] DURATION_FIELD_NUMBER: _ClassVar[int] METRIC_FIELD_NUMBER: _ClassVar[int] UNIT_FIELD_NUMBER: _ClassVar[int] VALUES_FIELD_NUMBER: _ClassVar[int] DISPLAY_NAME_FIELD_NUMBER: _ClassVar[int] name: str description: str default_limit: int max_limit: int free_tier: int duration: str metric: str unit: str values: _containers.ScalarMap[str, int] display_name: str def __init__( self, name: _Optional[str] = ..., description: _Optional[str] = ..., default_limit: _Optional[int] = ..., max_limit: _Optional[int] = ..., free_tier: _Optional[int] = ..., duration: _Optional[str] = ..., metric: _Optional[str] = ..., unit: _Optional[str] = ..., values: _Optional[_Mapping[str, int]] = ..., display_name: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/resource.proto0000644000000000000000000002144215177035223022422 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "ResourceProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.FieldOptions { // An annotation that describes a resource reference, see // [ResourceReference][]. google.api.ResourceReference resource_reference = 1055; } extend google.protobuf.FileOptions { // An annotation that describes a resource definition without a corresponding // message; see [ResourceDescriptor][]. repeated google.api.ResourceDescriptor resource_definition = 1053; } extend google.protobuf.MessageOptions { // An annotation that describes a resource definition, see // [ResourceDescriptor][]. google.api.ResourceDescriptor resource = 1053; } // A simple descriptor of a resource type. // // ResourceDescriptor annotates a resource message (either by means of a // protobuf annotation or use in the service config), and associates the // resource's schema, the resource type, and the pattern of the resource name. // // Example: // // message Topic { // // Indicates this message defines a resource schema. // // Declares the resource type in the format of {service}/{kind}. // // For Kubernetes resources, the format is {api group}/{kind}. // option (google.api.resource) = { // type: "pubsub.googleapis.com/Topic" // pattern: "projects/{project}/topics/{topic}" // }; // } // // The ResourceDescriptor Yaml config will look like: // // resources: // - type: "pubsub.googleapis.com/Topic" // pattern: "projects/{project}/topics/{topic}" // // Sometimes, resources have multiple patterns, typically because they can // live under multiple parents. // // Example: // // message LogEntry { // option (google.api.resource) = { // type: "logging.googleapis.com/LogEntry" // pattern: "projects/{project}/logs/{log}" // pattern: "folders/{folder}/logs/{log}" // pattern: "organizations/{organization}/logs/{log}" // pattern: "billingAccounts/{billing_account}/logs/{log}" // }; // } // // The ResourceDescriptor Yaml config will look like: // // resources: // - type: 'logging.googleapis.com/LogEntry' // pattern: "projects/{project}/logs/{log}" // pattern: "folders/{folder}/logs/{log}" // pattern: "organizations/{organization}/logs/{log}" // pattern: "billingAccounts/{billing_account}/logs/{log}" message ResourceDescriptor { // A description of the historical or future-looking state of the // resource pattern. enum History { // The "unset" value. HISTORY_UNSPECIFIED = 0; // The resource originally had one pattern and launched as such, and // additional patterns were added later. ORIGINALLY_SINGLE_PATTERN = 1; // The resource has one pattern, but the API owner expects to add more // later. (This is the inverse of ORIGINALLY_SINGLE_PATTERN, and prevents // that from being necessary once there are multiple patterns.) FUTURE_MULTI_PATTERN = 2; } // A flag representing a specific style that a resource claims to conform to. enum Style { // The unspecified value. Do not use. STYLE_UNSPECIFIED = 0; // This resource is intended to be "declarative-friendly". // // Declarative-friendly resources must be more strictly consistent, and // setting this to true communicates to tools that this resource should // adhere to declarative-friendly expectations. // // Note: This is used by the API linter (linter.aip.dev) to enable // additional checks. DECLARATIVE_FRIENDLY = 1; } // The resource type. It must be in the format of // {service_name}/{resource_type_kind}. The `resource_type_kind` must be // singular and must not include version numbers. // // Example: `storage.googleapis.com/Bucket` // // The value of the resource_type_kind must follow the regular expression // /[A-Za-z][a-zA-Z0-9]+/. It should start with an upper case character and // should use PascalCase (UpperCamelCase). The maximum number of // characters allowed for the `resource_type_kind` is 100. string type = 1; // Optional. The relative resource name pattern associated with this resource // type. The DNS prefix of the full resource name shouldn't be specified here. // // The path pattern must follow the syntax, which aligns with HTTP binding // syntax: // // Template = Segment { "/" Segment } ; // Segment = LITERAL | Variable ; // Variable = "{" LITERAL "}" ; // // Examples: // // - "projects/{project}/topics/{topic}" // - "projects/{project}/knowledgeBases/{knowledge_base}" // // The components in braces correspond to the IDs for each resource in the // hierarchy. It is expected that, if multiple patterns are provided, // the same component name (e.g. "project") refers to IDs of the same // type of resource. repeated string pattern = 2; // Optional. The field on the resource that designates the resource name // field. If omitted, this is assumed to be "name". string name_field = 3; // Optional. The historical or future-looking state of the resource pattern. // // Example: // // // The InspectTemplate message originally only supported resource // // names with organization, and project was added later. // message InspectTemplate { // option (google.api.resource) = { // type: "dlp.googleapis.com/InspectTemplate" // pattern: // "organizations/{organization}/inspectTemplates/{inspect_template}" // pattern: "projects/{project}/inspectTemplates/{inspect_template}" // history: ORIGINALLY_SINGLE_PATTERN // }; // } History history = 4; // The plural name used in the resource name and permission names, such as // 'projects' for the resource name of 'projects/{project}' and the permission // name of 'cloudresourcemanager.googleapis.com/projects.get'. One exception // to this is for Nested Collections that have stuttering names, as defined // in [AIP-122](https://google.aip.dev/122#nested-collections), where the // collection ID in the resource name pattern does not necessarily directly // match the `plural` value. // // It is the same concept of the `plural` field in k8s CRD spec // https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/ // // Note: The plural form is required even for singleton resources. See // https://aip.dev/156 string plural = 5; // The same concept of the `singular` field in k8s CRD spec // https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definitions/ // Such as "project" for the `resourcemanager.googleapis.com/Project` type. string singular = 6; // Style flag(s) for this resource. // These indicate that a resource is expected to conform to a given // style. See the specific style flags for additional information. repeated Style style = 10; } // Defines a proto annotation that describes a string field that refers to // an API resource. message ResourceReference { // The resource type that the annotated field references. // // Example: // // message Subscription { // string topic = 2 [(google.api.resource_reference) = { // type: "pubsub.googleapis.com/Topic" // }]; // } // // Occasionally, a field may reference an arbitrary resource. In this case, // APIs use the special value * in their resource reference. // // Example: // // message GetIamPolicyRequest { // string resource = 2 [(google.api.resource_reference) = { // type: "*" // }]; // } string type = 1; // The resource type of a child collection that the annotated field // references. This is useful for annotating the `parent` field that // doesn't have a fixed resource type. // // Example: // // message ListLogEntriesRequest { // string parent = 1 [(google.api.resource_reference) = { // child_type: "logging.googleapis.com/LogEntry" // }; // } string child_type = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/resource_pb2.py0000644000000000000000000000671715177035223022462 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/resource.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x19google/api/resource.proto\x12\ngoogle.api\x1a google/protobuf/descriptor.proto"\xee\x02\n\x12ResourceDescriptor\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x0f\n\x07pattern\x18\x02 \x03(\t\x12\x12\n\nname_field\x18\x03 \x01(\t\x12\x37\n\x07history\x18\x04 \x01(\x0e\x32&.google.api.ResourceDescriptor.History\x12\x0e\n\x06plural\x18\x05 \x01(\t\x12\x10\n\x08singular\x18\x06 \x01(\t\x12\x33\n\x05style\x18\n \x03(\x0e\x32$.google.api.ResourceDescriptor.Style"[\n\x07History\x12\x17\n\x13HISTORY_UNSPECIFIED\x10\x00\x12\x1d\n\x19ORIGINALLY_SINGLE_PATTERN\x10\x01\x12\x18\n\x14\x46UTURE_MULTI_PATTERN\x10\x02"8\n\x05Style\x12\x15\n\x11STYLE_UNSPECIFIED\x10\x00\x12\x18\n\x14\x44\x45\x43LARATIVE_FRIENDLY\x10\x01"5\n\x11ResourceReference\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x12\n\nchild_type\x18\x02 \x01(\t:Y\n\x12resource_reference\x12\x1d.google.protobuf.FieldOptions\x18\x9f\x08 \x01(\x0b\x32\x1d.google.api.ResourceReference:Z\n\x13resource_definition\x12\x1c.google.protobuf.FileOptions\x18\x9d\x08 \x03(\x0b\x32\x1e.google.api.ResourceDescriptor:R\n\x08resource\x12\x1f.google.protobuf.MessageOptions\x18\x9d\x08 \x01(\x0b\x32\x1e.google.api.ResourceDescriptorBk\n\x0e\x63om.google.apiB\rResourceProtoP\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.resource_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\rResourceProtoP\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\242\002\004GAPI" _globals["_RESOURCEDESCRIPTOR"]._serialized_start = 76 _globals["_RESOURCEDESCRIPTOR"]._serialized_end = 442 _globals["_RESOURCEDESCRIPTOR_HISTORY"]._serialized_start = 293 _globals["_RESOURCEDESCRIPTOR_HISTORY"]._serialized_end = 384 _globals["_RESOURCEDESCRIPTOR_STYLE"]._serialized_start = 386 _globals["_RESOURCEDESCRIPTOR_STYLE"]._serialized_end = 442 _globals["_RESOURCEREFERENCE"]._serialized_start = 444 _globals["_RESOURCEREFERENCE"]._serialized_end = 497 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/resource_pb2.pyi0000644000000000000000000000700415177035226022624 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor RESOURCE_REFERENCE_FIELD_NUMBER: _ClassVar[int] resource_reference: _descriptor.FieldDescriptor RESOURCE_DEFINITION_FIELD_NUMBER: _ClassVar[int] resource_definition: _descriptor.FieldDescriptor RESOURCE_FIELD_NUMBER: _ClassVar[int] resource: _descriptor.FieldDescriptor class ResourceDescriptor(_message.Message): __slots__ = ( "type", "pattern", "name_field", "history", "plural", "singular", "style", ) class History(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () HISTORY_UNSPECIFIED: _ClassVar[ResourceDescriptor.History] ORIGINALLY_SINGLE_PATTERN: _ClassVar[ResourceDescriptor.History] FUTURE_MULTI_PATTERN: _ClassVar[ResourceDescriptor.History] HISTORY_UNSPECIFIED: ResourceDescriptor.History ORIGINALLY_SINGLE_PATTERN: ResourceDescriptor.History FUTURE_MULTI_PATTERN: ResourceDescriptor.History class Style(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () STYLE_UNSPECIFIED: _ClassVar[ResourceDescriptor.Style] DECLARATIVE_FRIENDLY: _ClassVar[ResourceDescriptor.Style] STYLE_UNSPECIFIED: ResourceDescriptor.Style DECLARATIVE_FRIENDLY: ResourceDescriptor.Style TYPE_FIELD_NUMBER: _ClassVar[int] PATTERN_FIELD_NUMBER: _ClassVar[int] NAME_FIELD_FIELD_NUMBER: _ClassVar[int] HISTORY_FIELD_NUMBER: _ClassVar[int] PLURAL_FIELD_NUMBER: _ClassVar[int] SINGULAR_FIELD_NUMBER: _ClassVar[int] STYLE_FIELD_NUMBER: _ClassVar[int] type: str pattern: _containers.RepeatedScalarFieldContainer[str] name_field: str history: ResourceDescriptor.History plural: str singular: str style: _containers.RepeatedScalarFieldContainer[ResourceDescriptor.Style] def __init__( self, type: _Optional[str] = ..., pattern: _Optional[_Iterable[str]] = ..., name_field: _Optional[str] = ..., history: _Optional[_Union[ResourceDescriptor.History, str]] = ..., plural: _Optional[str] = ..., singular: _Optional[str] = ..., style: _Optional[_Iterable[_Union[ResourceDescriptor.Style, str]]] = ..., ) -> None: ... class ResourceReference(_message.Message): __slots__ = ("type", "child_type") TYPE_FIELD_NUMBER: _ClassVar[int] CHILD_TYPE_FIELD_NUMBER: _ClassVar[int] type: str child_type: str def __init__( self, type: _Optional[str] = ..., child_type: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/routing.proto0000644000000000000000000003553115177035222022265 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "RoutingProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.MethodOptions { // See RoutingRule. google.api.RoutingRule routing = 72295729; } // Specifies the routing information that should be sent along with the request // in the form of routing header. // **NOTE:** All service configuration rules follow the "last one wins" order. // // The examples below will apply to an RPC which has the following request type: // // Message Definition: // // message Request { // // The name of the Table // // Values can be of the following formats: // // - `projects//tables/` // // - `projects//instances//tables/
` // // - `region//zones//tables/
` // string table_name = 1; // // // This value specifies routing for replication. // // It can be in the following formats: // // - `profiles/` // // - a legacy `profile_id` that can be any string // string app_profile_id = 2; // } // // Example message: // // { // table_name: projects/proj_foo/instances/instance_bar/table/table_baz, // app_profile_id: profiles/prof_qux // } // // The routing header consists of one or multiple key-value pairs. The order of // the key-value pairs is undefined, the order of the `routing_parameters` in // the `RoutingRule` only matters for the evaluation order of the path // templates when `field` is the same. See the examples below for more details. // // Every key and value in the routing header must be percent-encoded, // and joined together in the following format: `key1=value1&key2=value2`. // The examples below skip the percent-encoding for readability. // // Example 1 // // Extracting a field from the request to put into the routing header // unchanged, with the key equal to the field name. // // annotation: // // option (google.api.routing) = { // // Take the `app_profile_id`. // routing_parameters { // field: "app_profile_id" // } // }; // // result: // // x-goog-request-params: app_profile_id=profiles/prof_qux // // Example 2 // // Extracting a field from the request to put into the routing header // unchanged, with the key different from the field name. // // annotation: // // option (google.api.routing) = { // // Take the `app_profile_id`, but name it `routing_id` in the header. // routing_parameters { // field: "app_profile_id" // path_template: "{routing_id=**}" // } // }; // // result: // // x-goog-request-params: routing_id=profiles/prof_qux // // Example 3 // // Extracting a field from the request to put into the routing // header, while matching a path template syntax on the field's value. // // NB: it is more useful to send nothing than to send garbage for the purpose // of dynamic routing, since garbage pollutes cache. Thus the matching. // // Sub-example 3a // // The field matches the template. // // annotation: // // option (google.api.routing) = { // // Take the `table_name`, if it's well-formed (with project-based // // syntax). // routing_parameters { // field: "table_name" // path_template: "{table_name=projects/*/instances/*/**}" // } // }; // // result: // // x-goog-request-params: // table_name=projects/proj_foo/instances/instance_bar/table/table_baz // // Sub-example 3b // // The field does not match the template. // // annotation: // // option (google.api.routing) = { // // Take the `table_name`, if it's well-formed (with region-based // // syntax). // routing_parameters { // field: "table_name" // path_template: "{table_name=regions/*/zones/*/**}" // } // }; // // result: // // // // Sub-example 3c // // Multiple alternative conflictingly named path templates are // specified. The one that matches is used to construct the header. // // annotation: // // option (google.api.routing) = { // // Take the `table_name`, if it's well-formed, whether // // using the region- or projects-based syntax. // // routing_parameters { // field: "table_name" // path_template: "{table_name=regions/*/zones/*/**}" // } // routing_parameters { // field: "table_name" // path_template: "{table_name=projects/*/instances/*/**}" // } // }; // // result: // // x-goog-request-params: // table_name=projects/proj_foo/instances/instance_bar/table/table_baz // // Example 4 // // Extracting a single routing header key-value pair by matching a // template syntax on (a part of) a single request field. // // annotation: // // option (google.api.routing) = { // // Take just the project id from the `table_name` field. // routing_parameters { // field: "table_name" // path_template: "{routing_id=projects/*}/**" // } // }; // // result: // // x-goog-request-params: routing_id=projects/proj_foo // // Example 5 // // Extracting a single routing header key-value pair by matching // several conflictingly named path templates on (parts of) a single request // field. The last template to match "wins" the conflict. // // annotation: // // option (google.api.routing) = { // // If the `table_name` does not have instances information, // // take just the project id for routing. // // Otherwise take project + instance. // // routing_parameters { // field: "table_name" // path_template: "{routing_id=projects/*}/**" // } // routing_parameters { // field: "table_name" // path_template: "{routing_id=projects/*/instances/*}/**" // } // }; // // result: // // x-goog-request-params: // routing_id=projects/proj_foo/instances/instance_bar // // Example 6 // // Extracting multiple routing header key-value pairs by matching // several non-conflicting path templates on (parts of) a single request field. // // Sub-example 6a // // Make the templates strict, so that if the `table_name` does not // have an instance information, nothing is sent. // // annotation: // // option (google.api.routing) = { // // The routing code needs two keys instead of one composite // // but works only for the tables with the "project-instance" name // // syntax. // // routing_parameters { // field: "table_name" // path_template: "{project_id=projects/*}/instances/*/**" // } // routing_parameters { // field: "table_name" // path_template: "projects/*/{instance_id=instances/*}/**" // } // }; // // result: // // x-goog-request-params: // project_id=projects/proj_foo&instance_id=instances/instance_bar // // Sub-example 6b // // Make the templates loose, so that if the `table_name` does not // have an instance information, just the project id part is sent. // // annotation: // // option (google.api.routing) = { // // The routing code wants two keys instead of one composite // // but will work with just the `project_id` for tables without // // an instance in the `table_name`. // // routing_parameters { // field: "table_name" // path_template: "{project_id=projects/*}/**" // } // routing_parameters { // field: "table_name" // path_template: "projects/*/{instance_id=instances/*}/**" // } // }; // // result (is the same as 6a for our example message because it has the instance // information): // // x-goog-request-params: // project_id=projects/proj_foo&instance_id=instances/instance_bar // // Example 7 // // Extracting multiple routing header key-value pairs by matching // several path templates on multiple request fields. // // NB: note that here there is no way to specify sending nothing if one of the // fields does not match its template. E.g. if the `table_name` is in the wrong // format, the `project_id` will not be sent, but the `routing_id` will be. // The backend routing code has to be aware of that and be prepared to not // receive a full complement of keys if it expects multiple. // // annotation: // // option (google.api.routing) = { // // The routing needs both `project_id` and `routing_id` // // (from the `app_profile_id` field) for routing. // // routing_parameters { // field: "table_name" // path_template: "{project_id=projects/*}/**" // } // routing_parameters { // field: "app_profile_id" // path_template: "{routing_id=**}" // } // }; // // result: // // x-goog-request-params: // project_id=projects/proj_foo&routing_id=profiles/prof_qux // // Example 8 // // Extracting a single routing header key-value pair by matching // several conflictingly named path templates on several request fields. The // last template to match "wins" the conflict. // // annotation: // // option (google.api.routing) = { // // The `routing_id` can be a project id or a region id depending on // // the table name format, but only if the `app_profile_id` is not set. // // If `app_profile_id` is set it should be used instead. // // routing_parameters { // field: "table_name" // path_template: "{routing_id=projects/*}/**" // } // routing_parameters { // field: "table_name" // path_template: "{routing_id=regions/*}/**" // } // routing_parameters { // field: "app_profile_id" // path_template: "{routing_id=**}" // } // }; // // result: // // x-goog-request-params: routing_id=profiles/prof_qux // // Example 9 // // Bringing it all together. // // annotation: // // option (google.api.routing) = { // // For routing both `table_location` and a `routing_id` are needed. // // // // table_location can be either an instance id or a region+zone id. // // // // For `routing_id`, take the value of `app_profile_id` // // - If it's in the format `profiles/`, send // // just the `` part. // // - If it's any other literal, send it as is. // // If the `app_profile_id` is empty, and the `table_name` starts with // // the project_id, send that instead. // // routing_parameters { // field: "table_name" // path_template: "projects/*/{table_location=instances/*}/tables/*" // } // routing_parameters { // field: "table_name" // path_template: "{table_location=regions/*/zones/*}/tables/*" // } // routing_parameters { // field: "table_name" // path_template: "{routing_id=projects/*}/**" // } // routing_parameters { // field: "app_profile_id" // path_template: "{routing_id=**}" // } // routing_parameters { // field: "app_profile_id" // path_template: "profiles/{routing_id=*}" // } // }; // // result: // // x-goog-request-params: // table_location=instances/instance_bar&routing_id=prof_qux message RoutingRule { // A collection of Routing Parameter specifications. // **NOTE:** If multiple Routing Parameters describe the same key // (via the `path_template` field or via the `field` field when // `path_template` is not provided), "last one wins" rule // determines which Parameter gets used. // See the examples for more details. repeated RoutingParameter routing_parameters = 2; } // A projection from an input message to the GRPC or REST header. message RoutingParameter { // A request field to extract the header key-value pair from. string field = 1; // A pattern matching the key-value field. Optional. // If not specified, the whole field specified in the `field` field will be // taken as value, and its name used as key. If specified, it MUST contain // exactly one named segment (along with any number of unnamed segments) The // pattern will be matched over the field specified in the `field` field, then // if the match is successful: // - the name of the single named segment will be used as a header name, // - the match value of the segment will be used as a header value; // if the match is NOT successful, nothing will be sent. // // Example: // // -- This is a field in the request message // | that the header value will be extracted from. // | // | -- This is the key name in the // | | routing header. // V | // field: "table_name" v // path_template: "projects/*/{table_location=instances/*}/tables/*" // ^ ^ // | | // In the {} brackets is the pattern that -- | // specifies what to extract from the | // field as a value to be sent. | // | // The string in the field must match the whole pattern -- // before brackets, inside brackets, after brackets. // // When looking at this specific example, we can see that: // - A key-value pair with the key `table_location` // and the value matching `instances/*` should be added // to the x-goog-request-params routing header. // - The value is extracted from the request message's `table_name` field // if it matches the full pattern specified: // `projects/*/instances/*/tables/*`. // // **NB:** If the `path_template` field is not provided, the key name is // equal to the field name, and the whole field should be sent as a value. // This makes the pattern for the field and the value functionally equivalent // to `**`, and the configuration // // { // field: "table_name" // } // // is a functionally equivalent shorthand to: // // { // field: "table_name" // path_template: "{table_name=**}" // } // // See Example 1 for more details. string path_template = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/routing_pb2.py0000644000000000000000000000467115177035222022316 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/routing.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x18google/api/routing.proto\x12\ngoogle.api\x1a google/protobuf/descriptor.proto"G\n\x0bRoutingRule\x12\x38\n\x12routing_parameters\x18\x02 \x03(\x0b\x32\x1c.google.api.RoutingParameter"8\n\x10RoutingParameter\x12\r\n\x05\x66ield\x18\x01 \x01(\t\x12\x15\n\rpath_template\x18\x02 \x01(\t:K\n\x07routing\x12\x1e.google.protobuf.MethodOptions\x18\xb1\xca\xbc" \x01(\x0b\x32\x17.google.api.RoutingRuleBj\n\x0e\x63om.google.apiB\x0cRoutingProtoP\x01ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.routing_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\014RoutingProtoP\001ZAgoogle.golang.org/genproto/googleapis/api/annotations;annotations\242\002\004GAPI" _globals["_ROUTINGRULE"]._serialized_start = 74 _globals["_ROUTINGRULE"]._serialized_end = 145 _globals["_ROUTINGPARAMETER"]._serialized_start = 147 _globals["_ROUTINGPARAMETER"]._serialized_end = 203 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/routing_pb2.pyi0000644000000000000000000000343515177035226022470 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor ROUTING_FIELD_NUMBER: _ClassVar[int] routing: _descriptor.FieldDescriptor class RoutingRule(_message.Message): __slots__ = ("routing_parameters",) ROUTING_PARAMETERS_FIELD_NUMBER: _ClassVar[int] routing_parameters: _containers.RepeatedCompositeFieldContainer[RoutingParameter] def __init__( self, routing_parameters: _Optional[ _Iterable[_Union[RoutingParameter, _Mapping]] ] = ..., ) -> None: ... class RoutingParameter(_message.Message): __slots__ = ("field", "path_template") FIELD_FIELD_NUMBER: _ClassVar[int] PATH_TEMPLATE_FIELD_NUMBER: _ClassVar[int] field: str path_template: str def __init__( self, field: _Optional[str] = ..., path_template: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/service.proto0000644000000000000000000001505215177035221022231 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/api/auth.proto"; import "google/api/backend.proto"; import "google/api/billing.proto"; import "google/api/client.proto"; import "google/api/context.proto"; import "google/api/control.proto"; import "google/api/documentation.proto"; import "google/api/endpoint.proto"; import "google/api/http.proto"; import "google/api/log.proto"; import "google/api/logging.proto"; import "google/api/metric.proto"; import "google/api/monitored_resource.proto"; import "google/api/monitoring.proto"; import "google/api/quota.proto"; import "google/api/source_info.proto"; import "google/api/system_parameter.proto"; import "google/api/usage.proto"; import "google/protobuf/api.proto"; import "google/protobuf/type.proto"; import "google/protobuf/wrappers.proto"; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "ServiceProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // `Service` is the root object of Google API service configuration (service // config). It describes the basic information about a logical service, // such as the service name and the user-facing title, and delegates other // aspects to sub-sections. Each sub-section is either a proto message or a // repeated proto message that configures a specific aspect, such as auth. // For more information, see each proto message definition. // // Example: // // type: google.api.Service // name: calendar.googleapis.com // title: Google Calendar API // apis: // - name: google.calendar.v3.Calendar // // visibility: // rules: // - selector: "google.calendar.v3.*" // restriction: PREVIEW // backend: // rules: // - selector: "google.calendar.v3.*" // address: calendar.example.com // // authentication: // providers: // - id: google_calendar_auth // jwks_uri: https://www.googleapis.com/oauth2/v1/certs // issuer: https://securetoken.google.com // rules: // - selector: "*" // requirements: // provider_id: google_calendar_auth message Service { // The service name, which is a DNS-like logical identifier for the // service, such as `calendar.googleapis.com`. The service name // typically goes through DNS verification to make sure the owner // of the service also owns the DNS name. string name = 1; // The product title for this service, it is the name displayed in Google // Cloud Console. string title = 2; // The Google project that owns this service. string producer_project_id = 22; // A unique ID for a specific instance of this message, typically assigned // by the client for tracking purpose. Must be no longer than 63 characters // and only lower case letters, digits, '.', '_' and '-' are allowed. If // empty, the server may choose to generate one instead. string id = 33; // A list of API interfaces exported by this service. Only the `name` field // of the [google.protobuf.Api][google.protobuf.Api] needs to be provided by // the configuration author, as the remaining fields will be derived from the // IDL during the normalization process. It is an error to specify an API // interface here which cannot be resolved against the associated IDL files. repeated google.protobuf.Api apis = 3; // A list of all proto message types included in this API service. // Types referenced directly or indirectly by the `apis` are automatically // included. Messages which are not referenced but shall be included, such as // types used by the `google.protobuf.Any` type, should be listed here by // name by the configuration author. Example: // // types: // - name: google.protobuf.Int32 repeated google.protobuf.Type types = 4; // A list of all enum types included in this API service. Enums referenced // directly or indirectly by the `apis` are automatically included. Enums // which are not referenced but shall be included should be listed here by // name by the configuration author. Example: // // enums: // - name: google.someapi.v1.SomeEnum repeated google.protobuf.Enum enums = 5; // Additional API documentation. Documentation documentation = 6; // API backend configuration. Backend backend = 8; // HTTP configuration. Http http = 9; // Quota configuration. Quota quota = 10; // Auth configuration. Authentication authentication = 11; // Context configuration. Context context = 12; // Configuration controlling usage of this service. Usage usage = 15; // Configuration for network endpoints. If this is empty, then an endpoint // with the same name as the service is automatically generated to service all // defined APIs. repeated Endpoint endpoints = 18; // Configuration for the service control plane. Control control = 21; // Defines the logs used by this service. repeated LogDescriptor logs = 23; // Defines the metrics used by this service. repeated MetricDescriptor metrics = 24; // Defines the monitored resources used by this service. This is required // by the `Service.monitoring` and `Service.logging` configurations. repeated MonitoredResourceDescriptor monitored_resources = 25; // Billing configuration. Billing billing = 26; // Logging configuration. Logging logging = 27; // Monitoring configuration. Monitoring monitoring = 28; // System parameter configuration. SystemParameters system_parameters = 29; // Output only. The source information for this configuration if available. SourceInfo source_info = 37; // Settings for [Google Cloud Client // libraries](https://cloud.google.com/apis/docs/cloud-client-libraries) // generated from APIs defined as protocol buffers. Publishing publishing = 45; // Obsolete. Do not use. // // This field has no semantic meaning. The service config compiler always // sets this field to `3`. google.protobuf.UInt32Value config_version = 20; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/service_pb2.py0000644000000000000000000001334215177035222022262 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/service.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import api_pb2 as google_dot_protobuf_dot_api__pb2 from google.protobuf import type_pb2 as google_dot_protobuf_dot_type__pb2 from google.protobuf import wrappers_pb2 as google_dot_protobuf_dot_wrappers__pb2 from google.api import auth_pb2 as google_dot_api_dot_auth__pb2 from google.api import backend_pb2 as google_dot_api_dot_backend__pb2 from google.api import billing_pb2 as google_dot_api_dot_billing__pb2 from google.api import client_pb2 as google_dot_api_dot_client__pb2 from google.api import context_pb2 as google_dot_api_dot_context__pb2 from google.api import control_pb2 as google_dot_api_dot_control__pb2 from google.api import documentation_pb2 as google_dot_api_dot_documentation__pb2 from google.api import endpoint_pb2 as google_dot_api_dot_endpoint__pb2 from google.api import http_pb2 as google_dot_api_dot_http__pb2 from google.api import log_pb2 as google_dot_api_dot_log__pb2 from google.api import logging_pb2 as google_dot_api_dot_logging__pb2 from google.api import metric_pb2 as google_dot_api_dot_metric__pb2 from google.api import ( monitored_resource_pb2 as google_dot_api_dot_monitored__resource__pb2, ) from google.api import monitoring_pb2 as google_dot_api_dot_monitoring__pb2 from google.api import quota_pb2 as google_dot_api_dot_quota__pb2 from google.api import source_info_pb2 as google_dot_api_dot_source__info__pb2 from google.api import system_parameter_pb2 as google_dot_api_dot_system__parameter__pb2 from google.api import usage_pb2 as google_dot_api_dot_usage__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n\x18google/api/service.proto\x12\ngoogle.api\x1a\x15google/api/auth.proto\x1a\x18google/api/backend.proto\x1a\x18google/api/billing.proto\x1a\x17google/api/client.proto\x1a\x18google/api/context.proto\x1a\x18google/api/control.proto\x1a\x1egoogle/api/documentation.proto\x1a\x19google/api/endpoint.proto\x1a\x15google/api/http.proto\x1a\x14google/api/log.proto\x1a\x18google/api/logging.proto\x1a\x17google/api/metric.proto\x1a#google/api/monitored_resource.proto\x1a\x1bgoogle/api/monitoring.proto\x1a\x16google/api/quota.proto\x1a\x1cgoogle/api/source_info.proto\x1a!google/api/system_parameter.proto\x1a\x16google/api/usage.proto\x1a\x19google/protobuf/api.proto\x1a\x1agoogle/protobuf/type.proto\x1a\x1egoogle/protobuf/wrappers.proto\"\x82\x08\n\x07Service\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\r\n\x05title\x18\x02 \x01(\t\x12\x1b\n\x13producer_project_id\x18\x16 \x01(\t\x12\n\n\x02id\x18! \x01(\t\x12\"\n\x04\x61pis\x18\x03 \x03(\x0b\x32\x14.google.protobuf.Api\x12$\n\x05types\x18\x04 \x03(\x0b\x32\x15.google.protobuf.Type\x12$\n\x05\x65nums\x18\x05 \x03(\x0b\x32\x15.google.protobuf.Enum\x12\x30\n\rdocumentation\x18\x06 \x01(\x0b\x32\x19.google.api.Documentation\x12$\n\x07\x62\x61\x63kend\x18\x08 \x01(\x0b\x32\x13.google.api.Backend\x12\x1e\n\x04http\x18\t \x01(\x0b\x32\x10.google.api.Http\x12 \n\x05quota\x18\n \x01(\x0b\x32\x11.google.api.Quota\x12\x32\n\x0e\x61uthentication\x18\x0b \x01(\x0b\x32\x1a.google.api.Authentication\x12$\n\x07\x63ontext\x18\x0c \x01(\x0b\x32\x13.google.api.Context\x12 \n\x05usage\x18\x0f \x01(\x0b\x32\x11.google.api.Usage\x12'\n\tendpoints\x18\x12 \x03(\x0b\x32\x14.google.api.Endpoint\x12$\n\x07\x63ontrol\x18\x15 \x01(\x0b\x32\x13.google.api.Control\x12'\n\x04logs\x18\x17 \x03(\x0b\x32\x19.google.api.LogDescriptor\x12-\n\x07metrics\x18\x18 \x03(\x0b\x32\x1c.google.api.MetricDescriptor\x12\x44\n\x13monitored_resources\x18\x19 \x03(\x0b\x32'.google.api.MonitoredResourceDescriptor\x12$\n\x07\x62illing\x18\x1a \x01(\x0b\x32\x13.google.api.Billing\x12$\n\x07logging\x18\x1b \x01(\x0b\x32\x13.google.api.Logging\x12*\n\nmonitoring\x18\x1c \x01(\x0b\x32\x16.google.api.Monitoring\x12\x37\n\x11system_parameters\x18\x1d \x01(\x0b\x32\x1c.google.api.SystemParameters\x12+\n\x0bsource_info\x18% \x01(\x0b\x32\x16.google.api.SourceInfo\x12*\n\npublishing\x18- \x01(\x0b\x32\x16.google.api.Publishing\x12\x34\n\x0e\x63onfig_version\x18\x14 \x01(\x0b\x32\x1c.google.protobuf.UInt32ValueBn\n\x0e\x63om.google.apiB\x0cServiceProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.service_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\014ServiceProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_SERVICE"]._serialized_start = 614 _globals["_SERVICE"]._serialized_end = 1640 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/api/service_pb2.pyi0000644000000000000000000001577415177035223022447 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import api_pb2 as _api_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import type_pb2 as _type_pb2 from google.protobuf import wrappers_pb2 as _wrappers_pb2 from google.protobuf.internal import containers as _containers from google.api import auth_pb2 as _auth_pb2 from google.api import backend_pb2 as _backend_pb2 from google.api import billing_pb2 as _billing_pb2 from google.api import client_pb2 as _client_pb2 from google.api import context_pb2 as _context_pb2 from google.api import control_pb2 as _control_pb2 from google.api import documentation_pb2 as _documentation_pb2 from google.api import endpoint_pb2 as _endpoint_pb2 from google.api import http_pb2 as _http_pb2 from google.api import log_pb2 as _log_pb2 from google.api import logging_pb2 as _logging_pb2 from google.api import metric_pb2 as _metric_pb2 from google.api import monitored_resource_pb2 as _monitored_resource_pb2 from google.api import monitoring_pb2 as _monitoring_pb2 from google.api import quota_pb2 as _quota_pb2 from google.api import source_info_pb2 as _source_info_pb2 from google.api import system_parameter_pb2 as _system_parameter_pb2 from google.api import usage_pb2 as _usage_pb2 DESCRIPTOR: _descriptor.FileDescriptor class Service(_message.Message): __slots__ = ( "name", "title", "producer_project_id", "id", "apis", "types", "enums", "documentation", "backend", "http", "quota", "authentication", "context", "usage", "endpoints", "control", "logs", "metrics", "monitored_resources", "billing", "logging", "monitoring", "system_parameters", "source_info", "publishing", "config_version", ) NAME_FIELD_NUMBER: _ClassVar[int] TITLE_FIELD_NUMBER: _ClassVar[int] PRODUCER_PROJECT_ID_FIELD_NUMBER: _ClassVar[int] ID_FIELD_NUMBER: _ClassVar[int] APIS_FIELD_NUMBER: _ClassVar[int] TYPES_FIELD_NUMBER: _ClassVar[int] ENUMS_FIELD_NUMBER: _ClassVar[int] DOCUMENTATION_FIELD_NUMBER: _ClassVar[int] BACKEND_FIELD_NUMBER: _ClassVar[int] HTTP_FIELD_NUMBER: _ClassVar[int] QUOTA_FIELD_NUMBER: _ClassVar[int] AUTHENTICATION_FIELD_NUMBER: _ClassVar[int] CONTEXT_FIELD_NUMBER: _ClassVar[int] USAGE_FIELD_NUMBER: _ClassVar[int] ENDPOINTS_FIELD_NUMBER: _ClassVar[int] CONTROL_FIELD_NUMBER: _ClassVar[int] LOGS_FIELD_NUMBER: _ClassVar[int] METRICS_FIELD_NUMBER: _ClassVar[int] MONITORED_RESOURCES_FIELD_NUMBER: _ClassVar[int] BILLING_FIELD_NUMBER: _ClassVar[int] LOGGING_FIELD_NUMBER: _ClassVar[int] MONITORING_FIELD_NUMBER: _ClassVar[int] SYSTEM_PARAMETERS_FIELD_NUMBER: _ClassVar[int] SOURCE_INFO_FIELD_NUMBER: _ClassVar[int] PUBLISHING_FIELD_NUMBER: _ClassVar[int] CONFIG_VERSION_FIELD_NUMBER: _ClassVar[int] name: str title: str producer_project_id: str id: str apis: _containers.RepeatedCompositeFieldContainer[_api_pb2.Api] types: _containers.RepeatedCompositeFieldContainer[_type_pb2.Type] enums: _containers.RepeatedCompositeFieldContainer[_type_pb2.Enum] documentation: _documentation_pb2.Documentation backend: _backend_pb2.Backend http: _http_pb2.Http quota: _quota_pb2.Quota authentication: _auth_pb2.Authentication context: _context_pb2.Context usage: _usage_pb2.Usage endpoints: _containers.RepeatedCompositeFieldContainer[_endpoint_pb2.Endpoint] control: _control_pb2.Control logs: _containers.RepeatedCompositeFieldContainer[_log_pb2.LogDescriptor] metrics: _containers.RepeatedCompositeFieldContainer[_metric_pb2.MetricDescriptor] monitored_resources: _containers.RepeatedCompositeFieldContainer[ _monitored_resource_pb2.MonitoredResourceDescriptor ] billing: _billing_pb2.Billing logging: _logging_pb2.Logging monitoring: _monitoring_pb2.Monitoring system_parameters: _system_parameter_pb2.SystemParameters source_info: _source_info_pb2.SourceInfo publishing: _client_pb2.Publishing config_version: _wrappers_pb2.UInt32Value def __init__( self, name: _Optional[str] = ..., title: _Optional[str] = ..., producer_project_id: _Optional[str] = ..., id: _Optional[str] = ..., apis: _Optional[_Iterable[_Union[_api_pb2.Api, _Mapping]]] = ..., types: _Optional[_Iterable[_Union[_type_pb2.Type, _Mapping]]] = ..., enums: _Optional[_Iterable[_Union[_type_pb2.Enum, _Mapping]]] = ..., documentation: _Optional[ _Union[_documentation_pb2.Documentation, _Mapping] ] = ..., backend: _Optional[_Union[_backend_pb2.Backend, _Mapping]] = ..., http: _Optional[_Union[_http_pb2.Http, _Mapping]] = ..., quota: _Optional[_Union[_quota_pb2.Quota, _Mapping]] = ..., authentication: _Optional[_Union[_auth_pb2.Authentication, _Mapping]] = ..., context: _Optional[_Union[_context_pb2.Context, _Mapping]] = ..., usage: _Optional[_Union[_usage_pb2.Usage, _Mapping]] = ..., endpoints: _Optional[_Iterable[_Union[_endpoint_pb2.Endpoint, _Mapping]]] = ..., control: _Optional[_Union[_control_pb2.Control, _Mapping]] = ..., logs: _Optional[_Iterable[_Union[_log_pb2.LogDescriptor, _Mapping]]] = ..., metrics: _Optional[ _Iterable[_Union[_metric_pb2.MetricDescriptor, _Mapping]] ] = ..., monitored_resources: _Optional[ _Iterable[ _Union[_monitored_resource_pb2.MonitoredResourceDescriptor, _Mapping] ] ] = ..., billing: _Optional[_Union[_billing_pb2.Billing, _Mapping]] = ..., logging: _Optional[_Union[_logging_pb2.Logging, _Mapping]] = ..., monitoring: _Optional[_Union[_monitoring_pb2.Monitoring, _Mapping]] = ..., system_parameters: _Optional[ _Union[_system_parameter_pb2.SystemParameters, _Mapping] ] = ..., source_info: _Optional[_Union[_source_info_pb2.SourceInfo, _Mapping]] = ..., publishing: _Optional[_Union[_client_pb2.Publishing, _Mapping]] = ..., config_version: _Optional[_Union[_wrappers_pb2.UInt32Value, _Mapping]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/source_info.proto0000644000000000000000000000210315177035224023100 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/any.proto"; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "SourceInfoProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Source information used to create a Service Config message SourceInfo { // All files used during config generation. repeated google.protobuf.Any source_files = 1; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/source_info_pb2.py0000644000000000000000000000415315177035225023140 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/source_info.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1cgoogle/api/source_info.proto\x12\ngoogle.api\x1a\x19google/protobuf/any.proto"8\n\nSourceInfo\x12*\n\x0csource_files\x18\x01 \x03(\x0b\x32\x14.google.protobuf.AnyBq\n\x0e\x63om.google.apiB\x0fSourceInfoProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.source_info_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\017SourceInfoProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_SOURCEINFO"]._serialized_start = 71 _globals["_SOURCEINFO"]._serialized_end = 127 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/api/source_info_pb2.pyi0000644000000000000000000000247715177035221023314 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import any_pb2 as _any_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class SourceInfo(_message.Message): __slots__ = ("source_files",) SOURCE_FILES_FIELD_NUMBER: _ClassVar[int] source_files: _containers.RepeatedCompositeFieldContainer[_any_pb2.Any] def __init__( self, source_files: _Optional[_Iterable[_Union[_any_pb2.Any, _Mapping]]] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/api/system_parameter.proto0000644000000000000000000000662315177035224024164 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "SystemParameterProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // ### System parameter configuration // // A system parameter is a special kind of parameter defined by the API // system, not by an individual API. It is typically mapped to an HTTP header // and/or a URL query parameter. This configuration specifies which methods // change the names of the system parameters. message SystemParameters { // Define system parameters. // // The parameters defined here will override the default parameters // implemented by the system. If this field is missing from the service // config, default system parameters will be used. Default system parameters // and names is implementation-dependent. // // Example: define api key for all methods // // system_parameters // rules: // - selector: "*" // parameters: // - name: api_key // url_query_parameter: api_key // // // Example: define 2 api key names for a specific method. // // system_parameters // rules: // - selector: "/ListShelves" // parameters: // - name: api_key // http_header: Api-Key1 // - name: api_key // http_header: Api-Key2 // // **NOTE:** All service configuration rules follow "last one wins" order. repeated SystemParameterRule rules = 1; } // Define a system parameter rule mapping system parameter definitions to // methods. message SystemParameterRule { // Selects the methods to which this rule applies. Use '*' to indicate all // methods in all APIs. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. string selector = 1; // Define parameters. Multiple names may be defined for a parameter. // For a given method call, only one of them should be used. If multiple // names are used the behavior is implementation-dependent. // If none of the specified names are present the behavior is // parameter-dependent. repeated SystemParameter parameters = 2; } // Define a parameter's name and location. The parameter may be passed as either // an HTTP header or a URL query parameter, and if both are passed the behavior // is implementation-dependent. message SystemParameter { // Define the name of the parameter, such as "api_key" . It is case sensitive. string name = 1; // Define the HTTP header name to use for the parameter. It is case // insensitive. string http_header = 2; // Define the URL query parameter name to use for the parameter. It is case // sensitive. string url_query_parameter = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/system_parameter_pb2.py0000644000000000000000000000506315177035226024213 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/system_parameter.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n!google/api/system_parameter.proto\x12\ngoogle.api"B\n\x10SystemParameters\x12.\n\x05rules\x18\x01 \x03(\x0b\x32\x1f.google.api.SystemParameterRule"X\n\x13SystemParameterRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12/\n\nparameters\x18\x02 \x03(\x0b\x32\x1b.google.api.SystemParameter"Q\n\x0fSystemParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0bhttp_header\x18\x02 \x01(\t\x12\x1b\n\x13url_query_parameter\x18\x03 \x01(\tBv\n\x0e\x63om.google.apiB\x14SystemParameterProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.system_parameter_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\024SystemParameterProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_SYSTEMPARAMETERS"]._serialized_start = 49 _globals["_SYSTEMPARAMETERS"]._serialized_end = 115 _globals["_SYSTEMPARAMETERRULE"]._serialized_start = 117 _globals["_SYSTEMPARAMETERRULE"]._serialized_end = 205 _globals["_SYSTEMPARAMETER"]._serialized_start = 207 _globals["_SYSTEMPARAMETER"]._serialized_end = 288 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/system_parameter_pb2.pyi0000644000000000000000000000425115177035222024356 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class SystemParameters(_message.Message): __slots__ = ("rules",) RULES_FIELD_NUMBER: _ClassVar[int] rules: _containers.RepeatedCompositeFieldContainer[SystemParameterRule] def __init__( self, rules: _Optional[_Iterable[_Union[SystemParameterRule, _Mapping]]] = ... ) -> None: ... class SystemParameterRule(_message.Message): __slots__ = ("selector", "parameters") SELECTOR_FIELD_NUMBER: _ClassVar[int] PARAMETERS_FIELD_NUMBER: _ClassVar[int] selector: str parameters: _containers.RepeatedCompositeFieldContainer[SystemParameter] def __init__( self, selector: _Optional[str] = ..., parameters: _Optional[_Iterable[_Union[SystemParameter, _Mapping]]] = ..., ) -> None: ... class SystemParameter(_message.Message): __slots__ = ("name", "http_header", "url_query_parameter") NAME_FIELD_NUMBER: _ClassVar[int] HTTP_HEADER_FIELD_NUMBER: _ClassVar[int] URL_QUERY_PARAMETER_FIELD_NUMBER: _ClassVar[int] name: str http_header: str url_query_parameter: str def __init__( self, name: _Optional[str] = ..., http_header: _Optional[str] = ..., url_query_parameter: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/usage.proto0000644000000000000000000000617615177035222021705 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; option go_package = "google.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig"; option java_multiple_files = true; option java_outer_classname = "UsageProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Configuration controlling usage of a service. message Usage { // Requirements that must be satisfied before a consumer project can use the // service. Each requirement is of the form /; // for example 'serviceusage.googleapis.com/billing-enabled'. // // For Google APIs, a Terms of Service requirement must be included here. // Google Cloud APIs must include "serviceusage.googleapis.com/tos/cloud". // Other Google APIs should include // "serviceusage.googleapis.com/tos/universal". Additional ToS can be // included based on the business needs. repeated string requirements = 1; // A list of usage rules that apply to individual API methods. // // **NOTE:** All service configuration rules follow "last one wins" order. repeated UsageRule rules = 6; // The full resource name of a channel used for sending notifications to the // service producer. // // Google Service Management currently only supports // [Google Cloud Pub/Sub](https://cloud.google.com/pubsub) as a notification // channel. To use Google Cloud Pub/Sub as the channel, this must be the name // of a Cloud Pub/Sub topic that uses the Cloud Pub/Sub topic name format // documented in https://cloud.google.com/pubsub/docs/overview. string producer_notification_channel = 7; } // Usage configuration rules for the service. message UsageRule { // Selects the methods to which this rule applies. Use '*' to indicate all // methods in all APIs. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. string selector = 1; // Use this rule to configure unregistered calls for the service. Unregistered // calls are calls that do not contain consumer project identity. // (Example: calls that do not contain an API key). // // WARNING: By default, API methods do not allow unregistered calls, and each // method call must be identified by a consumer project identity. bool allow_unregistered_calls = 2; // If true, the selected method should skip service control and the control // plane features, such as quota and billing, will not be available. // This flag is used by Google Cloud Endpoints to bypass checks for internal // methods, such as service health check methods. bool skip_service_control = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/api/usage_pb2.py0000644000000000000000000000446215177035226021735 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/usage.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x16google/api/usage.proto\x12\ngoogle.api"j\n\x05Usage\x12\x14\n\x0crequirements\x18\x01 \x03(\t\x12$\n\x05rules\x18\x06 \x03(\x0b\x32\x15.google.api.UsageRule\x12%\n\x1dproducer_notification_channel\x18\x07 \x01(\t"]\n\tUsageRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12 \n\x18\x61llow_unregistered_calls\x18\x02 \x01(\x08\x12\x1c\n\x14skip_service_control\x18\x03 \x01(\x08\x42l\n\x0e\x63om.google.apiB\nUsageProtoP\x01ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.api.usage_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\nUsageProtoP\001ZEgoogle.golang.org/genproto/googleapis/api/serviceconfig;serviceconfig\242\002\004GAPI" _globals["_USAGE"]._serialized_start = 38 _globals["_USAGE"]._serialized_end = 144 _globals["_USAGERULE"]._serialized_start = 146 _globals["_USAGERULE"]._serialized_end = 239 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/api/usage_pb2.pyi0000644000000000000000000000417715177035225022110 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Usage(_message.Message): __slots__ = ("requirements", "rules", "producer_notification_channel") REQUIREMENTS_FIELD_NUMBER: _ClassVar[int] RULES_FIELD_NUMBER: _ClassVar[int] PRODUCER_NOTIFICATION_CHANNEL_FIELD_NUMBER: _ClassVar[int] requirements: _containers.RepeatedScalarFieldContainer[str] rules: _containers.RepeatedCompositeFieldContainer[UsageRule] producer_notification_channel: str def __init__( self, requirements: _Optional[_Iterable[str]] = ..., rules: _Optional[_Iterable[_Union[UsageRule, _Mapping]]] = ..., producer_notification_channel: _Optional[str] = ..., ) -> None: ... class UsageRule(_message.Message): __slots__ = ("selector", "allow_unregistered_calls", "skip_service_control") SELECTOR_FIELD_NUMBER: _ClassVar[int] ALLOW_UNREGISTERED_CALLS_FIELD_NUMBER: _ClassVar[int] SKIP_SERVICE_CONTROL_FIELD_NUMBER: _ClassVar[int] selector: str allow_unregistered_calls: bool skip_service_control: bool def __init__( self, selector: _Optional[str] = ..., allow_unregistered_calls: bool = ..., skip_service_control: bool = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/visibility.proto0000644000000000000000000000726715177035222022772 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.api; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/api/visibility;visibility"; option java_multiple_files = true; option java_outer_classname = "VisibilityProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.EnumOptions { // See `VisibilityRule`. google.api.VisibilityRule enum_visibility = 72295727; } extend google.protobuf.EnumValueOptions { // See `VisibilityRule`. google.api.VisibilityRule value_visibility = 72295727; } extend google.protobuf.FieldOptions { // See `VisibilityRule`. google.api.VisibilityRule field_visibility = 72295727; } extend google.protobuf.MessageOptions { // See `VisibilityRule`. google.api.VisibilityRule message_visibility = 72295727; } extend google.protobuf.MethodOptions { // See `VisibilityRule`. google.api.VisibilityRule method_visibility = 72295727; } extend google.protobuf.ServiceOptions { // See `VisibilityRule`. google.api.VisibilityRule api_visibility = 72295727; } // `Visibility` restricts service consumer's access to service elements, // such as whether an application can call a visibility-restricted method. // The restriction is expressed by applying visibility labels on service // elements. The visibility labels are elsewhere linked to service consumers. // // A service can define multiple visibility labels, but a service consumer // should be granted at most one visibility label. Multiple visibility // labels for a single service consumer are not supported. // // If an element and all its parents have no visibility label, its visibility // is unconditionally granted. // // Example: // // visibility: // rules: // - selector: google.calendar.Calendar.EnhancedSearch // restriction: PREVIEW // - selector: google.calendar.Calendar.Delegate // restriction: INTERNAL // // Here, all methods are publicly visible except for the restricted methods // EnhancedSearch and Delegate. message Visibility { // A list of visibility rules that apply to individual API elements. // // **NOTE:** All service configuration rules follow "last one wins" order. repeated VisibilityRule rules = 1; } // A visibility rule provides visibility configuration for an individual API // element. message VisibilityRule { // Selects methods, messages, fields, enums, etc. to which this rule applies. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax // details. string selector = 1; // A comma-separated list of visibility labels that apply to the `selector`. // Any of the listed labels can be used to grant the visibility. // // If a rule has multiple labels, removing one of the labels but not all of // them can break clients. // // Example: // // visibility: // rules: // - selector: google.calendar.Calendar.EnhancedSearch // restriction: INTERNAL, PREVIEW // // Removing INTERNAL from this restriction will break clients that rely on // this method and only had access to it through INTERNAL. string restriction = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/api/visibility_pb2.py0000644000000000000000000000605215177035227023016 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/api/visibility.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1bgoogle/api/visibility.proto\x12\ngoogle.api\x1a google/protobuf/descriptor.proto"7\n\nVisibility\x12)\n\x05rules\x18\x01 \x03(\x0b\x32\x1a.google.api.VisibilityRule"7\n\x0eVisibilityRule\x12\x10\n\x08selector\x18\x01 \x01(\t\x12\x13\n\x0brestriction\x18\x02 \x01(\t:T\n\x0f\x65num_visibility\x12\x1c.google.protobuf.EnumOptions\x18\xaf\xca\xbc" \x01(\x0b\x32\x1a.google.api.VisibilityRule:Z\n\x10value_visibility\x12!.google.protobuf.EnumValueOptions\x18\xaf\xca\xbc" \x01(\x0b\x32\x1a.google.api.VisibilityRule:V\n\x10\x66ield_visibility\x12\x1d.google.protobuf.FieldOptions\x18\xaf\xca\xbc" \x01(\x0b\x32\x1a.google.api.VisibilityRule:Z\n\x12message_visibility\x12\x1f.google.protobuf.MessageOptions\x18\xaf\xca\xbc" \x01(\x0b\x32\x1a.google.api.VisibilityRule:X\n\x11method_visibility\x12\x1e.google.protobuf.MethodOptions\x18\xaf\xca\xbc" \x01(\x0b\x32\x1a.google.api.VisibilityRule:V\n\x0e\x61pi_visibility\x12\x1f.google.protobuf.ServiceOptions\x18\xaf\xca\xbc" \x01(\x0b\x32\x1a.google.api.VisibilityRuleBk\n\x0e\x63om.google.apiB\x0fVisibilityProtoP\x01Z?google.golang.org/genproto/googleapis/api/visibility;visibility\xa2\x02\x04GAPIb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.api.visibility_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.apiB\017VisibilityProtoP\001Z?google.golang.org/genproto/googleapis/api/visibility;visibility\242\002\004GAPI" _globals["_VISIBILITY"]._serialized_start = 77 _globals["_VISIBILITY"]._serialized_end = 132 _globals["_VISIBILITYRULE"]._serialized_start = 134 _globals["_VISIBILITYRULE"]._serialized_end = 189 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/api/visibility_pb2.pyi0000644000000000000000000000424515177035222023164 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor ENUM_VISIBILITY_FIELD_NUMBER: _ClassVar[int] enum_visibility: _descriptor.FieldDescriptor VALUE_VISIBILITY_FIELD_NUMBER: _ClassVar[int] value_visibility: _descriptor.FieldDescriptor FIELD_VISIBILITY_FIELD_NUMBER: _ClassVar[int] field_visibility: _descriptor.FieldDescriptor MESSAGE_VISIBILITY_FIELD_NUMBER: _ClassVar[int] message_visibility: _descriptor.FieldDescriptor METHOD_VISIBILITY_FIELD_NUMBER: _ClassVar[int] method_visibility: _descriptor.FieldDescriptor API_VISIBILITY_FIELD_NUMBER: _ClassVar[int] api_visibility: _descriptor.FieldDescriptor class Visibility(_message.Message): __slots__ = ("rules",) RULES_FIELD_NUMBER: _ClassVar[int] rules: _containers.RepeatedCompositeFieldContainer[VisibilityRule] def __init__( self, rules: _Optional[_Iterable[_Union[VisibilityRule, _Mapping]]] = ... ) -> None: ... class VisibilityRule(_message.Message): __slots__ = ("selector", "restriction") SELECTOR_FIELD_NUMBER: _ClassVar[int] RESTRICTION_FIELD_NUMBER: _ClassVar[int] selector: str restriction: str def __init__( self, selector: _Optional[str] = ..., restriction: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0632596 googleapis_common_protos-1.75.0/google/cloud/0000755000000000000000000000000015177036143020042 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/cloud/common_resources.proto0000644000000000000000000000305215177035224024510 0ustar00rootroot// Copyright 2025 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. // This file contains stub messages for common resources in GCP. // It is not intended to be directly generated, and is instead used by // other tooling to be able to match common resource patterns. syntax = "proto3"; package google.cloud; import "google/api/resource.proto"; option (google.api.resource_definition) = { type: "cloudresourcemanager.googleapis.com/Project" pattern: "projects/{project}" }; option (google.api.resource_definition) = { type: "cloudresourcemanager.googleapis.com/Organization" pattern: "organizations/{organization}" }; option (google.api.resource_definition) = { type: "cloudresourcemanager.googleapis.com/Folder" pattern: "folders/{folder}" }; option (google.api.resource_definition) = { type: "cloudbilling.googleapis.com/BillingAccount" pattern: "billingAccounts/{billing_account}" }; option (google.api.resource_definition) = { type: "locations.googleapis.com/Location" pattern: "projects/{project}/locations/{location}" }; ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/cloud/common_resources_pb2.py0000644000000000000000000000504215177035222024537 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/cloud/common_resources.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.api import resource_pb2 as google_dot_api_dot_resource__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n#google/cloud/common_resources.proto\x12\x0cgoogle.cloud\x1a\x19google/api/resource.protoB\xf9\x02\xea\x41\x41\n+cloudresourcemanager.googleapis.com/Project\x12\x12projects/{project}\xea\x41P\n0cloudresourcemanager.googleapis.com/Organization\x12\x1corganizations/{organization}\xea\x41>\n*cloudresourcemanager.googleapis.com/Folder\x12\x10\x66olders/{folder}\xea\x41O\n*cloudbilling.googleapis.com/BillingAccount\x12!billingAccounts/{billing_account}\xea\x41L\n!locations.googleapis.com/Location\x12'projects/{project}/locations/{location}b\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.cloud.common_resources_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\352AA\n+cloudresourcemanager.googleapis.com/Project\022\022projects/{project}\352AP\n0cloudresourcemanager.googleapis.com/Organization\022\034organizations/{organization}\352A>\n*cloudresourcemanager.googleapis.com/Folder\022\020folders/{folder}\352AO\n*cloudbilling.googleapis.com/BillingAccount\022!billingAccounts/{billing_account}\352AL\n!locations.googleapis.com/Location\022'projects/{project}/locations/{location}" # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/cloud/common_resources_pb2.pyi0000644000000000000000000000137515177035224024717 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.api import resource_pb2 as _resource_pb2 DESCRIPTOR: _descriptor.FileDescriptor ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/cloud/extended_operations.proto0000644000000000000000000001424315177035222025173 0ustar00rootroot// Copyright 2025 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. // This file contains custom annotations that are used by GAPIC generators to // handle Long Running Operation methods (LRO) that are NOT compliant with // https://google.aip.dev/151. These annotations are public for technical // reasons only. Please DO NOT USE them in your protos. syntax = "proto3"; package google.cloud; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/cloud/extendedops;extendedops"; option java_multiple_files = true; option java_outer_classname = "ExtendedOperationsProto"; option java_package = "com.google.cloud"; option objc_class_prefix = "GAPI"; // FieldOptions to match corresponding fields in the initial request, // polling request and operation response messages. // // Example: // // In an API-specific operation message: // // message MyOperation { // string http_error_message = 1 [(operation_field) = ERROR_MESSAGE]; // int32 http_error_status_code = 2 [(operation_field) = ERROR_CODE]; // string id = 3 [(operation_field) = NAME]; // Status status = 4 [(operation_field) = STATUS]; // } // // In a polling request message (the one which is used to poll for an LRO // status): // // message MyPollingRequest { // string operation = 1 [(operation_response_field) = "id"]; // string project = 2; // string region = 3; // } // // In an initial request message (the one which starts an LRO): // // message MyInitialRequest { // string my_project = 2 [(operation_request_field) = "project"]; // string my_region = 3 [(operation_request_field) = "region"]; // } // extend google.protobuf.FieldOptions { // A field annotation that maps fields in an API-specific Operation object to // their standard counterparts in google.longrunning.Operation. See // OperationResponseMapping enum definition. OperationResponseMapping operation_field = 1149; // A field annotation that maps fields in the initial request message // (the one which started the LRO) to their counterparts in the polling // request message. For non-standard LRO, the polling response may be missing // some of the information needed to make a subsequent polling request. The // missing information (for example, project or region ID) is contained in the // fields of the initial request message that this annotation must be applied // to. The string value of the annotation corresponds to the name of the // counterpart field in the polling request message that the annotated field's // value will be copied to. string operation_request_field = 1150; // A field annotation that maps fields in the polling request message to their // counterparts in the initial and/or polling response message. The initial // and the polling methods return an API-specific Operation object. Some of // the fields from that response object must be reused in the subsequent // request (like operation name/ID) to fully identify the polled operation. // This annotation must be applied to the fields in the polling request // message, the string value of the annotation must correspond to the name of // the counterpart field in the Operation response object whose value will be // copied to the annotated field. string operation_response_field = 1151; } // MethodOptions to identify the actual service and method used for operation // status polling. // // Example: // // In a method, which starts an LRO: // // service MyService { // rpc Foo(MyInitialRequest) returns (MyOperation) { // option (operation_service) = "MyPollingService"; // } // } // // In a polling method: // // service MyPollingService { // rpc Get(MyPollingRequest) returns (MyOperation) { // option (operation_polling_method) = true; // } // } extend google.protobuf.MethodOptions { // A method annotation that maps an LRO method (the one which starts an LRO) // to the service, which will be used to poll for the operation status. The // annotation must be applied to the method which starts an LRO, the string // value of the annotation must correspond to the name of the service used to // poll for the operation status. string operation_service = 1249; // A method annotation that marks methods that can be used for polling // operation status (e.g. the MyPollingService.Get(MyPollingRequest) method). bool operation_polling_method = 1250; } // An enum to be used to mark the essential (for polling) fields in an // API-specific Operation object. A custom Operation object may contain many // different fields, but only few of them are essential to conduct a successful // polling process. enum OperationResponseMapping { // Do not use. UNDEFINED = 0; // A field in an API-specific (custom) Operation object which carries the same // meaning as google.longrunning.Operation.name. NAME = 1; // A field in an API-specific (custom) Operation object which carries the same // meaning as google.longrunning.Operation.done. If the annotated field is of // an enum type, `annotated_field_name == EnumType.DONE` semantics should be // equivalent to `Operation.done == true`. If the annotated field is of type // boolean, then it should follow the same semantics as Operation.done. // Otherwise, a non-empty value should be treated as `Operation.done == true`. STATUS = 2; // A field in an API-specific (custom) Operation object which carries the same // meaning as google.longrunning.Operation.error.code. ERROR_CODE = 3; // A field in an API-specific (custom) Operation object which carries the same // meaning as google.longrunning.Operation.error.message. ERROR_MESSAGE = 4; }././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/cloud/extended_operations_pb2.py0000644000000000000000000000540015177035223025217 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/cloud/extended_operations.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n&google/cloud/extended_operations.proto\x12\x0cgoogle.cloud\x1a google/protobuf/descriptor.proto*b\n\x18OperationResponseMapping\x12\r\n\tUNDEFINED\x10\x00\x12\x08\n\x04NAME\x10\x01\x12\n\n\x06STATUS\x10\x02\x12\x0e\n\nERROR_CODE\x10\x03\x12\x11\n\rERROR_MESSAGE\x10\x04:_\n\x0foperation_field\x12\x1d.google.protobuf.FieldOptions\x18\xfd\x08 \x01(\x0e\x32&.google.cloud.OperationResponseMapping:?\n\x17operation_request_field\x12\x1d.google.protobuf.FieldOptions\x18\xfe\x08 \x01(\t:@\n\x18operation_response_field\x12\x1d.google.protobuf.FieldOptions\x18\xff\x08 \x01(\t::\n\x11operation_service\x12\x1e.google.protobuf.MethodOptions\x18\xe1\t \x01(\t:A\n\x18operation_polling_method\x12\x1e.google.protobuf.MethodOptions\x18\xe2\t \x01(\x08\x42y\n\x10\x63om.google.cloudB\x17\x45xtendedOperationsProtoP\x01ZCgoogle.golang.org/genproto/googleapis/cloud/extendedops;extendedops\xa2\x02\x04GAPIb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.cloud.extended_operations_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\020com.google.cloudB\027ExtendedOperationsProtoP\001ZCgoogle.golang.org/genproto/googleapis/cloud/extendedops;extendedops\242\002\004GAPI" _globals["_OPERATIONRESPONSEMAPPING"]._serialized_start = 90 _globals["_OPERATIONRESPONSEMAPPING"]._serialized_end = 188 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/cloud/extended_operations_pb2.pyi0000644000000000000000000000354115177035225025376 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class OperationResponseMapping(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () UNDEFINED: _ClassVar[OperationResponseMapping] NAME: _ClassVar[OperationResponseMapping] STATUS: _ClassVar[OperationResponseMapping] ERROR_CODE: _ClassVar[OperationResponseMapping] ERROR_MESSAGE: _ClassVar[OperationResponseMapping] UNDEFINED: OperationResponseMapping NAME: OperationResponseMapping STATUS: OperationResponseMapping ERROR_CODE: OperationResponseMapping ERROR_MESSAGE: OperationResponseMapping OPERATION_FIELD_FIELD_NUMBER: _ClassVar[int] operation_field: _descriptor.FieldDescriptor OPERATION_REQUEST_FIELD_FIELD_NUMBER: _ClassVar[int] operation_request_field: _descriptor.FieldDescriptor OPERATION_RESPONSE_FIELD_FIELD_NUMBER: _ClassVar[int] operation_response_field: _descriptor.FieldDescriptor OPERATION_SERVICE_FIELD_NUMBER: _ClassVar[int] operation_service: _descriptor.FieldDescriptor OPERATION_POLLING_METHOD_FIELD_NUMBER: _ClassVar[int] operation_polling_method: _descriptor.FieldDescriptor ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0637348 googleapis_common_protos-1.75.0/google/cloud/location/0000755000000000000000000000000015177036143021652 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/cloud/location/locations.proto0000644000000000000000000000702415177035223024733 0ustar00rootroot// Copyright 2025 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. syntax = "proto3"; package google.cloud.location; import "google/api/annotations.proto"; import "google/protobuf/any.proto"; import "google/api/client.proto"; option cc_enable_arenas = true; option go_package = "google.golang.org/genproto/googleapis/cloud/location;location"; option java_multiple_files = true; option java_outer_classname = "LocationsProto"; option java_package = "com.google.cloud.location"; // An abstract interface that provides location-related information for // a service. Service-specific metadata is provided through the // [Location.metadata][google.cloud.location.Location.metadata] field. service Locations { option (google.api.default_host) = "cloud.googleapis.com"; option (google.api.oauth_scopes) = "https://www.googleapis.com/auth/cloud-platform"; // Lists information about the supported locations for this service. rpc ListLocations(ListLocationsRequest) returns (ListLocationsResponse) { option (google.api.http) = { get: "/v1/{name=locations}" additional_bindings { get: "/v1/{name=projects/*}/locations" } }; } // Gets information about a location. rpc GetLocation(GetLocationRequest) returns (Location) { option (google.api.http) = { get: "/v1/{name=locations/*}" additional_bindings { get: "/v1/{name=projects/*/locations/*}" } }; } } // The request message for [Locations.ListLocations][google.cloud.location.Locations.ListLocations]. message ListLocationsRequest { // The resource that owns the locations collection, if applicable. string name = 1; // The standard list filter. string filter = 2; // The standard list page size. int32 page_size = 3; // The standard list page token. string page_token = 4; } // The response message for [Locations.ListLocations][google.cloud.location.Locations.ListLocations]. message ListLocationsResponse { // A list of locations that matches the specified filter in the request. repeated Location locations = 1; // The standard List next-page token. string next_page_token = 2; } // The request message for [Locations.GetLocation][google.cloud.location.Locations.GetLocation]. message GetLocationRequest { // Resource name for the location. string name = 1; } // A resource that represents Google Cloud Platform location. message Location { // Resource name for the location, which may vary between implementations. // For example: `"projects/example-project/locations/us-east1"` string name = 1; // The canonical id for this location. For example: `"us-east1"`. string location_id = 4; // The friendly name for this location, typically a nearby city name. // For example, "Tokyo". string display_name = 5; // Cross-service attributes for the location. For example // // {"cloud.googleapis.com/region": "us-east1"} map labels = 2; // Service-specific metadata. For example the available capacity at the given // location. google.protobuf.Any metadata = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/cloud/location/locations_pb2.py0000644000000000000000000001172515177035225024770 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/cloud/location/locations.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 from google.api import client_pb2 as google_dot_api_dot_client__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n%google/cloud/location/locations.proto\x12\x15google.cloud.location\x1a\x1cgoogle/api/annotations.proto\x1a\x19google/protobuf/any.proto\x1a\x17google/api/client.proto"[\n\x14ListLocationsRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x02 \x01(\t\x12\x11\n\tpage_size\x18\x03 \x01(\x05\x12\x12\n\npage_token\x18\x04 \x01(\t"d\n\x15ListLocationsResponse\x12\x32\n\tlocations\x18\x01 \x03(\x0b\x32\x1f.google.cloud.location.Location\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t""\n\x12GetLocationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t"\xd7\x01\n\x08Location\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0blocation_id\x18\x04 \x01(\t\x12\x14\n\x0c\x64isplay_name\x18\x05 \x01(\t\x12;\n\x06labels\x18\x02 \x03(\x0b\x32+.google.cloud.location.Location.LabelsEntry\x12&\n\x08metadata\x18\x03 \x01(\x0b\x32\x14.google.protobuf.Any\x1a-\n\x0bLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x32\xa4\x03\n\tLocations\x12\xab\x01\n\rListLocations\x12+.google.cloud.location.ListLocationsRequest\x1a,.google.cloud.location.ListLocationsResponse"?\x82\xd3\xe4\x93\x02\x39\x12\x14/v1/{name=locations}Z!\x12\x1f/v1/{name=projects/*}/locations\x12\x9e\x01\n\x0bGetLocation\x12).google.cloud.location.GetLocationRequest\x1a\x1f.google.cloud.location.Location"C\x82\xd3\xe4\x93\x02=\x12\x16/v1/{name=locations/*}Z#\x12!/v1/{name=projects/*/locations/*}\x1aH\xca\x41\x14\x63loud.googleapis.com\xd2\x41.https://www.googleapis.com/auth/cloud-platformBo\n\x19\x63om.google.cloud.locationB\x0eLocationsProtoP\x01Z=google.golang.org/genproto/googleapis/cloud/location;location\xf8\x01\x01\x62\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.cloud.location.locations_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\031com.google.cloud.locationB\016LocationsProtoP\001Z=google.golang.org/genproto/googleapis/cloud/location;location\370\001\001" _globals["_LOCATION_LABELSENTRY"]._options = None _globals["_LOCATION_LABELSENTRY"]._serialized_options = b"8\001" _globals["_LOCATIONS"]._options = None _globals[ "_LOCATIONS" ]._serialized_options = b"\312A\024cloud.googleapis.com\322A.https://www.googleapis.com/auth/cloud-platform" _globals["_LOCATIONS"].methods_by_name["ListLocations"]._options = None _globals["_LOCATIONS"].methods_by_name[ "ListLocations" ]._serialized_options = b"\202\323\344\223\0029\022\024/v1/{name=locations}Z!\022\037/v1/{name=projects/*}/locations" _globals["_LOCATIONS"].methods_by_name["GetLocation"]._options = None _globals["_LOCATIONS"].methods_by_name[ "GetLocation" ]._serialized_options = b"\202\323\344\223\002=\022\026/v1/{name=locations/*}Z#\022!/v1/{name=projects/*/locations/*}" _globals["_LISTLOCATIONSREQUEST"]._serialized_start = 146 _globals["_LISTLOCATIONSREQUEST"]._serialized_end = 237 _globals["_LISTLOCATIONSRESPONSE"]._serialized_start = 239 _globals["_LISTLOCATIONSRESPONSE"]._serialized_end = 339 _globals["_GETLOCATIONREQUEST"]._serialized_start = 341 _globals["_GETLOCATIONREQUEST"]._serialized_end = 375 _globals["_LOCATION"]._serialized_start = 378 _globals["_LOCATION"]._serialized_end = 593 _globals["_LOCATION_LABELSENTRY"]._serialized_start = 548 _globals["_LOCATION_LABELSENTRY"]._serialized_end = 593 _globals["_LOCATIONS"]._serialized_start = 596 _globals["_LOCATIONS"]._serialized_end = 1016 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/cloud/location/locations_pb2.pyi0000644000000000000000000000650015177035226025135 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import any_pb2 as _any_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.api import annotations_pb2 as _annotations_pb2 from google.api import client_pb2 as _client_pb2 DESCRIPTOR: _descriptor.FileDescriptor class ListLocationsRequest(_message.Message): __slots__ = ("name", "filter", "page_size", "page_token") NAME_FIELD_NUMBER: _ClassVar[int] FILTER_FIELD_NUMBER: _ClassVar[int] PAGE_SIZE_FIELD_NUMBER: _ClassVar[int] PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int] name: str filter: str page_size: int page_token: str def __init__( self, name: _Optional[str] = ..., filter: _Optional[str] = ..., page_size: _Optional[int] = ..., page_token: _Optional[str] = ..., ) -> None: ... class ListLocationsResponse(_message.Message): __slots__ = ("locations", "next_page_token") LOCATIONS_FIELD_NUMBER: _ClassVar[int] NEXT_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int] locations: _containers.RepeatedCompositeFieldContainer[Location] next_page_token: str def __init__( self, locations: _Optional[_Iterable[_Union[Location, _Mapping]]] = ..., next_page_token: _Optional[str] = ..., ) -> None: ... class GetLocationRequest(_message.Message): __slots__ = ("name",) NAME_FIELD_NUMBER: _ClassVar[int] name: str def __init__(self, name: _Optional[str] = ...) -> None: ... class Location(_message.Message): __slots__ = ("name", "location_id", "display_name", "labels", "metadata") class LabelsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... NAME_FIELD_NUMBER: _ClassVar[int] LOCATION_ID_FIELD_NUMBER: _ClassVar[int] DISPLAY_NAME_FIELD_NUMBER: _ClassVar[int] LABELS_FIELD_NUMBER: _ClassVar[int] METADATA_FIELD_NUMBER: _ClassVar[int] name: str location_id: str display_name: str labels: _containers.ScalarMap[str, str] metadata: _any_pb2.Any def __init__( self, name: _Optional[str] = ..., location_id: _Optional[str] = ..., display_name: _Optional[str] = ..., labels: _Optional[_Mapping[str, str]] = ..., metadata: _Optional[_Union[_any_pb2.Any, _Mapping]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0443504 googleapis_common_protos-1.75.0/google/gapic/0000755000000000000000000000000015177036143020017 5ustar00rootroot././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0641906 googleapis_common_protos-1.75.0/google/gapic/metadata/0000755000000000000000000000000015177036143021577 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/gapic/metadata/gapic_metadata.proto0000644000000000000000000000733515177035226025620 0ustar00rootroot// Copyright 2020 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. // syntax = "proto3"; package google.gapic.metadata; option csharp_namespace = "Google.Gapic.Metadata"; option go_package = "google.golang.org/genproto/googleapis/gapic/metadata;metadata"; option java_multiple_files = true; option java_outer_classname = "GapicMetadataProto"; option java_package = "com.google.gapic.metadata"; option php_namespace = "Google\\Gapic\\Metadata"; option ruby_package = "Google::Gapic::Metadata"; // Metadata about a GAPIC library service for a specific combination of API, // version, and computer language. message GapicMetadata { // Schema version of this proto. Current value: 1.0 string schema = 1; // Any human-readable comments to be included in this file. string comment = 2; // Computer language of this generated language. This must be // spelled out as it spoken in English, with no capitalization or // separators (e.g. "csharp", "nodejs"). string language = 3; // The proto package containing the API definition for which this // GAPIC library was generated. string proto_package = 4; // The language-specific library package for this GAPIC library. string library_package = 5; // A map from each proto-defined service to ServiceForTransports, // which allows listing information about transport-specific // implementations of the service. // // The key is the name of the service as it appears in the .proto // file. map services = 6; // A map from a transport name to ServiceAsClient, which allows // listing information about the client objects that implement the // parent RPC service for the specified transport. message ServiceForTransport { // Map of transport name to ServiceAsClient. The key name is the transport, // lower-cased with no separators (e.g. "grpc", "rest"). map clients = 1; // The API version for the interface definition found in the // `google.api.api_version` annotation of this proto-defined service during // code generation. // This is the value populated by the client in the API version request // parameter as per // [AIP-4236](https://google.aip.dev/client-libraries/4236). string api_version = 2; } // Information about a specific client implementing a proto-defined service. message ServiceAsClient { // The name of the library client formatted as it appears in the source code string library_client = 1; // A mapping from each proto-defined RPC name to the the list of // methods in library_client that implement it. There can be more // than one library_client method for each RPC. RPCs with no // library_client methods need not be included. // // The key name is the name of the RPC as defined and formatted in // the proto file. map rpcs = 2; } // List of GAPIC client methods implementing the proto-defined RPC // for the transport and service specified in the containing // structures. message MethodList { // List of methods for a specific proto-service client in the // GAPIC. These names should be formatted as they appear in the // source code. repeated string methods = 1; } } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/gapic/metadata/gapic_metadata_pb2.py0000644000000000000000000001134415177035222025637 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/gapic/metadata/gapic_metadata.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n*google/gapic/metadata/gapic_metadata.proto\x12\x15google.gapic.metadata"\x85\x06\n\rGapicMetadata\x12\x0e\n\x06schema\x18\x01 \x01(\t\x12\x0f\n\x07\x63omment\x18\x02 \x01(\t\x12\x10\n\x08language\x18\x03 \x01(\t\x12\x15\n\rproto_package\x18\x04 \x01(\t\x12\x17\n\x0flibrary_package\x18\x05 \x01(\t\x12\x44\n\x08services\x18\x06 \x03(\x0b\x32\x32.google.gapic.metadata.GapicMetadata.ServicesEntry\x1ai\n\rServicesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12G\n\x05value\x18\x02 \x01(\x0b\x32\x38.google.gapic.metadata.GapicMetadata.ServiceForTransport:\x02\x38\x01\x1a\xe8\x01\n\x13ServiceForTransport\x12V\n\x07\x63lients\x18\x01 \x03(\x0b\x32\x45.google.gapic.metadata.GapicMetadata.ServiceForTransport.ClientsEntry\x12\x13\n\x0b\x61pi_version\x18\x02 \x01(\t\x1a\x64\n\x0c\x43lientsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x43\n\x05value\x18\x02 \x01(\x0b\x32\x34.google.gapic.metadata.GapicMetadata.ServiceAsClient:\x02\x38\x01\x1a\xd5\x01\n\x0fServiceAsClient\x12\x16\n\x0elibrary_client\x18\x01 \x01(\t\x12L\n\x04rpcs\x18\x02 \x03(\x0b\x32>.google.gapic.metadata.GapicMetadata.ServiceAsClient.RpcsEntry\x1a\\\n\tRpcsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12>\n\x05value\x18\x02 \x01(\x0b\x32/.google.gapic.metadata.GapicMetadata.MethodList:\x02\x38\x01\x1a\x1d\n\nMethodList\x12\x0f\n\x07methods\x18\x01 \x03(\tB\xba\x01\n\x19\x63om.google.gapic.metadataB\x12GapicMetadataProtoP\x01Z=google.golang.org/genproto/googleapis/gapic/metadata;metadata\xaa\x02\x15Google.Gapic.Metadata\xca\x02\x15Google\\Gapic\\Metadata\xea\x02\x17Google::Gapic::Metadatab\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.gapic.metadata.gapic_metadata_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\031com.google.gapic.metadataB\022GapicMetadataProtoP\001Z=google.golang.org/genproto/googleapis/gapic/metadata;metadata\252\002\025Google.Gapic.Metadata\312\002\025Google\\Gapic\\Metadata\352\002\027Google::Gapic::Metadata" _globals["_GAPICMETADATA_SERVICESENTRY"]._options = None _globals["_GAPICMETADATA_SERVICESENTRY"]._serialized_options = b"8\001" _globals["_GAPICMETADATA_SERVICEFORTRANSPORT_CLIENTSENTRY"]._options = None _globals[ "_GAPICMETADATA_SERVICEFORTRANSPORT_CLIENTSENTRY" ]._serialized_options = b"8\001" _globals["_GAPICMETADATA_SERVICEASCLIENT_RPCSENTRY"]._options = None _globals["_GAPICMETADATA_SERVICEASCLIENT_RPCSENTRY"]._serialized_options = b"8\001" _globals["_GAPICMETADATA"]._serialized_start = 70 _globals["_GAPICMETADATA"]._serialized_end = 843 _globals["_GAPICMETADATA_SERVICESENTRY"]._serialized_start = 256 _globals["_GAPICMETADATA_SERVICESENTRY"]._serialized_end = 361 _globals["_GAPICMETADATA_SERVICEFORTRANSPORT"]._serialized_start = 364 _globals["_GAPICMETADATA_SERVICEFORTRANSPORT"]._serialized_end = 596 _globals["_GAPICMETADATA_SERVICEFORTRANSPORT_CLIENTSENTRY"]._serialized_start = 496 _globals["_GAPICMETADATA_SERVICEFORTRANSPORT_CLIENTSENTRY"]._serialized_end = 596 _globals["_GAPICMETADATA_SERVICEASCLIENT"]._serialized_start = 599 _globals["_GAPICMETADATA_SERVICEASCLIENT"]._serialized_end = 812 _globals["_GAPICMETADATA_SERVICEASCLIENT_RPCSENTRY"]._serialized_start = 720 _globals["_GAPICMETADATA_SERVICEASCLIENT_RPCSENTRY"]._serialized_end = 812 _globals["_GAPICMETADATA_METHODLIST"]._serialized_start = 814 _globals["_GAPICMETADATA_METHODLIST"]._serialized_end = 843 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/gapic/metadata/gapic_metadata_pb2.pyi0000644000000000000000000001062515177035225026014 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class GapicMetadata(_message.Message): __slots__ = ( "schema", "comment", "language", "proto_package", "library_package", "services", ) class ServicesEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: GapicMetadata.ServiceForTransport def __init__( self, key: _Optional[str] = ..., value: _Optional[_Union[GapicMetadata.ServiceForTransport, _Mapping]] = ..., ) -> None: ... class ServiceForTransport(_message.Message): __slots__ = ("clients", "api_version") class ClientsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: GapicMetadata.ServiceAsClient def __init__( self, key: _Optional[str] = ..., value: _Optional[_Union[GapicMetadata.ServiceAsClient, _Mapping]] = ..., ) -> None: ... CLIENTS_FIELD_NUMBER: _ClassVar[int] API_VERSION_FIELD_NUMBER: _ClassVar[int] clients: _containers.MessageMap[str, GapicMetadata.ServiceAsClient] api_version: str def __init__( self, clients: _Optional[_Mapping[str, GapicMetadata.ServiceAsClient]] = ..., api_version: _Optional[str] = ..., ) -> None: ... class ServiceAsClient(_message.Message): __slots__ = ("library_client", "rpcs") class RpcsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: GapicMetadata.MethodList def __init__( self, key: _Optional[str] = ..., value: _Optional[_Union[GapicMetadata.MethodList, _Mapping]] = ..., ) -> None: ... LIBRARY_CLIENT_FIELD_NUMBER: _ClassVar[int] RPCS_FIELD_NUMBER: _ClassVar[int] library_client: str rpcs: _containers.MessageMap[str, GapicMetadata.MethodList] def __init__( self, library_client: _Optional[str] = ..., rpcs: _Optional[_Mapping[str, GapicMetadata.MethodList]] = ..., ) -> None: ... class MethodList(_message.Message): __slots__ = ("methods",) METHODS_FIELD_NUMBER: _ClassVar[int] methods: _containers.RepeatedScalarFieldContainer[str] def __init__(self, methods: _Optional[_Iterable[str]] = ...) -> None: ... SCHEMA_FIELD_NUMBER: _ClassVar[int] COMMENT_FIELD_NUMBER: _ClassVar[int] LANGUAGE_FIELD_NUMBER: _ClassVar[int] PROTO_PACKAGE_FIELD_NUMBER: _ClassVar[int] LIBRARY_PACKAGE_FIELD_NUMBER: _ClassVar[int] SERVICES_FIELD_NUMBER: _ClassVar[int] schema: str comment: str language: str proto_package: str library_package: str services: _containers.MessageMap[str, GapicMetadata.ServiceForTransport] def __init__( self, schema: _Optional[str] = ..., comment: _Optional[str] = ..., language: _Optional[str] = ..., proto_package: _Optional[str] = ..., library_package: _Optional[str] = ..., services: _Optional[_Mapping[str, GapicMetadata.ServiceForTransport]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0443504 googleapis_common_protos-1.75.0/google/logging/0000755000000000000000000000000015177036143020362 5ustar00rootroot././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0651479 googleapis_common_protos-1.75.0/google/logging/type/0000755000000000000000000000000015177036143021343 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/logging/type/http_request.proto0000644000000000000000000000702115177035221025153 0ustar00rootroot// Copyright 2025 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. syntax = "proto3"; package google.logging.type; import "google/protobuf/duration.proto"; option csharp_namespace = "Google.Cloud.Logging.Type"; option go_package = "google.golang.org/genproto/googleapis/logging/type;ltype"; option java_multiple_files = true; option java_outer_classname = "HttpRequestProto"; option java_package = "com.google.logging.type"; option php_namespace = "Google\\Cloud\\Logging\\Type"; option ruby_package = "Google::Cloud::Logging::Type"; // A common proto for logging HTTP requests. Only contains semantics // defined by the HTTP specification. Product-specific logging // information MUST be defined in a separate message. message HttpRequest { // The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`. string request_method = 1; // The scheme (http, https), the host name, the path and the query // portion of the URL that was requested. // Example: `"http://example.com/some/info?color=red"`. string request_url = 2; // The size of the HTTP request message in bytes, including the request // headers and the request body. int64 request_size = 3; // The response code indicating the status of response. // Examples: 200, 404. int32 status = 4; // The size of the HTTP response message sent back to the client, in bytes, // including the response headers and the response body. int64 response_size = 5; // The user agent sent by the client. Example: // `"Mozilla/4.0 (compatible; MSIE 6.0; Windows 98; Q312461; .NET // CLR 1.0.3705)"`. string user_agent = 6; // The IP address (IPv4 or IPv6) of the client that issued the HTTP // request. This field can include port information. Examples: // `"192.168.1.1"`, `"10.0.0.1:80"`, `"FE80::0202:B3FF:FE1E:8329"`. string remote_ip = 7; // The IP address (IPv4 or IPv6) of the origin server that the request was // sent to. This field can include port information. Examples: // `"192.168.1.1"`, `"10.0.0.1:80"`, `"FE80::0202:B3FF:FE1E:8329"`. string server_ip = 13; // The referer URL of the request, as defined in // [HTTP/1.1 Header Field // Definitions](https://datatracker.ietf.org/doc/html/rfc2616#section-14.36). string referer = 8; // The request processing latency on the server, from the time the request was // received until the response was sent. google.protobuf.Duration latency = 14; // Whether or not a cache lookup was attempted. bool cache_lookup = 11; // Whether or not an entity was served from cache // (with or without validation). bool cache_hit = 9; // Whether or not the response was validated with the origin server before // being served from cache. This field is only meaningful if `cache_hit` is // True. bool cache_validated_with_origin_server = 10; // The number of HTTP response bytes inserted into cache. Set only when a // cache fill was attempted. int64 cache_fill_bytes = 12; // Protocol used for the request. Examples: "HTTP/1.1", "HTTP/2", "websocket" string protocol = 15; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/logging/type/http_request_pb2.py0000644000000000000000000000571715177035225025221 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/logging/type/http_request.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n&google/logging/type/http_request.proto\x12\x13google.logging.type\x1a\x1egoogle/protobuf/duration.proto"\xef\x02\n\x0bHttpRequest\x12\x16\n\x0erequest_method\x18\x01 \x01(\t\x12\x13\n\x0brequest_url\x18\x02 \x01(\t\x12\x14\n\x0crequest_size\x18\x03 \x01(\x03\x12\x0e\n\x06status\x18\x04 \x01(\x05\x12\x15\n\rresponse_size\x18\x05 \x01(\x03\x12\x12\n\nuser_agent\x18\x06 \x01(\t\x12\x11\n\tremote_ip\x18\x07 \x01(\t\x12\x11\n\tserver_ip\x18\r \x01(\t\x12\x0f\n\x07referer\x18\x08 \x01(\t\x12*\n\x07latency\x18\x0e \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x14\n\x0c\x63\x61\x63he_lookup\x18\x0b \x01(\x08\x12\x11\n\tcache_hit\x18\t \x01(\x08\x12*\n"cache_validated_with_origin_server\x18\n \x01(\x08\x12\x18\n\x10\x63\x61\x63he_fill_bytes\x18\x0c \x01(\x03\x12\x10\n\x08protocol\x18\x0f \x01(\tB\xbe\x01\n\x17\x63om.google.logging.typeB\x10HttpRequestProtoP\x01Z8google.golang.org/genproto/googleapis/logging/type;ltype\xaa\x02\x19Google.Cloud.Logging.Type\xca\x02\x19Google\\Cloud\\Logging\\Type\xea\x02\x1cGoogle::Cloud::Logging::Typeb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.logging.type.http_request_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\027com.google.logging.typeB\020HttpRequestProtoP\001Z8google.golang.org/genproto/googleapis/logging/type;ltype\252\002\031Google.Cloud.Logging.Type\312\002\031Google\\Cloud\\Logging\\Type\352\002\034Google::Cloud::Logging::Type" _globals["_HTTPREQUEST"]._serialized_start = 96 _globals["_HTTPREQUEST"]._serialized_end = 463 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/logging/type/http_request_pb2.pyi0000644000000000000000000000603615177035224025364 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import duration_pb2 as _duration_pb2 from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class HttpRequest(_message.Message): __slots__ = ( "request_method", "request_url", "request_size", "status", "response_size", "user_agent", "remote_ip", "server_ip", "referer", "latency", "cache_lookup", "cache_hit", "cache_validated_with_origin_server", "cache_fill_bytes", "protocol", ) REQUEST_METHOD_FIELD_NUMBER: _ClassVar[int] REQUEST_URL_FIELD_NUMBER: _ClassVar[int] REQUEST_SIZE_FIELD_NUMBER: _ClassVar[int] STATUS_FIELD_NUMBER: _ClassVar[int] RESPONSE_SIZE_FIELD_NUMBER: _ClassVar[int] USER_AGENT_FIELD_NUMBER: _ClassVar[int] REMOTE_IP_FIELD_NUMBER: _ClassVar[int] SERVER_IP_FIELD_NUMBER: _ClassVar[int] REFERER_FIELD_NUMBER: _ClassVar[int] LATENCY_FIELD_NUMBER: _ClassVar[int] CACHE_LOOKUP_FIELD_NUMBER: _ClassVar[int] CACHE_HIT_FIELD_NUMBER: _ClassVar[int] CACHE_VALIDATED_WITH_ORIGIN_SERVER_FIELD_NUMBER: _ClassVar[int] CACHE_FILL_BYTES_FIELD_NUMBER: _ClassVar[int] PROTOCOL_FIELD_NUMBER: _ClassVar[int] request_method: str request_url: str request_size: int status: int response_size: int user_agent: str remote_ip: str server_ip: str referer: str latency: _duration_pb2.Duration cache_lookup: bool cache_hit: bool cache_validated_with_origin_server: bool cache_fill_bytes: int protocol: str def __init__( self, request_method: _Optional[str] = ..., request_url: _Optional[str] = ..., request_size: _Optional[int] = ..., status: _Optional[int] = ..., response_size: _Optional[int] = ..., user_agent: _Optional[str] = ..., remote_ip: _Optional[str] = ..., server_ip: _Optional[str] = ..., referer: _Optional[str] = ..., latency: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., cache_lookup: bool = ..., cache_hit: bool = ..., cache_validated_with_origin_server: bool = ..., cache_fill_bytes: _Optional[int] = ..., protocol: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/logging/type/log_severity.proto0000644000000000000000000000477315177035225025156 0ustar00rootroot// Copyright 2025 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. syntax = "proto3"; package google.logging.type; option csharp_namespace = "Google.Cloud.Logging.Type"; option go_package = "google.golang.org/genproto/googleapis/logging/type;ltype"; option java_multiple_files = true; option java_outer_classname = "LogSeverityProto"; option java_package = "com.google.logging.type"; option objc_class_prefix = "GLOG"; option php_namespace = "Google\\Cloud\\Logging\\Type"; option ruby_package = "Google::Cloud::Logging::Type"; // The severity of the event described in a log entry, expressed as one of the // standard severity levels listed below. For your reference, the levels are // assigned the listed numeric values. The effect of using numeric values other // than those listed is undefined. // // You can filter for log entries by severity. For example, the following // filter expression will match log entries with severities `INFO`, `NOTICE`, // and `WARNING`: // // severity > DEBUG AND severity <= WARNING // // If you are writing log entries, you should map other severity encodings to // one of these standard levels. For example, you might map all of Java's FINE, // FINER, and FINEST levels to `LogSeverity.DEBUG`. You can preserve the // original severity level in the log entry payload if you wish. enum LogSeverity { // (0) The log entry has no assigned severity level. DEFAULT = 0; // (100) Debug or trace information. DEBUG = 100; // (200) Routine information, such as ongoing status or performance. INFO = 200; // (300) Normal but significant events, such as start up, shut down, or // a configuration change. NOTICE = 300; // (400) Warning events might cause problems. WARNING = 400; // (500) Error events are likely to cause problems. ERROR = 500; // (600) Critical events cause more severe problems or outages. CRITICAL = 600; // (700) A person must take an action immediately. ALERT = 700; // (800) One or more systems are unusable. EMERGENCY = 800; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/logging/type/log_severity_pb2.py0000644000000000000000000000501015177035226025170 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/logging/type/log_severity.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n&google/logging/type/log_severity.proto\x12\x13google.logging.type*\x82\x01\n\x0bLogSeverity\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x44\x45\x42UG\x10\x64\x12\t\n\x04INFO\x10\xc8\x01\x12\x0b\n\x06NOTICE\x10\xac\x02\x12\x0c\n\x07WARNING\x10\x90\x03\x12\n\n\x05\x45RROR\x10\xf4\x03\x12\r\n\x08\x43RITICAL\x10\xd8\x04\x12\n\n\x05\x41LERT\x10\xbc\x05\x12\x0e\n\tEMERGENCY\x10\xa0\x06\x42\xc5\x01\n\x17\x63om.google.logging.typeB\x10LogSeverityProtoP\x01Z8google.golang.org/genproto/googleapis/logging/type;ltype\xa2\x02\x04GLOG\xaa\x02\x19Google.Cloud.Logging.Type\xca\x02\x19Google\\Cloud\\Logging\\Type\xea\x02\x1cGoogle::Cloud::Logging::Typeb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.logging.type.log_severity_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\027com.google.logging.typeB\020LogSeverityProtoP\001Z8google.golang.org/genproto/googleapis/logging/type;ltype\242\002\004GLOG\252\002\031Google.Cloud.Logging.Type\312\002\031Google\\Cloud\\Logging\\Type\352\002\034Google::Cloud::Logging::Type" _globals["_LOGSEVERITY"]._serialized_start = 64 _globals["_LOGSEVERITY"]._serialized_end = 194 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/logging/type/log_severity_pb2.pyi0000644000000000000000000000254215177035226025350 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class LogSeverity(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () DEFAULT: _ClassVar[LogSeverity] DEBUG: _ClassVar[LogSeverity] INFO: _ClassVar[LogSeverity] NOTICE: _ClassVar[LogSeverity] WARNING: _ClassVar[LogSeverity] ERROR: _ClassVar[LogSeverity] CRITICAL: _ClassVar[LogSeverity] ALERT: _ClassVar[LogSeverity] EMERGENCY: _ClassVar[LogSeverity] DEFAULT: LogSeverity DEBUG: LogSeverity INFO: LogSeverity NOTICE: LogSeverity WARNING: LogSeverity ERROR: LogSeverity CRITICAL: LogSeverity ALERT: LogSeverity EMERGENCY: LogSeverity ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0663824 googleapis_common_protos-1.75.0/google/longrunning/0000755000000000000000000000000015177036143021274 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/longrunning/operations_grpc.py0000644000000000000000000000146215177035225025047 0ustar00rootroot# Copyright 2020 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 # # https://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. # This module is provided for backwards compatibility with # googleapis-common-protos <= 1.5.0, where this was the import path. from __future__ import absolute_import from google.longrunning.operations_grpc_pb2 import * # noqa: F401, F403 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/longrunning/operations_grpc_pb2.py0000644000000000000000000000102315177035222025600 0ustar00rootroot# This module is provided for backwards compatibility with # googleapis-common-protos <= 1.52.0, where this import path contained # all of the message and gRPC definitions. from google.longrunning.operations_pb2_grpc import * from google.longrunning.operations_proto_pb2 import * from google.longrunning.operations_proto_pb2 import ( _CANCELOPERATIONREQUEST, _DELETEOPERATIONREQUEST, _GETOPERATIONREQUEST, _LISTOPERATIONSREQUEST, _LISTOPERATIONSRESPONSE, _OPERATION, _OPERATIONINFO, _OPERATIONS, ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/longrunning/operations_pb2.py0000644000000000000000000000304115177035223024570 0ustar00rootroot# 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. """Safe implementation of long-running operations with and without gRPC. Multiplexes between versions of long-running operations with and without gRPC. The former is preferred, but not possible in all environments (such as Google AppEngine Standard). """ try: from google.longrunning.operations_grpc_pb2 import * from google.longrunning.operations_grpc_pb2 import ( _CANCELOPERATIONREQUEST, _DELETEOPERATIONREQUEST, _GETOPERATIONREQUEST, _LISTOPERATIONSREQUEST, _LISTOPERATIONSRESPONSE, _OPERATION, _OPERATIONINFO, _OPERATIONS, ) except ImportError: from google.longrunning.operations_proto_pb2 import * from google.longrunning.operations_proto_pb2 import ( _CANCELOPERATIONREQUEST, _DELETEOPERATIONREQUEST, _GETOPERATIONREQUEST, _LISTOPERATIONSREQUEST, _LISTOPERATIONSRESPONSE, _OPERATION, _OPERATIONINFO, _OPERATIONS, ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/longrunning/operations_pb2_grpc.py0000644000000000000000000003420015177035226025607 0ustar00rootroot# Copyright 2020 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. # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! """Client and server classes corresponding to protobuf-defined services.""" import grpc from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2 from google.longrunning import ( operations_proto_pb2 as google_dot_longrunning_dot_operations__pb2, ) class OperationsStub(object): """Manages long-running operations with an API service. When an API method normally takes long time to complete, it can be designed to return [Operation][google.longrunning.Operation] to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource, or pass the operation resource to another API (such as Google Cloud Pub/Sub API) to receive the response. Any API service that returns long-running operations should implement the `Operations` interface so developers can have a consistent client experience. """ def __init__(self, channel): """Constructor. Args: channel: A grpc.Channel. """ self.ListOperations = channel.unary_unary( "/google.longrunning.Operations/ListOperations", request_serializer=google_dot_longrunning_dot_operations__pb2.ListOperationsRequest.SerializeToString, response_deserializer=google_dot_longrunning_dot_operations__pb2.ListOperationsResponse.FromString, ) self.GetOperation = channel.unary_unary( "/google.longrunning.Operations/GetOperation", request_serializer=google_dot_longrunning_dot_operations__pb2.GetOperationRequest.SerializeToString, response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, ) self.DeleteOperation = channel.unary_unary( "/google.longrunning.Operations/DeleteOperation", request_serializer=google_dot_longrunning_dot_operations__pb2.DeleteOperationRequest.SerializeToString, response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString, ) self.CancelOperation = channel.unary_unary( "/google.longrunning.Operations/CancelOperation", request_serializer=google_dot_longrunning_dot_operations__pb2.CancelOperationRequest.SerializeToString, response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString, ) self.WaitOperation = channel.unary_unary( "/google.longrunning.Operations/WaitOperation", request_serializer=google_dot_longrunning_dot_operations__pb2.WaitOperationRequest.SerializeToString, response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, ) class OperationsServicer(object): """Manages long-running operations with an API service. When an API method normally takes long time to complete, it can be designed to return [Operation][google.longrunning.Operation] to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource, or pass the operation resource to another API (such as Google Cloud Pub/Sub API) to receive the response. Any API service that returns long-running operations should implement the `Operations` interface so developers can have a consistent client experience. """ def ListOperations(self, request, context): """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. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetOperation(self, request, context): """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. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteOperation(self, request, context): """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`. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CancelOperation(self, request, context): """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][google.longrunning.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][google.longrunning.Operation.error] value with a [google.rpc.Status.code][google.rpc.Status.code] of 1, corresponding to `Code.CANCELLED`. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def WaitOperation(self, request, context): """Waits until the specified long-running operation is done or reaches at most a specified timeout, returning the latest state. If the operation is already done, the latest state is immediately returned. If the timeout specified is greater than the default HTTP/RPC timeout, the HTTP/RPC timeout is used. If the server does not support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Note that this method is on a best-effort basis. It may return the latest state before the specified timeout (including immediately), meaning even an immediate response is no guarantee that the operation is done. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def add_OperationsServicer_to_server(servicer, server): rpc_method_handlers = { "ListOperations": grpc.unary_unary_rpc_method_handler( servicer.ListOperations, request_deserializer=google_dot_longrunning_dot_operations__pb2.ListOperationsRequest.FromString, response_serializer=google_dot_longrunning_dot_operations__pb2.ListOperationsResponse.SerializeToString, ), "GetOperation": grpc.unary_unary_rpc_method_handler( servicer.GetOperation, request_deserializer=google_dot_longrunning_dot_operations__pb2.GetOperationRequest.FromString, response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, ), "DeleteOperation": grpc.unary_unary_rpc_method_handler( servicer.DeleteOperation, request_deserializer=google_dot_longrunning_dot_operations__pb2.DeleteOperationRequest.FromString, response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ), "CancelOperation": grpc.unary_unary_rpc_method_handler( servicer.CancelOperation, request_deserializer=google_dot_longrunning_dot_operations__pb2.CancelOperationRequest.FromString, response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ), "WaitOperation": grpc.unary_unary_rpc_method_handler( servicer.WaitOperation, request_deserializer=google_dot_longrunning_dot_operations__pb2.WaitOperationRequest.FromString, response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, ), } generic_handler = grpc.method_handlers_generic_handler( "google.longrunning.Operations", rpc_method_handlers ) server.add_generic_rpc_handlers((generic_handler,)) # This class is part of an EXPERIMENTAL API. class Operations(object): """Manages long-running operations with an API service. When an API method normally takes long time to complete, it can be designed to return [Operation][google.longrunning.Operation] to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource, or pass the operation resource to another API (such as Google Cloud Pub/Sub API) to receive the response. Any API service that returns long-running operations should implement the `Operations` interface so developers can have a consistent client experience. """ @staticmethod def ListOperations( request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None, ): return grpc.experimental.unary_unary( request, target, "/google.longrunning.Operations/ListOperations", google_dot_longrunning_dot_operations__pb2.ListOperationsRequest.SerializeToString, google_dot_longrunning_dot_operations__pb2.ListOperationsResponse.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata, ) @staticmethod def GetOperation( request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None, ): return grpc.experimental.unary_unary( request, target, "/google.longrunning.Operations/GetOperation", google_dot_longrunning_dot_operations__pb2.GetOperationRequest.SerializeToString, google_dot_longrunning_dot_operations__pb2.Operation.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata, ) @staticmethod def DeleteOperation( request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None, ): return grpc.experimental.unary_unary( request, target, "/google.longrunning.Operations/DeleteOperation", google_dot_longrunning_dot_operations__pb2.DeleteOperationRequest.SerializeToString, google_dot_protobuf_dot_empty__pb2.Empty.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata, ) @staticmethod def CancelOperation( request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None, ): return grpc.experimental.unary_unary( request, target, "/google.longrunning.Operations/CancelOperation", google_dot_longrunning_dot_operations__pb2.CancelOperationRequest.SerializeToString, google_dot_protobuf_dot_empty__pb2.Empty.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata, ) @staticmethod def WaitOperation( request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None, ): return grpc.experimental.unary_unary( request, target, "/google.longrunning.Operations/WaitOperation", google_dot_longrunning_dot_operations__pb2.WaitOperationRequest.SerializeToString, google_dot_longrunning_dot_operations__pb2.Operation.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata, ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/longrunning/operations_proto.proto0000644000000000000000000002347115177035223025774 0ustar00rootroot// Copyright 2025 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. syntax = "proto3"; package google.longrunning; import "google/api/annotations.proto"; import "google/api/client.proto"; import "google/protobuf/any.proto"; import "google/protobuf/descriptor.proto"; import "google/protobuf/duration.proto"; import "google/protobuf/empty.proto"; import "google/rpc/status.proto"; option cc_enable_arenas = true; option csharp_namespace = "Google.LongRunning"; option go_package = "cloud.google.com/go/longrunning/autogen/longrunningpb;longrunningpb"; option java_multiple_files = true; option java_outer_classname = "OperationsProto"; option java_package = "com.google.longrunning"; option objc_class_prefix = "GLRUN"; option php_namespace = "Google\\LongRunning"; extend google.protobuf.MethodOptions { // Additional information regarding long-running operations. // In particular, this specifies the types that are returned from // long-running operations. // // Required for methods that return `google.longrunning.Operation`; invalid // otherwise. google.longrunning.OperationInfo operation_info = 1049; } // Manages long-running operations with an API service. // // When an API method normally takes long time to complete, it can be designed // to return [Operation][google.longrunning.Operation] to the client, and the // client can use this interface to receive the real response asynchronously by // polling the operation resource, or pass the operation resource to another API // (such as Pub/Sub API) to receive the response. Any API service that returns // long-running operations should implement the `Operations` interface so // developers can have a consistent client experience. service Operations { option (google.api.default_host) = "longrunning.googleapis.com"; // Lists operations that match the specified filter in the request. If the // server doesn't support this method, it returns `UNIMPLEMENTED`. rpc ListOperations(ListOperationsRequest) returns (ListOperationsResponse) { option (google.api.http) = { get: "/v1/{name=operations}" }; option (google.api.method_signature) = "name,filter"; } // 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. rpc GetOperation(GetOperationRequest) returns (Operation) { option (google.api.http) = { get: "/v1/{name=operations/**}" }; option (google.api.method_signature) = "name"; } // 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`. rpc DeleteOperation(DeleteOperationRequest) returns (google.protobuf.Empty) { option (google.api.http) = { delete: "/v1/{name=operations/**}" }; option (google.api.method_signature) = "name"; } // 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][google.longrunning.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][google.longrunning.Operation.error] value with a // [google.rpc.Status.code][google.rpc.Status.code] of `1`, corresponding to // `Code.CANCELLED`. rpc CancelOperation(CancelOperationRequest) returns (google.protobuf.Empty) { option (google.api.http) = { post: "/v1/{name=operations/**}:cancel" body: "*" }; option (google.api.method_signature) = "name"; } // Waits until the specified long-running operation is done or reaches at most // a specified timeout, returning the latest state. If the operation is // already done, the latest state is immediately returned. If the timeout // specified is greater than the default HTTP/RPC timeout, the HTTP/RPC // timeout is used. If the server does not support this method, it returns // `google.rpc.Code.UNIMPLEMENTED`. // Note that this method is on a best-effort basis. It may return the latest // state before the specified timeout (including immediately), meaning even an // immediate response is no guarantee that the operation is done. rpc WaitOperation(WaitOperationRequest) returns (Operation) {} } // This resource represents a long-running operation that is the result of a // network API call. message Operation { // 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}`. string name = 1; // 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. google.protobuf.Any metadata = 2; // 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. bool done = 3; // The operation result, which can be either an `error` or a valid `response`. // If `done` == `false`, neither `error` nor `response` is set. // If `done` == `true`, exactly one of `error` or `response` can be set. // Some services might not provide the result. oneof result { // The error result of the operation in case of failure or cancellation. google.rpc.Status error = 4; // 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`. google.protobuf.Any response = 5; } } // The request message for // [Operations.GetOperation][google.longrunning.Operations.GetOperation]. message GetOperationRequest { // The name of the operation resource. string name = 1; } // The request message for // [Operations.ListOperations][google.longrunning.Operations.ListOperations]. message ListOperationsRequest { // The name of the operation's parent resource. string name = 4; // The standard list filter. string filter = 1; // The standard list page size. int32 page_size = 2; // The standard list page token. string page_token = 3; } // The response message for // [Operations.ListOperations][google.longrunning.Operations.ListOperations]. message ListOperationsResponse { // A list of operations that matches the specified filter in the request. repeated Operation operations = 1; // The standard List next-page token. string next_page_token = 2; } // The request message for // [Operations.CancelOperation][google.longrunning.Operations.CancelOperation]. message CancelOperationRequest { // The name of the operation resource to be cancelled. string name = 1; } // The request message for // [Operations.DeleteOperation][google.longrunning.Operations.DeleteOperation]. message DeleteOperationRequest { // The name of the operation resource to be deleted. string name = 1; } // The request message for // [Operations.WaitOperation][google.longrunning.Operations.WaitOperation]. message WaitOperationRequest { // The name of the operation resource to wait on. string name = 1; // The maximum duration to wait before timing out. If left blank, the wait // will be at most the time permitted by the underlying HTTP/RPC protocol. // If RPC context deadline is also specified, the shorter one will be used. google.protobuf.Duration timeout = 2; } // A message representing the message types used by a long-running operation. // // Example: // // rpc Export(ExportRequest) returns (google.longrunning.Operation) { // option (google.longrunning.operation_info) = { // response_type: "ExportResponse" // metadata_type: "ExportMetadata" // }; // } message OperationInfo { // Required. The message name of the primary return type for this // long-running operation. // This type will be used to deserialize the LRO's response. // // If the response is in a different package from the rpc, a fully-qualified // message name must be used (e.g. `google.protobuf.Struct`). // // Note: Altering this value constitutes a breaking change. string response_type = 1; // Required. The message name of the metadata type for this long-running // operation. // // If the response is in a different package from the rpc, a fully-qualified // message name must be used (e.g. `google.protobuf.Struct`). // // Note: Altering this value constitutes a breaking change. string metadata_type = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/longrunning/operations_proto.py0000644000000000000000000000036315177035225025256 0ustar00rootroot# This module is provided for backwards compatibility with # googleapis-common-protos <= 1.5.0, where this was the import path. from __future__ import absolute_import from google.longrunning.operations_proto_pb2 import * # noqa: F401, F403 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137745.0 googleapis_common_protos-1.75.0/google/longrunning/operations_proto_pb2.py0000644000000000000000000001610015177035221026011 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/longrunning/operations.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2 from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 from google.api import client_pb2 as google_dot_api_dot_client__pb2 from google.rpc import status_pb2 as google_dot_rpc_dot_status__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n#google/longrunning/operations.proto\x12\x12google.longrunning\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x19google/protobuf/any.proto\x1a google/protobuf/descriptor.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x17google/rpc/status.proto"\xa8\x01\n\tOperation\x12\x0c\n\x04name\x18\x01 \x01(\t\x12&\n\x08metadata\x18\x02 \x01(\x0b\x32\x14.google.protobuf.Any\x12\x0c\n\x04\x64one\x18\x03 \x01(\x08\x12#\n\x05\x65rror\x18\x04 \x01(\x0b\x32\x12.google.rpc.StatusH\x00\x12(\n\x08response\x18\x05 \x01(\x0b\x32\x14.google.protobuf.AnyH\x00\x42\x08\n\x06result"#\n\x13GetOperationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t"\\\n\x15ListOperationsRequest\x12\x0c\n\x04name\x18\x04 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x12\n\npage_token\x18\x03 \x01(\t"d\n\x16ListOperationsResponse\x12\x31\n\noperations\x18\x01 \x03(\x0b\x32\x1d.google.longrunning.Operation\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t"&\n\x16\x43\x61ncelOperationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t"&\n\x16\x44\x65leteOperationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t"P\n\x14WaitOperationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12*\n\x07timeout\x18\x02 \x01(\x0b\x32\x19.google.protobuf.Duration"=\n\rOperationInfo\x12\x15\n\rresponse_type\x18\x01 \x01(\t\x12\x15\n\rmetadata_type\x18\x02 \x01(\t2\xaa\x05\n\nOperations\x12\x94\x01\n\x0eListOperations\x12).google.longrunning.ListOperationsRequest\x1a*.google.longrunning.ListOperationsResponse"+\xda\x41\x0bname,filter\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/{name=operations}\x12\x7f\n\x0cGetOperation\x12\'.google.longrunning.GetOperationRequest\x1a\x1d.google.longrunning.Operation"\'\xda\x41\x04name\x82\xd3\xe4\x93\x02\x1a\x12\x18/v1/{name=operations/**}\x12~\n\x0f\x44\x65leteOperation\x12*.google.longrunning.DeleteOperationRequest\x1a\x16.google.protobuf.Empty"\'\xda\x41\x04name\x82\xd3\xe4\x93\x02\x1a*\x18/v1/{name=operations/**}\x12\x88\x01\n\x0f\x43\x61ncelOperation\x12*.google.longrunning.CancelOperationRequest\x1a\x16.google.protobuf.Empty"1\xda\x41\x04name\x82\xd3\xe4\x93\x02$"\x1f/v1/{name=operations/**}:cancel:\x01*\x12Z\n\rWaitOperation\x12(.google.longrunning.WaitOperationRequest\x1a\x1d.google.longrunning.Operation"\x00\x1a\x1d\xca\x41\x1alongrunning.googleapis.com:Z\n\x0eoperation_info\x12\x1e.google.protobuf.MethodOptions\x18\x99\x08 \x01(\x0b\x32!.google.longrunning.OperationInfoB\xa5\x01\n\x16\x63om.google.longrunningB\x0fOperationsProtoP\x01ZCcloud.google.com/go/longrunning/autogen/longrunningpb;longrunningpb\xf8\x01\x01\xa2\x02\x05GLRUN\xaa\x02\x12Google.LongRunning\xca\x02\x12Google\\LongRunningb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.longrunning.operations_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\026com.google.longrunningB\017OperationsProtoP\001ZCcloud.google.com/go/longrunning/autogen/longrunningpb;longrunningpb\370\001\001\242\002\005GLRUN\252\002\022Google.LongRunning\312\002\022Google\\LongRunning" _globals["_OPERATIONS"]._options = None _globals["_OPERATIONS"]._serialized_options = b"\312A\032longrunning.googleapis.com" _globals["_OPERATIONS"].methods_by_name["ListOperations"]._options = None _globals["_OPERATIONS"].methods_by_name[ "ListOperations" ]._serialized_options = ( b"\332A\013name,filter\202\323\344\223\002\027\022\025/v1/{name=operations}" ) _globals["_OPERATIONS"].methods_by_name["GetOperation"]._options = None _globals["_OPERATIONS"].methods_by_name[ "GetOperation" ]._serialized_options = ( b"\332A\004name\202\323\344\223\002\032\022\030/v1/{name=operations/**}" ) _globals["_OPERATIONS"].methods_by_name["DeleteOperation"]._options = None _globals["_OPERATIONS"].methods_by_name[ "DeleteOperation" ]._serialized_options = ( b"\332A\004name\202\323\344\223\002\032*\030/v1/{name=operations/**}" ) _globals["_OPERATIONS"].methods_by_name["CancelOperation"]._options = None _globals["_OPERATIONS"].methods_by_name[ "CancelOperation" ]._serialized_options = ( b'\332A\004name\202\323\344\223\002$"\037/v1/{name=operations/**}:cancel:\001*' ) _globals["_OPERATION"]._serialized_start = 262 _globals["_OPERATION"]._serialized_end = 430 _globals["_GETOPERATIONREQUEST"]._serialized_start = 432 _globals["_GETOPERATIONREQUEST"]._serialized_end = 467 _globals["_LISTOPERATIONSREQUEST"]._serialized_start = 469 _globals["_LISTOPERATIONSREQUEST"]._serialized_end = 561 _globals["_LISTOPERATIONSRESPONSE"]._serialized_start = 563 _globals["_LISTOPERATIONSRESPONSE"]._serialized_end = 663 _globals["_CANCELOPERATIONREQUEST"]._serialized_start = 665 _globals["_CANCELOPERATIONREQUEST"]._serialized_end = 703 _globals["_DELETEOPERATIONREQUEST"]._serialized_start = 705 _globals["_DELETEOPERATIONREQUEST"]._serialized_end = 743 _globals["_WAITOPERATIONREQUEST"]._serialized_start = 745 _globals["_WAITOPERATIONREQUEST"]._serialized_end = 825 _globals["_OPERATIONINFO"]._serialized_start = 827 _globals["_OPERATIONINFO"]._serialized_end = 888 _globals["_OPERATIONS"]._serialized_start = 891 _globals["_OPERATIONS"]._serialized_end = 1573 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/longrunning/operations_proto_pb2.pyi0000644000000000000000000001061215177035223026166 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import any_pb2 as _any_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pb2 as _descriptor_pb2 from google.protobuf import duration_pb2 as _duration_pb2 from google.protobuf import empty_pb2 as _empty_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers from google.api import annotations_pb2 as _annotations_pb2 from google.api import client_pb2 as _client_pb2 from google.rpc import status_pb2 as _status_pb2 DESCRIPTOR: _descriptor.FileDescriptor OPERATION_INFO_FIELD_NUMBER: _ClassVar[int] operation_info: _descriptor.FieldDescriptor class Operation(_message.Message): __slots__ = ("name", "metadata", "done", "error", "response") NAME_FIELD_NUMBER: _ClassVar[int] METADATA_FIELD_NUMBER: _ClassVar[int] DONE_FIELD_NUMBER: _ClassVar[int] ERROR_FIELD_NUMBER: _ClassVar[int] RESPONSE_FIELD_NUMBER: _ClassVar[int] name: str metadata: _any_pb2.Any done: bool error: _status_pb2.Status response: _any_pb2.Any def __init__( self, name: _Optional[str] = ..., metadata: _Optional[_Union[_any_pb2.Any, _Mapping]] = ..., done: bool = ..., error: _Optional[_Union[_status_pb2.Status, _Mapping]] = ..., response: _Optional[_Union[_any_pb2.Any, _Mapping]] = ..., ) -> None: ... class GetOperationRequest(_message.Message): __slots__ = ("name",) NAME_FIELD_NUMBER: _ClassVar[int] name: str def __init__(self, name: _Optional[str] = ...) -> None: ... class ListOperationsRequest(_message.Message): __slots__ = ("name", "filter", "page_size", "page_token") NAME_FIELD_NUMBER: _ClassVar[int] FILTER_FIELD_NUMBER: _ClassVar[int] PAGE_SIZE_FIELD_NUMBER: _ClassVar[int] PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int] name: str filter: str page_size: int page_token: str def __init__( self, name: _Optional[str] = ..., filter: _Optional[str] = ..., page_size: _Optional[int] = ..., page_token: _Optional[str] = ..., ) -> None: ... class ListOperationsResponse(_message.Message): __slots__ = ("operations", "next_page_token") OPERATIONS_FIELD_NUMBER: _ClassVar[int] NEXT_PAGE_TOKEN_FIELD_NUMBER: _ClassVar[int] operations: _containers.RepeatedCompositeFieldContainer[Operation] next_page_token: str def __init__( self, operations: _Optional[_Iterable[_Union[Operation, _Mapping]]] = ..., next_page_token: _Optional[str] = ..., ) -> None: ... class CancelOperationRequest(_message.Message): __slots__ = ("name",) NAME_FIELD_NUMBER: _ClassVar[int] name: str def __init__(self, name: _Optional[str] = ...) -> None: ... class DeleteOperationRequest(_message.Message): __slots__ = ("name",) NAME_FIELD_NUMBER: _ClassVar[int] name: str def __init__(self, name: _Optional[str] = ...) -> None: ... class WaitOperationRequest(_message.Message): __slots__ = ("name", "timeout") NAME_FIELD_NUMBER: _ClassVar[int] TIMEOUT_FIELD_NUMBER: _ClassVar[int] name: str timeout: _duration_pb2.Duration def __init__( self, name: _Optional[str] = ..., timeout: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., ) -> None: ... class OperationInfo(_message.Message): __slots__ = ("response_type", "metadata_type") RESPONSE_TYPE_FIELD_NUMBER: _ClassVar[int] METADATA_TYPE_FIELD_NUMBER: _ClassVar[int] response_type: str metadata_type: str def __init__( self, response_type: _Optional[str] = ..., metadata_type: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0682957 googleapis_common_protos-1.75.0/google/rpc/0000755000000000000000000000000015177036143017520 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/rpc/code.proto0000644000000000000000000001574215177035224021527 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.rpc; option go_package = "google.golang.org/genproto/googleapis/rpc/code;code"; option java_multiple_files = true; option java_outer_classname = "CodeProto"; option java_package = "com.google.rpc"; option objc_class_prefix = "RPC"; // The canonical error codes for gRPC APIs. // // // Sometimes multiple error codes may apply. Services should return // the most specific error code that applies. For example, prefer // `OUT_OF_RANGE` over `FAILED_PRECONDITION` if both codes apply. // Similarly prefer `NOT_FOUND` or `ALREADY_EXISTS` over `FAILED_PRECONDITION`. enum Code { // Not an error; returned on success. // // HTTP Mapping: 200 OK OK = 0; // The operation was cancelled, typically by the caller. // // HTTP Mapping: 499 Client Closed Request CANCELLED = 1; // Unknown error. For example, this error may be returned when // a `Status` value received from another address space belongs to // an error space that is not known in this address space. Also // errors raised by APIs that do not return enough error information // may be converted to this error. // // HTTP Mapping: 500 Internal Server Error UNKNOWN = 2; // The client specified an invalid argument. Note that this differs // from `FAILED_PRECONDITION`. `INVALID_ARGUMENT` indicates arguments // that are problematic regardless of the state of the system // (e.g., a malformed file name). // // HTTP Mapping: 400 Bad Request INVALID_ARGUMENT = 3; // The deadline expired before the operation could complete. For operations // that change the state of the system, this error may be returned // even if the operation has completed successfully. For example, a // successful response from a server could have been delayed long // enough for the deadline to expire. // // HTTP Mapping: 504 Gateway Timeout DEADLINE_EXCEEDED = 4; // Some requested entity (e.g., file or directory) was not found. // // Note to server developers: if a request is denied for an entire class // of users, such as gradual feature rollout or undocumented allowlist, // `NOT_FOUND` may be used. If a request is denied for some users within // a class of users, such as user-based access control, `PERMISSION_DENIED` // must be used. // // HTTP Mapping: 404 Not Found NOT_FOUND = 5; // The entity that a client attempted to create (e.g., file or directory) // already exists. // // HTTP Mapping: 409 Conflict ALREADY_EXISTS = 6; // The caller does not have permission to execute the specified // operation. `PERMISSION_DENIED` must not be used for rejections // caused by exhausting some resource (use `RESOURCE_EXHAUSTED` // instead for those errors). `PERMISSION_DENIED` must not be // used if the caller can not be identified (use `UNAUTHENTICATED` // instead for those errors). This error code does not imply the // request is valid or the requested entity exists or satisfies // other pre-conditions. // // HTTP Mapping: 403 Forbidden PERMISSION_DENIED = 7; // The request does not have valid authentication credentials for the // operation. // // HTTP Mapping: 401 Unauthorized UNAUTHENTICATED = 16; // Some resource has been exhausted, perhaps a per-user quota, or // perhaps the entire file system is out of space. // // HTTP Mapping: 429 Too Many Requests RESOURCE_EXHAUSTED = 8; // The operation was rejected because the system is not in a state // required for the operation's execution. For example, the directory // to be deleted is non-empty, an rmdir operation is applied to // a non-directory, etc. // // Service implementors can use the following guidelines to decide // between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`: // (a) Use `UNAVAILABLE` if the client can retry just the failing call. // (b) Use `ABORTED` if the client should retry at a higher level. For // example, when a client-specified test-and-set fails, indicating the // client should restart a read-modify-write sequence. // (c) Use `FAILED_PRECONDITION` if the client should not retry until // the system state has been explicitly fixed. For example, if an "rmdir" // fails because the directory is non-empty, `FAILED_PRECONDITION` // should be returned since the client should not retry unless // the files are deleted from the directory. // // HTTP Mapping: 400 Bad Request FAILED_PRECONDITION = 9; // The operation was aborted, typically due to a concurrency issue such as // a sequencer check failure or transaction abort. // // See the guidelines above for deciding between `FAILED_PRECONDITION`, // `ABORTED`, and `UNAVAILABLE`. // // HTTP Mapping: 409 Conflict ABORTED = 10; // The operation was attempted past the valid range. E.g., seeking or // reading past end-of-file. // // Unlike `INVALID_ARGUMENT`, this error indicates a problem that may // be fixed if the system state changes. For example, a 32-bit file // system will generate `INVALID_ARGUMENT` if asked to read at an // offset that is not in the range [0,2^32-1], but it will generate // `OUT_OF_RANGE` if asked to read from an offset past the current // file size. // // There is a fair bit of overlap between `FAILED_PRECONDITION` and // `OUT_OF_RANGE`. We recommend using `OUT_OF_RANGE` (the more specific // error) when it applies so that callers who are iterating through // a space can easily look for an `OUT_OF_RANGE` error to detect when // they are done. // // HTTP Mapping: 400 Bad Request OUT_OF_RANGE = 11; // The operation is not implemented or is not supported/enabled in this // service. // // HTTP Mapping: 501 Not Implemented UNIMPLEMENTED = 12; // Internal errors. This means that some invariants expected by the // underlying system have been broken. This error code is reserved // for serious errors. // // HTTP Mapping: 500 Internal Server Error INTERNAL = 13; // The service is currently unavailable. This is most likely a // transient condition, which can be corrected by retrying with // a backoff. Note that it is not always safe to retry // non-idempotent operations. // // See the guidelines above for deciding between `FAILED_PRECONDITION`, // `ABORTED`, and `UNAVAILABLE`. // // HTTP Mapping: 503 Service Unavailable UNAVAILABLE = 14; // Unrecoverable data loss or corruption. // // HTTP Mapping: 500 Internal Server Error DATA_LOSS = 15; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/rpc/code_pb2.py0000644000000000000000000000466015177035222021552 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/rpc/code.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n\x15google/rpc/code.proto\x12\ngoogle.rpc*\xb7\x02\n\x04\x43ode\x12\x06\n\x02OK\x10\x00\x12\r\n\tCANCELLED\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x14\n\x10INVALID_ARGUMENT\x10\x03\x12\x15\n\x11\x44\x45\x41\x44LINE_EXCEEDED\x10\x04\x12\r\n\tNOT_FOUND\x10\x05\x12\x12\n\x0e\x41LREADY_EXISTS\x10\x06\x12\x15\n\x11PERMISSION_DENIED\x10\x07\x12\x13\n\x0fUNAUTHENTICATED\x10\x10\x12\x16\n\x12RESOURCE_EXHAUSTED\x10\x08\x12\x17\n\x13\x46\x41ILED_PRECONDITION\x10\t\x12\x0b\n\x07\x41\x42ORTED\x10\n\x12\x10\n\x0cOUT_OF_RANGE\x10\x0b\x12\x11\n\rUNIMPLEMENTED\x10\x0c\x12\x0c\n\x08INTERNAL\x10\r\x12\x0f\n\x0bUNAVAILABLE\x10\x0e\x12\r\n\tDATA_LOSS\x10\x0f\x42X\n\x0e\x63om.google.rpcB\tCodeProtoP\x01Z3google.golang.org/genproto/googleapis/rpc/code;code\xa2\x02\x03RPCb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.rpc.code_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.rpcB\tCodeProtoP\001Z3google.golang.org/genproto/googleapis/rpc/code;code\242\002\003RPC" _globals["_CODE"]._serialized_start = 38 _globals["_CODE"]._serialized_end = 349 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/rpc/code_pb2.pyi0000644000000000000000000000335315177035225021724 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class Code(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () OK: _ClassVar[Code] CANCELLED: _ClassVar[Code] UNKNOWN: _ClassVar[Code] INVALID_ARGUMENT: _ClassVar[Code] DEADLINE_EXCEEDED: _ClassVar[Code] NOT_FOUND: _ClassVar[Code] ALREADY_EXISTS: _ClassVar[Code] PERMISSION_DENIED: _ClassVar[Code] UNAUTHENTICATED: _ClassVar[Code] RESOURCE_EXHAUSTED: _ClassVar[Code] FAILED_PRECONDITION: _ClassVar[Code] ABORTED: _ClassVar[Code] OUT_OF_RANGE: _ClassVar[Code] UNIMPLEMENTED: _ClassVar[Code] INTERNAL: _ClassVar[Code] UNAVAILABLE: _ClassVar[Code] DATA_LOSS: _ClassVar[Code] OK: Code CANCELLED: Code UNKNOWN: Code INVALID_ARGUMENT: Code DEADLINE_EXCEEDED: Code NOT_FOUND: Code ALREADY_EXISTS: Code PERMISSION_DENIED: Code UNAUTHENTICATED: Code RESOURCE_EXHAUSTED: Code FAILED_PRECONDITION: Code ABORTED: Code OUT_OF_RANGE: Code UNIMPLEMENTED: Code INTERNAL: Code UNAVAILABLE: Code DATA_LOSS: Code ././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1778138211.06927 googleapis_common_protos-1.75.0/google/rpc/context/0000755000000000000000000000000015177036143021204 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/rpc/context/attribute_context.proto0000644000000000000000000003541315177035225026046 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.rpc.context; import "google/protobuf/any.proto"; import "google/protobuf/duration.proto"; import "google/protobuf/struct.proto"; import "google/protobuf/timestamp.proto"; option go_package = "google.golang.org/genproto/googleapis/rpc/context/attribute_context;attribute_context"; option java_multiple_files = true; option java_outer_classname = "AttributeContextProto"; option java_package = "com.google.rpc.context"; // This message defines the standard attribute vocabulary for Google APIs. // // An attribute is a piece of metadata that describes an activity on a network // service. For example, the size of an HTTP request, or the status code of // an HTTP response. // // Each attribute has a type and a name, which is logically defined as // a proto message field in `AttributeContext`. The field type becomes the // attribute type, and the field path becomes the attribute name. For example, // the attribute `source.ip` maps to field `AttributeContext.source.ip`. // // This message definition is guaranteed not to have any wire breaking change. // So you can use it directly for passing attributes across different systems. // // NOTE: Different system may generate different subset of attributes. Please // verify the system specification before relying on an attribute generated // a system. message AttributeContext { // This message defines attributes for a node that handles a network request. // The node can be either a service or an application that sends, forwards, // or receives the request. Service peers should fill in // `principal` and `labels` as appropriate. message Peer { // The IP address of the peer. string ip = 1; // The network port of the peer. int64 port = 2; // The labels associated with the peer. map labels = 6; // The identity of this peer. Similar to `Request.auth.principal`, but // relative to the peer instead of the request. For example, the // identity associated with a load balancer that forwarded the request. string principal = 7; // The CLDR country/region code associated with the above IP address. // If the IP address is private, the `region_code` should reflect the // physical location where this peer is running. string region_code = 8; } // This message defines attributes associated with API operations, such as // a network API request. The terminology is based on the conventions used // by Google APIs, Istio, and OpenAPI. message Api { // The API service name. It is a logical identifier for a networked API, // such as "pubsub.googleapis.com". The naming syntax depends on the // API management system being used for handling the request. string service = 1; // The API operation name. For gRPC requests, it is the fully qualified API // method name, such as "google.pubsub.v1.Publisher.Publish". For OpenAPI // requests, it is the `operationId`, such as "getPet". string operation = 2; // The API protocol used for sending the request, such as "http", "https", // "grpc", or "internal". string protocol = 3; // The API version associated with the API operation above, such as "v1" or // "v1alpha1". string version = 4; } // This message defines request authentication attributes. Terminology is // based on the JSON Web Token (JWT) standard, but the terms also // correlate to concepts in other standards. message Auth { // The authenticated principal. Reflects the issuer (`iss`) and subject // (`sub`) claims within a JWT. The issuer and subject should be `/` // delimited, with `/` percent-encoded within the subject fragment. For // Google accounts, the principal format is: // "https://accounts.google.com/{id}" string principal = 1; // The intended audience(s) for this authentication information. Reflects // the audience (`aud`) claim within a JWT. The audience // value(s) depends on the `issuer`, but typically include one or more of // the following pieces of information: // // * The services intended to receive the credential. For example, // ["https://pubsub.googleapis.com/", "https://storage.googleapis.com/"]. // * A set of service-based scopes. For example, // ["https://www.googleapis.com/auth/cloud-platform"]. // * The client id of an app, such as the Firebase project id for JWTs // from Firebase Auth. // // Consult the documentation for the credential issuer to determine the // information provided. repeated string audiences = 2; // The authorized presenter of the credential. Reflects the optional // Authorized Presenter (`azp`) claim within a JWT or the // OAuth client id. For example, a Google Cloud Platform client id looks // as follows: "123456789012.apps.googleusercontent.com". string presenter = 3; // Structured claims presented with the credential. JWTs include // `{key: value}` pairs for standard and private claims. The following // is a subset of the standard required and optional claims that would // typically be presented for a Google-based JWT: // // {'iss': 'accounts.google.com', // 'sub': '113289723416554971153', // 'aud': ['123456789012', 'pubsub.googleapis.com'], // 'azp': '123456789012.apps.googleusercontent.com', // 'email': 'jsmith@example.com', // 'iat': 1353601026, // 'exp': 1353604926} // // SAML assertions are similarly specified, but with an identity provider // dependent structure. google.protobuf.Struct claims = 4; // A list of access level resource names that allow resources to be // accessed by authenticated requester. It is part of Secure GCP processing // for the incoming request. An access level string has the format: // "//{api_service_name}/accessPolicies/{policy_id}/accessLevels/{short_name}" // // Example: // "//accesscontextmanager.googleapis.com/accessPolicies/MY_POLICY_ID/accessLevels/MY_LEVEL" repeated string access_levels = 5; } // This message defines attributes for an HTTP request. If the actual // request is not an HTTP request, the runtime system should try to map // the actual request to an equivalent HTTP request. message Request { // The unique ID for a request, which can be propagated to downstream // systems. The ID should have low probability of collision // within a single day for a specific service. string id = 1; // The HTTP request method, such as `GET`, `POST`. string method = 2; // The HTTP request headers. If multiple headers share the same key, they // must be merged according to the HTTP spec. All header keys must be // lowercased, because HTTP header keys are case-insensitive. map headers = 3; // The HTTP URL path, excluding the query parameters. string path = 4; // The HTTP request `Host` header value. string host = 5; // The HTTP URL scheme, such as `http` and `https`. string scheme = 6; // The HTTP URL query in the format of `name1=value1&name2=value2`, as it // appears in the first line of the HTTP request. No decoding is performed. string query = 7; // The timestamp when the `destination` service receives the last byte of // the request. google.protobuf.Timestamp time = 9; // The HTTP request size in bytes. If unknown, it must be -1. int64 size = 10; // The network protocol used with the request, such as "http/1.1", // "spdy/3", "h2", "h2c", "webrtc", "tcp", "udp", "quic". See // https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids // for details. string protocol = 11; // A special parameter for request reason. It is used by security systems // to associate auditing information with a request. string reason = 12; // The request authentication. May be absent for unauthenticated requests. // Derived from the HTTP request `Authorization` header or equivalent. Auth auth = 13; // The values from Origin header from the HTTP request, such as // "https://console.cloud.google.com". Modern browsers can only have one // origin. Special browsers and/or HTTP clients may require multiple // origins. string origin = 14; } // This message defines attributes for a typical network response. It // generally models semantics of an HTTP response. message Response { // The HTTP response status code, such as `200` and `404`. int64 code = 1; // The HTTP response size in bytes. If unknown, it must be -1. int64 size = 2; // The HTTP response headers. If multiple headers share the same key, they // must be merged according to HTTP spec. All header keys must be // lowercased, because HTTP header keys are case-insensitive. map headers = 3; // The timestamp when the `destination` service sends the last byte of // the response. google.protobuf.Timestamp time = 4; // The amount of time it takes the backend service to fully respond to a // request. Measured from when the destination service starts to send the // request to the backend until when the destination service receives the // complete response from the backend. google.protobuf.Duration backend_latency = 5; } // This message defines core attributes for a resource. A resource is an // addressable (named) entity provided by the destination service. For // example, a file stored on a network storage service. message Resource { // The name of the service that this resource belongs to, such as // `pubsub.googleapis.com`. The service may be different from the DNS // hostname that actually serves the request. string service = 1; // The stable identifier (name) of a resource on the `service`. A resource // can be logically identified as "//{resource.service}/{resource.name}". // The differences between a resource name and a URI are: // // * Resource name is a logical identifier, independent of network // protocol and API version. For example, // `//pubsub.googleapis.com/projects/123/topics/news-feed`. // * URI often includes protocol and version information, so it can // be used directly by applications. For example, // `https://pubsub.googleapis.com/v1/projects/123/topics/news-feed`. // // See https://cloud.google.com/apis/design/resource_names for details. string name = 2; // The type of the resource. The syntax is platform-specific because // different platforms define their resources differently. // // For Google APIs, the type format must be "{service}/{kind}", such as // "pubsub.googleapis.com/Topic". string type = 3; // The labels or tags on the resource, such as AWS resource tags and // Kubernetes resource labels. map labels = 4; // The unique identifier of the resource. UID is unique in the time // and space for this resource within the scope of the service. It is // typically generated by the server on successful creation of a resource // and must not be changed. UID is used to uniquely identify resources // with resource name reuses. This should be a UUID4. string uid = 5; // Annotations is an unstructured key-value map stored with a resource that // may be set by external tools to store and retrieve arbitrary metadata. // They are not queryable and should be preserved when modifying objects. // // More info: // https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ map annotations = 6; // Mutable. The display name set by clients. Must be <= 63 characters. string display_name = 7; // Output only. The timestamp when the resource was created. This may // be either the time creation was initiated or when it was completed. google.protobuf.Timestamp create_time = 8; // Output only. The timestamp when the resource was last updated. Any // change to the resource made by users must refresh this value. // Changes to a resource made by the service should refresh this value. google.protobuf.Timestamp update_time = 9; // Output only. The timestamp when the resource was deleted. // If the resource is not deleted, this must be empty. google.protobuf.Timestamp delete_time = 10; // Output only. An opaque value that uniquely identifies a version or // generation of a resource. It can be used to confirm that the client // and server agree on the ordering of a resource being written. string etag = 11; // Immutable. The location of the resource. The location encoding is // specific to the service provider, and new encoding may be introduced // as the service evolves. // // For Google Cloud products, the encoding is what is used by Google Cloud // APIs, such as `us-east1`, `aws-us-east-1`, and `azure-eastus2`. The // semantics of `location` is identical to the // `cloud.googleapis.com/location` label used by some Google Cloud APIs. string location = 12; } // The origin of a network activity. In a multi hop network activity, // the origin represents the sender of the first hop. For the first hop, // the `source` and the `origin` must have the same content. Peer origin = 7; // The source of a network activity, such as starting a TCP connection. // In a multi hop network activity, the source represents the sender of the // last hop. Peer source = 1; // The destination of a network activity, such as accepting a TCP connection. // In a multi hop network activity, the destination represents the receiver of // the last hop. Peer destination = 2; // Represents a network request, such as an HTTP request. Request request = 3; // Represents a network response, such as an HTTP response. Response response = 4; // Represents a target resource that is involved with a network activity. // If multiple resources are involved with an activity, this must be the // primary one. Resource resource = 5; // Represents an API operation that is involved to a network activity. Api api = 6; // Supports extensions for advanced use cases, such as logs and metrics. repeated google.protobuf.Any extensions = 8; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/rpc/context/attribute_context_pb2.py0000644000000000000000000002044615177035222026073 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/rpc/context/attribute_context.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n*google/rpc/context/attribute_context.proto\x12\x12google.rpc.context\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x93\x10\n\x10\x41ttributeContext\x12\x39\n\x06origin\x18\x07 \x01(\x0b\x32).google.rpc.context.AttributeContext.Peer\x12\x39\n\x06source\x18\x01 \x01(\x0b\x32).google.rpc.context.AttributeContext.Peer\x12>\n\x0b\x64\x65stination\x18\x02 \x01(\x0b\x32).google.rpc.context.AttributeContext.Peer\x12=\n\x07request\x18\x03 \x01(\x0b\x32,.google.rpc.context.AttributeContext.Request\x12?\n\x08response\x18\x04 \x01(\x0b\x32-.google.rpc.context.AttributeContext.Response\x12?\n\x08resource\x18\x05 \x01(\x0b\x32-.google.rpc.context.AttributeContext.Resource\x12\x35\n\x03\x61pi\x18\x06 \x01(\x0b\x32(.google.rpc.context.AttributeContext.Api\x12(\n\nextensions\x18\x08 \x03(\x0b\x32\x14.google.protobuf.Any\x1a\xbe\x01\n\x04Peer\x12\n\n\x02ip\x18\x01 \x01(\t\x12\x0c\n\x04port\x18\x02 \x01(\x03\x12\x45\n\x06labels\x18\x06 \x03(\x0b\x32\x35.google.rpc.context.AttributeContext.Peer.LabelsEntry\x12\x11\n\tprincipal\x18\x07 \x01(\t\x12\x13\n\x0bregion_code\x18\x08 \x01(\t\x1a-\n\x0bLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1aL\n\x03\x41pi\x12\x0f\n\x07service\x18\x01 \x01(\t\x12\x11\n\toperation\x18\x02 \x01(\t\x12\x10\n\x08protocol\x18\x03 \x01(\t\x12\x0f\n\x07version\x18\x04 \x01(\t\x1a\x7f\n\x04\x41uth\x12\x11\n\tprincipal\x18\x01 \x01(\t\x12\x11\n\taudiences\x18\x02 \x03(\t\x12\x11\n\tpresenter\x18\x03 \x01(\t\x12'\n\x06\x63laims\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\x12\x15\n\raccess_levels\x18\x05 \x03(\t\x1a\xff\x02\n\x07Request\x12\n\n\x02id\x18\x01 \x01(\t\x12\x0e\n\x06method\x18\x02 \x01(\t\x12J\n\x07headers\x18\x03 \x03(\x0b\x32\x39.google.rpc.context.AttributeContext.Request.HeadersEntry\x12\x0c\n\x04path\x18\x04 \x01(\t\x12\x0c\n\x04host\x18\x05 \x01(\t\x12\x0e\n\x06scheme\x18\x06 \x01(\t\x12\r\n\x05query\x18\x07 \x01(\t\x12(\n\x04time\x18\t \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0c\n\x04size\x18\n \x01(\x03\x12\x10\n\x08protocol\x18\x0b \x01(\t\x12\x0e\n\x06reason\x18\x0c \x01(\t\x12\x37\n\x04\x61uth\x18\r \x01(\x0b\x32).google.rpc.context.AttributeContext.Auth\x12\x0e\n\x06origin\x18\x0e \x01(\t\x1a.\n\x0cHeadersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x81\x02\n\x08Response\x12\x0c\n\x04\x63ode\x18\x01 \x01(\x03\x12\x0c\n\x04size\x18\x02 \x01(\x03\x12K\n\x07headers\x18\x03 \x03(\x0b\x32:.google.rpc.context.AttributeContext.Response.HeadersEntry\x12(\n\x04time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x32\n\x0f\x62\x61\x63kend_latency\x18\x05 \x01(\x0b\x32\x19.google.protobuf.Duration\x1a.\n\x0cHeadersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x90\x04\n\x08Resource\x12\x0f\n\x07service\x18\x01 \x01(\t\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x0c\n\x04type\x18\x03 \x01(\t\x12I\n\x06labels\x18\x04 \x03(\x0b\x32\x39.google.rpc.context.AttributeContext.Resource.LabelsEntry\x12\x0b\n\x03uid\x18\x05 \x01(\t\x12S\n\x0b\x61nnotations\x18\x06 \x03(\x0b\x32>.google.rpc.context.AttributeContext.Resource.AnnotationsEntry\x12\x14\n\x0c\x64isplay_name\x18\x07 \x01(\t\x12/\n\x0b\x63reate_time\x18\x08 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12/\n\x0bupdate_time\x18\t \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12/\n\x0b\x64\x65lete_time\x18\n \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0c\n\x04\x65tag\x18\x0b \x01(\t\x12\x10\n\x08location\x18\x0c \x01(\t\x1a-\n\x0bLabelsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x32\n\x10\x41nnotationsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42\x88\x01\n\x16\x63om.google.rpc.contextB\x15\x41ttributeContextProtoP\x01ZUgoogle.golang.org/genproto/googleapis/rpc/context/attribute_context;attribute_contextb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.rpc.context.attribute_context_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\026com.google.rpc.contextB\025AttributeContextProtoP\001ZUgoogle.golang.org/genproto/googleapis/rpc/context/attribute_context;attribute_context" _globals["_ATTRIBUTECONTEXT_PEER_LABELSENTRY"]._options = None _globals["_ATTRIBUTECONTEXT_PEER_LABELSENTRY"]._serialized_options = b"8\001" _globals["_ATTRIBUTECONTEXT_REQUEST_HEADERSENTRY"]._options = None _globals["_ATTRIBUTECONTEXT_REQUEST_HEADERSENTRY"]._serialized_options = b"8\001" _globals["_ATTRIBUTECONTEXT_RESPONSE_HEADERSENTRY"]._options = None _globals["_ATTRIBUTECONTEXT_RESPONSE_HEADERSENTRY"]._serialized_options = b"8\001" _globals["_ATTRIBUTECONTEXT_RESOURCE_LABELSENTRY"]._options = None _globals["_ATTRIBUTECONTEXT_RESOURCE_LABELSENTRY"]._serialized_options = b"8\001" _globals["_ATTRIBUTECONTEXT_RESOURCE_ANNOTATIONSENTRY"]._options = None _globals[ "_ATTRIBUTECONTEXT_RESOURCE_ANNOTATIONSENTRY" ]._serialized_options = b"8\001" _globals["_ATTRIBUTECONTEXT"]._serialized_start = 189 _globals["_ATTRIBUTECONTEXT"]._serialized_end = 2256 _globals["_ATTRIBUTECONTEXT_PEER"]._serialized_start = 682 _globals["_ATTRIBUTECONTEXT_PEER"]._serialized_end = 872 _globals["_ATTRIBUTECONTEXT_PEER_LABELSENTRY"]._serialized_start = 827 _globals["_ATTRIBUTECONTEXT_PEER_LABELSENTRY"]._serialized_end = 872 _globals["_ATTRIBUTECONTEXT_API"]._serialized_start = 874 _globals["_ATTRIBUTECONTEXT_API"]._serialized_end = 950 _globals["_ATTRIBUTECONTEXT_AUTH"]._serialized_start = 952 _globals["_ATTRIBUTECONTEXT_AUTH"]._serialized_end = 1079 _globals["_ATTRIBUTECONTEXT_REQUEST"]._serialized_start = 1082 _globals["_ATTRIBUTECONTEXT_REQUEST"]._serialized_end = 1465 _globals["_ATTRIBUTECONTEXT_REQUEST_HEADERSENTRY"]._serialized_start = 1419 _globals["_ATTRIBUTECONTEXT_REQUEST_HEADERSENTRY"]._serialized_end = 1465 _globals["_ATTRIBUTECONTEXT_RESPONSE"]._serialized_start = 1468 _globals["_ATTRIBUTECONTEXT_RESPONSE"]._serialized_end = 1725 _globals["_ATTRIBUTECONTEXT_RESPONSE_HEADERSENTRY"]._serialized_start = 1419 _globals["_ATTRIBUTECONTEXT_RESPONSE_HEADERSENTRY"]._serialized_end = 1465 _globals["_ATTRIBUTECONTEXT_RESOURCE"]._serialized_start = 1728 _globals["_ATTRIBUTECONTEXT_RESOURCE"]._serialized_end = 2256 _globals["_ATTRIBUTECONTEXT_RESOURCE_LABELSENTRY"]._serialized_start = 827 _globals["_ATTRIBUTECONTEXT_RESOURCE_LABELSENTRY"]._serialized_end = 872 _globals["_ATTRIBUTECONTEXT_RESOURCE_ANNOTATIONSENTRY"]._serialized_start = 2206 _globals["_ATTRIBUTECONTEXT_RESOURCE_ANNOTATIONSENTRY"]._serialized_end = 2256 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/rpc/context/attribute_context_pb2.pyi0000644000000000000000000002651315177035222026245 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import any_pb2 as _any_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import duration_pb2 as _duration_pb2 from google.protobuf import message as _message from google.protobuf import struct_pb2 as _struct_pb2 from google.protobuf import timestamp_pb2 as _timestamp_pb2 from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class AttributeContext(_message.Message): __slots__ = ( "origin", "source", "destination", "request", "response", "resource", "api", "extensions", ) class Peer(_message.Message): __slots__ = ("ip", "port", "labels", "principal", "region_code") class LabelsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... IP_FIELD_NUMBER: _ClassVar[int] PORT_FIELD_NUMBER: _ClassVar[int] LABELS_FIELD_NUMBER: _ClassVar[int] PRINCIPAL_FIELD_NUMBER: _ClassVar[int] REGION_CODE_FIELD_NUMBER: _ClassVar[int] ip: str port: int labels: _containers.ScalarMap[str, str] principal: str region_code: str def __init__( self, ip: _Optional[str] = ..., port: _Optional[int] = ..., labels: _Optional[_Mapping[str, str]] = ..., principal: _Optional[str] = ..., region_code: _Optional[str] = ..., ) -> None: ... class Api(_message.Message): __slots__ = ("service", "operation", "protocol", "version") SERVICE_FIELD_NUMBER: _ClassVar[int] OPERATION_FIELD_NUMBER: _ClassVar[int] PROTOCOL_FIELD_NUMBER: _ClassVar[int] VERSION_FIELD_NUMBER: _ClassVar[int] service: str operation: str protocol: str version: str def __init__( self, service: _Optional[str] = ..., operation: _Optional[str] = ..., protocol: _Optional[str] = ..., version: _Optional[str] = ..., ) -> None: ... class Auth(_message.Message): __slots__ = ("principal", "audiences", "presenter", "claims", "access_levels") PRINCIPAL_FIELD_NUMBER: _ClassVar[int] AUDIENCES_FIELD_NUMBER: _ClassVar[int] PRESENTER_FIELD_NUMBER: _ClassVar[int] CLAIMS_FIELD_NUMBER: _ClassVar[int] ACCESS_LEVELS_FIELD_NUMBER: _ClassVar[int] principal: str audiences: _containers.RepeatedScalarFieldContainer[str] presenter: str claims: _struct_pb2.Struct access_levels: _containers.RepeatedScalarFieldContainer[str] def __init__( self, principal: _Optional[str] = ..., audiences: _Optional[_Iterable[str]] = ..., presenter: _Optional[str] = ..., claims: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., access_levels: _Optional[_Iterable[str]] = ..., ) -> None: ... class Request(_message.Message): __slots__ = ( "id", "method", "headers", "path", "host", "scheme", "query", "time", "size", "protocol", "reason", "auth", "origin", ) class HeadersEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... ID_FIELD_NUMBER: _ClassVar[int] METHOD_FIELD_NUMBER: _ClassVar[int] HEADERS_FIELD_NUMBER: _ClassVar[int] PATH_FIELD_NUMBER: _ClassVar[int] HOST_FIELD_NUMBER: _ClassVar[int] SCHEME_FIELD_NUMBER: _ClassVar[int] QUERY_FIELD_NUMBER: _ClassVar[int] TIME_FIELD_NUMBER: _ClassVar[int] SIZE_FIELD_NUMBER: _ClassVar[int] PROTOCOL_FIELD_NUMBER: _ClassVar[int] REASON_FIELD_NUMBER: _ClassVar[int] AUTH_FIELD_NUMBER: _ClassVar[int] ORIGIN_FIELD_NUMBER: _ClassVar[int] id: str method: str headers: _containers.ScalarMap[str, str] path: str host: str scheme: str query: str time: _timestamp_pb2.Timestamp size: int protocol: str reason: str auth: AttributeContext.Auth origin: str def __init__( self, id: _Optional[str] = ..., method: _Optional[str] = ..., headers: _Optional[_Mapping[str, str]] = ..., path: _Optional[str] = ..., host: _Optional[str] = ..., scheme: _Optional[str] = ..., query: _Optional[str] = ..., time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., size: _Optional[int] = ..., protocol: _Optional[str] = ..., reason: _Optional[str] = ..., auth: _Optional[_Union[AttributeContext.Auth, _Mapping]] = ..., origin: _Optional[str] = ..., ) -> None: ... class Response(_message.Message): __slots__ = ("code", "size", "headers", "time", "backend_latency") class HeadersEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... CODE_FIELD_NUMBER: _ClassVar[int] SIZE_FIELD_NUMBER: _ClassVar[int] HEADERS_FIELD_NUMBER: _ClassVar[int] TIME_FIELD_NUMBER: _ClassVar[int] BACKEND_LATENCY_FIELD_NUMBER: _ClassVar[int] code: int size: int headers: _containers.ScalarMap[str, str] time: _timestamp_pb2.Timestamp backend_latency: _duration_pb2.Duration def __init__( self, code: _Optional[int] = ..., size: _Optional[int] = ..., headers: _Optional[_Mapping[str, str]] = ..., time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., backend_latency: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ..., ) -> None: ... class Resource(_message.Message): __slots__ = ( "service", "name", "type", "labels", "uid", "annotations", "display_name", "create_time", "update_time", "delete_time", "etag", "location", ) class LabelsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... class AnnotationsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... SERVICE_FIELD_NUMBER: _ClassVar[int] NAME_FIELD_NUMBER: _ClassVar[int] TYPE_FIELD_NUMBER: _ClassVar[int] LABELS_FIELD_NUMBER: _ClassVar[int] UID_FIELD_NUMBER: _ClassVar[int] ANNOTATIONS_FIELD_NUMBER: _ClassVar[int] DISPLAY_NAME_FIELD_NUMBER: _ClassVar[int] CREATE_TIME_FIELD_NUMBER: _ClassVar[int] UPDATE_TIME_FIELD_NUMBER: _ClassVar[int] DELETE_TIME_FIELD_NUMBER: _ClassVar[int] ETAG_FIELD_NUMBER: _ClassVar[int] LOCATION_FIELD_NUMBER: _ClassVar[int] service: str name: str type: str labels: _containers.ScalarMap[str, str] uid: str annotations: _containers.ScalarMap[str, str] display_name: str create_time: _timestamp_pb2.Timestamp update_time: _timestamp_pb2.Timestamp delete_time: _timestamp_pb2.Timestamp etag: str location: str def __init__( self, service: _Optional[str] = ..., name: _Optional[str] = ..., type: _Optional[str] = ..., labels: _Optional[_Mapping[str, str]] = ..., uid: _Optional[str] = ..., annotations: _Optional[_Mapping[str, str]] = ..., display_name: _Optional[str] = ..., create_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., update_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., delete_time: _Optional[_Union[_timestamp_pb2.Timestamp, _Mapping]] = ..., etag: _Optional[str] = ..., location: _Optional[str] = ..., ) -> None: ... ORIGIN_FIELD_NUMBER: _ClassVar[int] SOURCE_FIELD_NUMBER: _ClassVar[int] DESTINATION_FIELD_NUMBER: _ClassVar[int] REQUEST_FIELD_NUMBER: _ClassVar[int] RESPONSE_FIELD_NUMBER: _ClassVar[int] RESOURCE_FIELD_NUMBER: _ClassVar[int] API_FIELD_NUMBER: _ClassVar[int] EXTENSIONS_FIELD_NUMBER: _ClassVar[int] origin: AttributeContext.Peer source: AttributeContext.Peer destination: AttributeContext.Peer request: AttributeContext.Request response: AttributeContext.Response resource: AttributeContext.Resource api: AttributeContext.Api extensions: _containers.RepeatedCompositeFieldContainer[_any_pb2.Any] def __init__( self, origin: _Optional[_Union[AttributeContext.Peer, _Mapping]] = ..., source: _Optional[_Union[AttributeContext.Peer, _Mapping]] = ..., destination: _Optional[_Union[AttributeContext.Peer, _Mapping]] = ..., request: _Optional[_Union[AttributeContext.Request, _Mapping]] = ..., response: _Optional[_Union[AttributeContext.Response, _Mapping]] = ..., resource: _Optional[_Union[AttributeContext.Resource, _Mapping]] = ..., api: _Optional[_Union[AttributeContext.Api, _Mapping]] = ..., extensions: _Optional[_Iterable[_Union[_any_pb2.Any, _Mapping]]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/rpc/context/audit_context.proto0000644000000000000000000000344515177035226025152 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.rpc.context; import "google/protobuf/struct.proto"; option go_package = "google.golang.org/genproto/googleapis/rpc/context;context"; option java_multiple_files = true; option java_outer_classname = "AuditContextProto"; option java_package = "com.google.rpc.context"; // `AuditContext` provides information that is needed for audit logging. message AuditContext { // Serialized audit log. bytes audit_log = 1; // An API request message that is scrubbed based on the method annotation. // This field should only be filled if audit_log field is present. // Service Control will use this to assemble a complete log for Cloud Audit // Logs and Google internal audit logs. google.protobuf.Struct scrubbed_request = 2; // An API response message that is scrubbed based on the method annotation. // This field should only be filled if audit_log field is present. // Service Control will use this to assemble a complete log for Cloud Audit // Logs and Google internal audit logs. google.protobuf.Struct scrubbed_response = 3; // Number of scrubbed response items. int32 scrubbed_response_item_count = 4; // Audit resource name which is scrubbed. string target_resource = 5; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/rpc/context/audit_context_pb2.py0000644000000000000000000000456115177035224025200 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/rpc/context/audit_context.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n&google/rpc/context/audit_context.proto\x12\x12google.rpc.context\x1a\x1cgoogle/protobuf/struct.proto"\xc7\x01\n\x0c\x41uditContext\x12\x11\n\taudit_log\x18\x01 \x01(\x0c\x12\x31\n\x10scrubbed_request\x18\x02 \x01(\x0b\x32\x17.google.protobuf.Struct\x12\x32\n\x11scrubbed_response\x18\x03 \x01(\x0b\x32\x17.google.protobuf.Struct\x12$\n\x1cscrubbed_response_item_count\x18\x04 \x01(\x05\x12\x17\n\x0ftarget_resource\x18\x05 \x01(\tBh\n\x16\x63om.google.rpc.contextB\x11\x41uditContextProtoP\x01Z9google.golang.org/genproto/googleapis/rpc/context;contextb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.rpc.context.audit_context_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\026com.google.rpc.contextB\021AuditContextProtoP\001Z9google.golang.org/genproto/googleapis/rpc/context;context" _globals["_AUDITCONTEXT"]._serialized_start = 93 _globals["_AUDITCONTEXT"]._serialized_end = 292 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/rpc/context/audit_context_pb2.pyi0000644000000000000000000000360215177035226025346 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import struct_pb2 as _struct_pb2 DESCRIPTOR: _descriptor.FileDescriptor class AuditContext(_message.Message): __slots__ = ( "audit_log", "scrubbed_request", "scrubbed_response", "scrubbed_response_item_count", "target_resource", ) AUDIT_LOG_FIELD_NUMBER: _ClassVar[int] SCRUBBED_REQUEST_FIELD_NUMBER: _ClassVar[int] SCRUBBED_RESPONSE_FIELD_NUMBER: _ClassVar[int] SCRUBBED_RESPONSE_ITEM_COUNT_FIELD_NUMBER: _ClassVar[int] TARGET_RESOURCE_FIELD_NUMBER: _ClassVar[int] audit_log: bytes scrubbed_request: _struct_pb2.Struct scrubbed_response: _struct_pb2.Struct scrubbed_response_item_count: int target_resource: str def __init__( self, audit_log: _Optional[bytes] = ..., scrubbed_request: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., scrubbed_response: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., scrubbed_response_item_count: _Optional[int] = ..., target_resource: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/rpc/error_details.proto0000644000000000000000000003440715177035224023452 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.rpc; import "google/protobuf/duration.proto"; option go_package = "google.golang.org/genproto/googleapis/rpc/errdetails;errdetails"; option java_multiple_files = true; option java_outer_classname = "ErrorDetailsProto"; option java_package = "com.google.rpc"; option objc_class_prefix = "RPC"; // 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" // } // } message ErrorInfo { // 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_]+[A-Z0-9]`, which represents // UPPER_SNAKE_CASE. string reason = 1; // 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". string domain = 2; // Additional structured details about this error. // // Keys must match a regular expression of `[a-z][a-zA-Z0-9-_]+` 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. map metadata = 3; } // Describes when the clients can retry a failed request. Clients could ignore // the recommendation here or retry when this information is missing from error // responses. // // It's always recommended that clients should use exponential backoff when // retrying. // // Clients should wait until `retry_delay` amount of time has passed since // receiving the error response before retrying. If retrying requests also // fail, clients should use an exponential backoff scheme to gradually increase // the delay between retries based on `retry_delay`, until either a maximum // number of retries have been reached or a maximum retry delay cap has been // reached. message RetryInfo { // Clients should wait at least this long between retrying the same request. google.protobuf.Duration retry_delay = 1; } // Describes additional debugging info. message DebugInfo { // The stack trace entries indicating where the error occurred. repeated string stack_entries = 1; // Additional debugging information provided by the server. string detail = 2; } // Describes how a quota check failed. // // For example if a daily limit was exceeded for the calling project, // a service could respond with a QuotaFailure detail containing the project // id and the description of the quota limit that was exceeded. If the // calling project hasn't enabled the service in the developer console, then // a service could respond with the project id and set `service_disabled` // to true. // // Also see RetryInfo and Help types for other details about handling a // quota failure. message QuotaFailure { // A message type used to describe a single quota violation. For example, a // daily quota or a custom quota that was exceeded. message Violation { // The subject on which the quota check failed. // For example, "clientip:" or "project:". string subject = 1; // A description of how the quota check failed. Clients can use this // description to find more about the quota configuration in the service's // public documentation, or find the relevant quota limit to adjust through // developer console. // // For example: "Service disabled" or "Daily Limit for read operations // exceeded". string description = 2; // The API Service from which the `QuotaFailure.Violation` orginates. In // some cases, Quota issues originate from an API Service other than the one // that was called. In other words, a dependency of the called API Service // could be the cause of the `QuotaFailure`, and this field would have the // dependency API service name. // // For example, if the called API is Kubernetes Engine API // (container.googleapis.com), and a quota violation occurs in the // Kubernetes Engine API itself, this field would be // "container.googleapis.com". On the other hand, if the quota violation // occurs when the Kubernetes Engine API creates VMs in the Compute Engine // API (compute.googleapis.com), this field would be // "compute.googleapis.com". string api_service = 3; // The metric of the violated quota. A quota metric is a named counter to // measure usage, such as API requests or CPUs. When an activity occurs in a // service, such as Virtual Machine allocation, one or more quota metrics // may be affected. // // For example, "compute.googleapis.com/cpus_per_vm_family", // "storage.googleapis.com/internet_egress_bandwidth". string quota_metric = 4; // The id of the violated quota. Also know as "limit name", this is the // unique identifier of a quota in the context of an API service. // // For example, "CPUS-PER-VM-FAMILY-per-project-region". string quota_id = 5; // The dimensions of the violated quota. Every non-global quota is enforced // on a set of dimensions. While quota metric defines what to count, the // dimensions specify for what aspects the counter should be increased. // // For example, the quota "CPUs per region per VM family" enforces a limit // on the metric "compute.googleapis.com/cpus_per_vm_family" on dimensions // "region" and "vm_family". And if the violation occurred in region // "us-central1" and for VM family "n1", the quota_dimensions would be, // // { // "region": "us-central1", // "vm_family": "n1", // } // // When a quota is enforced globally, the quota_dimensions would always be // empty. map quota_dimensions = 6; // The enforced quota value at the time of the `QuotaFailure`. // // For example, if the enforced quota value at the time of the // `QuotaFailure` on the number of CPUs is "10", then the value of this // field would reflect this quantity. int64 quota_value = 7; // The new quota value being rolled out at the time of the violation. At the // completion of the rollout, this value will be enforced in place of // quota_value. If no rollout is in progress at the time of the violation, // this field is not set. // // For example, if at the time of the violation a rollout is in progress // changing the number of CPUs quota from 10 to 20, 20 would be the value of // this field. optional int64 future_quota_value = 8; } // Describes all quota violations. repeated Violation violations = 1; } // Describes what preconditions have failed. // // For example, if an RPC failed because it required the Terms of Service to be // acknowledged, it could list the terms of service violation in the // PreconditionFailure message. message PreconditionFailure { // A message type used to describe a single precondition failure. message Violation { // The type of PreconditionFailure. We recommend using a service-specific // enum type to define the supported precondition violation subjects. For // example, "TOS" for "Terms of Service violation". string type = 1; // The subject, relative to the type, that failed. // For example, "google.com/cloud" relative to the "TOS" type would indicate // which terms of service is being referenced. string subject = 2; // A description of how the precondition failed. Developers can use this // description to understand how to fix the failure. // // For example: "Terms of service not accepted". string description = 3; } // Describes all precondition violations. repeated Violation violations = 1; } // Describes violations in a client request. This error type focuses on the // syntactic aspects of the request. message BadRequest { // A message type used to describe a single bad request field. message FieldViolation { // A path that leads to a field in the request body. The value will be a // sequence of dot-separated identifiers that identify a protocol buffer // field. // // Consider the following: // // message CreateContactRequest { // message EmailAddress { // enum Type { // TYPE_UNSPECIFIED = 0; // HOME = 1; // WORK = 2; // } // // optional string email = 1; // repeated EmailType type = 2; // } // // string full_name = 1; // repeated EmailAddress email_addresses = 2; // } // // In this example, in proto `field` could take one of the following values: // // * `full_name` for a violation in the `full_name` value // * `email_addresses[0].email` for a violation in the `email` field of the // first `email_addresses` message // * `email_addresses[2].type[1]` for a violation in the second `type` // value in the third `email_addresses` message. // // In JSON, the same values are represented as: // // * `fullName` for a violation in the `fullName` value // * `emailAddresses[0].email` for a violation in the `email` field of the // first `emailAddresses` message // * `emailAddresses[2].type[1]` for a violation in the second `type` // value in the third `emailAddresses` message. string field = 1; // A description of why the request element is bad. string description = 2; // The reason of the field-level error. This is a constant value that // identifies the proximate cause of the field-level error. It should // uniquely identify the type of the FieldViolation within the scope of the // google.rpc.ErrorInfo.domain. This should be at most 63 // characters and match a regular expression of `[A-Z][A-Z0-9_]+[A-Z0-9]`, // which represents UPPER_SNAKE_CASE. string reason = 3; // Provides a localized error message for field-level errors that is safe to // return to the API consumer. LocalizedMessage localized_message = 4; } // Describes all violations in a client request. repeated FieldViolation field_violations = 1; } // Contains metadata about the request that clients can attach when filing a bug // or providing other forms of feedback. message RequestInfo { // An opaque string that should only be interpreted by the service generating // it. For example, it can be used to identify requests in the service's logs. string request_id = 1; // Any data that was used to serve this request. For example, an encrypted // stack trace that can be sent back to the service provider for debugging. string serving_data = 2; } // Describes the resource that is being accessed. message ResourceInfo { // A name for the type of resource being accessed, e.g. "sql table", // "cloud storage bucket", "file", "Google calendar"; or the type URL // of the resource: e.g. "type.googleapis.com/google.pubsub.v1.Topic". string resource_type = 1; // The name of the resource being accessed. For example, a shared calendar // name: "example.com_4fghdhgsrgh@group.calendar.google.com", if the current // error is // [google.rpc.Code.PERMISSION_DENIED][google.rpc.Code.PERMISSION_DENIED]. string resource_name = 2; // The owner of the resource (optional). // For example, "user:" or "project:". string owner = 3; // Describes what error is encountered when accessing this resource. // For example, updating a cloud project may require the `writer` permission // on the developer console project. string description = 4; } // Provides links to documentation or for performing an out of band action. // // For example, if a quota check failed with an error indicating the calling // project hasn't enabled the accessed service, this can contain a URL pointing // directly to the right place in the developer console to flip the bit. message Help { // Describes a URL link. message Link { // Describes what the link offers. string description = 1; // The URL of the link. string url = 2; } // URL(s) pointing to additional information on handling the current error. repeated Link links = 1; } // Provides a localized error message that is safe to return to the user // which can be attached to an RPC error. message LocalizedMessage { // The locale used following the specification defined at // https://www.rfc-editor.org/rfc/bcp/bcp47.txt. // Examples are: "en-US", "fr-CH", "es-MX" string locale = 1; // The localized error message in the above locale. string message = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/rpc/error_details_pb2.py0000644000000000000000000001447215177035222023500 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/rpc/error_details.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1egoogle/rpc/error_details.proto\x12\ngoogle.rpc\x1a\x1egoogle/protobuf/duration.proto"\x93\x01\n\tErrorInfo\x12\x0e\n\x06reason\x18\x01 \x01(\t\x12\x0e\n\x06\x64omain\x18\x02 \x01(\t\x12\x35\n\x08metadata\x18\x03 \x03(\x0b\x32#.google.rpc.ErrorInfo.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01";\n\tRetryInfo\x12.\n\x0bretry_delay\x18\x01 \x01(\x0b\x32\x19.google.protobuf.Duration"2\n\tDebugInfo\x12\x15\n\rstack_entries\x18\x01 \x03(\t\x12\x0e\n\x06\x64\x65tail\x18\x02 \x01(\t"\x8f\x03\n\x0cQuotaFailure\x12\x36\n\nviolations\x18\x01 \x03(\x0b\x32".google.rpc.QuotaFailure.Violation\x1a\xc6\x02\n\tViolation\x12\x0f\n\x07subject\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x13\n\x0b\x61pi_service\x18\x03 \x01(\t\x12\x14\n\x0cquota_metric\x18\x04 \x01(\t\x12\x10\n\x08quota_id\x18\x05 \x01(\t\x12Q\n\x10quota_dimensions\x18\x06 \x03(\x0b\x32\x37.google.rpc.QuotaFailure.Violation.QuotaDimensionsEntry\x12\x13\n\x0bquota_value\x18\x07 \x01(\x03\x12\x1f\n\x12\x66uture_quota_value\x18\x08 \x01(\x03H\x00\x88\x01\x01\x1a\x36\n\x14QuotaDimensionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42\x15\n\x13_future_quota_value"\x95\x01\n\x13PreconditionFailure\x12=\n\nviolations\x18\x01 \x03(\x0b\x32).google.rpc.PreconditionFailure.Violation\x1a?\n\tViolation\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x0f\n\x07subject\x18\x02 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x03 \x01(\t"\xcc\x01\n\nBadRequest\x12?\n\x10\x66ield_violations\x18\x01 \x03(\x0b\x32%.google.rpc.BadRequest.FieldViolation\x1a}\n\x0e\x46ieldViolation\x12\r\n\x05\x66ield\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x37\n\x11localized_message\x18\x04 \x01(\x0b\x32\x1c.google.rpc.LocalizedMessage"7\n\x0bRequestInfo\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x14\n\x0cserving_data\x18\x02 \x01(\t"`\n\x0cResourceInfo\x12\x15\n\rresource_type\x18\x01 \x01(\t\x12\x15\n\rresource_name\x18\x02 \x01(\t\x12\r\n\x05owner\x18\x03 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x04 \x01(\t"V\n\x04Help\x12$\n\x05links\x18\x01 \x03(\x0b\x32\x15.google.rpc.Help.Link\x1a(\n\x04Link\x12\x13\n\x0b\x64\x65scription\x18\x01 \x01(\t\x12\x0b\n\x03url\x18\x02 \x01(\t"3\n\x10LocalizedMessage\x12\x0e\n\x06locale\x18\x01 \x01(\t\x12\x0f\n\x07message\x18\x02 \x01(\tBl\n\x0e\x63om.google.rpcB\x11\x45rrorDetailsProtoP\x01Z?google.golang.org/genproto/googleapis/rpc/errdetails;errdetails\xa2\x02\x03RPCb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.rpc.error_details_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.rpcB\021ErrorDetailsProtoP\001Z?google.golang.org/genproto/googleapis/rpc/errdetails;errdetails\242\002\003RPC" _globals["_ERRORINFO_METADATAENTRY"]._options = None _globals["_ERRORINFO_METADATAENTRY"]._serialized_options = b"8\001" _globals["_QUOTAFAILURE_VIOLATION_QUOTADIMENSIONSENTRY"]._options = None _globals[ "_QUOTAFAILURE_VIOLATION_QUOTADIMENSIONSENTRY" ]._serialized_options = b"8\001" _globals["_ERRORINFO"]._serialized_start = 79 _globals["_ERRORINFO"]._serialized_end = 226 _globals["_ERRORINFO_METADATAENTRY"]._serialized_start = 179 _globals["_ERRORINFO_METADATAENTRY"]._serialized_end = 226 _globals["_RETRYINFO"]._serialized_start = 228 _globals["_RETRYINFO"]._serialized_end = 287 _globals["_DEBUGINFO"]._serialized_start = 289 _globals["_DEBUGINFO"]._serialized_end = 339 _globals["_QUOTAFAILURE"]._serialized_start = 342 _globals["_QUOTAFAILURE"]._serialized_end = 741 _globals["_QUOTAFAILURE_VIOLATION"]._serialized_start = 415 _globals["_QUOTAFAILURE_VIOLATION"]._serialized_end = 741 _globals["_QUOTAFAILURE_VIOLATION_QUOTADIMENSIONSENTRY"]._serialized_start = 664 _globals["_QUOTAFAILURE_VIOLATION_QUOTADIMENSIONSENTRY"]._serialized_end = 718 _globals["_PRECONDITIONFAILURE"]._serialized_start = 744 _globals["_PRECONDITIONFAILURE"]._serialized_end = 893 _globals["_PRECONDITIONFAILURE_VIOLATION"]._serialized_start = 830 _globals["_PRECONDITIONFAILURE_VIOLATION"]._serialized_end = 893 _globals["_BADREQUEST"]._serialized_start = 896 _globals["_BADREQUEST"]._serialized_end = 1100 _globals["_BADREQUEST_FIELDVIOLATION"]._serialized_start = 975 _globals["_BADREQUEST_FIELDVIOLATION"]._serialized_end = 1100 _globals["_REQUESTINFO"]._serialized_start = 1102 _globals["_REQUESTINFO"]._serialized_end = 1157 _globals["_RESOURCEINFO"]._serialized_start = 1159 _globals["_RESOURCEINFO"]._serialized_end = 1255 _globals["_HELP"]._serialized_start = 1257 _globals["_HELP"]._serialized_end = 1343 _globals["_HELP_LINK"]._serialized_start = 1303 _globals["_HELP_LINK"]._serialized_end = 1343 _globals["_LOCALIZEDMESSAGE"]._serialized_start = 1345 _globals["_LOCALIZEDMESSAGE"]._serialized_end = 1396 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/rpc/error_details_pb2.pyi0000644000000000000000000002036415177035226023652 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import duration_pb2 as _duration_pb2 from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class ErrorInfo(_message.Message): __slots__ = ("reason", "domain", "metadata") class MetadataEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... REASON_FIELD_NUMBER: _ClassVar[int] DOMAIN_FIELD_NUMBER: _ClassVar[int] METADATA_FIELD_NUMBER: _ClassVar[int] reason: str domain: str metadata: _containers.ScalarMap[str, str] def __init__( self, reason: _Optional[str] = ..., domain: _Optional[str] = ..., metadata: _Optional[_Mapping[str, str]] = ..., ) -> None: ... class RetryInfo(_message.Message): __slots__ = ("retry_delay",) RETRY_DELAY_FIELD_NUMBER: _ClassVar[int] retry_delay: _duration_pb2.Duration def __init__( self, retry_delay: _Optional[_Union[_duration_pb2.Duration, _Mapping]] = ... ) -> None: ... class DebugInfo(_message.Message): __slots__ = ("stack_entries", "detail") STACK_ENTRIES_FIELD_NUMBER: _ClassVar[int] DETAIL_FIELD_NUMBER: _ClassVar[int] stack_entries: _containers.RepeatedScalarFieldContainer[str] detail: str def __init__( self, stack_entries: _Optional[_Iterable[str]] = ..., detail: _Optional[str] = ..., ) -> None: ... class QuotaFailure(_message.Message): __slots__ = ("violations",) class Violation(_message.Message): __slots__ = ( "subject", "description", "api_service", "quota_metric", "quota_id", "quota_dimensions", "quota_value", "future_quota_value", ) class QuotaDimensionsEntry(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... SUBJECT_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] API_SERVICE_FIELD_NUMBER: _ClassVar[int] QUOTA_METRIC_FIELD_NUMBER: _ClassVar[int] QUOTA_ID_FIELD_NUMBER: _ClassVar[int] QUOTA_DIMENSIONS_FIELD_NUMBER: _ClassVar[int] QUOTA_VALUE_FIELD_NUMBER: _ClassVar[int] FUTURE_QUOTA_VALUE_FIELD_NUMBER: _ClassVar[int] subject: str description: str api_service: str quota_metric: str quota_id: str quota_dimensions: _containers.ScalarMap[str, str] quota_value: int future_quota_value: int def __init__( self, subject: _Optional[str] = ..., description: _Optional[str] = ..., api_service: _Optional[str] = ..., quota_metric: _Optional[str] = ..., quota_id: _Optional[str] = ..., quota_dimensions: _Optional[_Mapping[str, str]] = ..., quota_value: _Optional[int] = ..., future_quota_value: _Optional[int] = ..., ) -> None: ... VIOLATIONS_FIELD_NUMBER: _ClassVar[int] violations: _containers.RepeatedCompositeFieldContainer[QuotaFailure.Violation] def __init__( self, violations: _Optional[ _Iterable[_Union[QuotaFailure.Violation, _Mapping]] ] = ..., ) -> None: ... class PreconditionFailure(_message.Message): __slots__ = ("violations",) class Violation(_message.Message): __slots__ = ("type", "subject", "description") TYPE_FIELD_NUMBER: _ClassVar[int] SUBJECT_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] type: str subject: str description: str def __init__( self, type: _Optional[str] = ..., subject: _Optional[str] = ..., description: _Optional[str] = ..., ) -> None: ... VIOLATIONS_FIELD_NUMBER: _ClassVar[int] violations: _containers.RepeatedCompositeFieldContainer[ PreconditionFailure.Violation ] def __init__( self, violations: _Optional[ _Iterable[_Union[PreconditionFailure.Violation, _Mapping]] ] = ..., ) -> None: ... class BadRequest(_message.Message): __slots__ = ("field_violations",) class FieldViolation(_message.Message): __slots__ = ("field", "description", "reason", "localized_message") FIELD_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] REASON_FIELD_NUMBER: _ClassVar[int] LOCALIZED_MESSAGE_FIELD_NUMBER: _ClassVar[int] field: str description: str reason: str localized_message: LocalizedMessage def __init__( self, field: _Optional[str] = ..., description: _Optional[str] = ..., reason: _Optional[str] = ..., localized_message: _Optional[_Union[LocalizedMessage, _Mapping]] = ..., ) -> None: ... FIELD_VIOLATIONS_FIELD_NUMBER: _ClassVar[int] field_violations: _containers.RepeatedCompositeFieldContainer[ BadRequest.FieldViolation ] def __init__( self, field_violations: _Optional[ _Iterable[_Union[BadRequest.FieldViolation, _Mapping]] ] = ..., ) -> None: ... class RequestInfo(_message.Message): __slots__ = ("request_id", "serving_data") REQUEST_ID_FIELD_NUMBER: _ClassVar[int] SERVING_DATA_FIELD_NUMBER: _ClassVar[int] request_id: str serving_data: str def __init__( self, request_id: _Optional[str] = ..., serving_data: _Optional[str] = ... ) -> None: ... class ResourceInfo(_message.Message): __slots__ = ("resource_type", "resource_name", "owner", "description") RESOURCE_TYPE_FIELD_NUMBER: _ClassVar[int] RESOURCE_NAME_FIELD_NUMBER: _ClassVar[int] OWNER_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] resource_type: str resource_name: str owner: str description: str def __init__( self, resource_type: _Optional[str] = ..., resource_name: _Optional[str] = ..., owner: _Optional[str] = ..., description: _Optional[str] = ..., ) -> None: ... class Help(_message.Message): __slots__ = ("links",) class Link(_message.Message): __slots__ = ("description", "url") DESCRIPTION_FIELD_NUMBER: _ClassVar[int] URL_FIELD_NUMBER: _ClassVar[int] description: str url: str def __init__( self, description: _Optional[str] = ..., url: _Optional[str] = ... ) -> None: ... LINKS_FIELD_NUMBER: _ClassVar[int] links: _containers.RepeatedCompositeFieldContainer[Help.Link] def __init__( self, links: _Optional[_Iterable[_Union[Help.Link, _Mapping]]] = ... ) -> None: ... class LocalizedMessage(_message.Message): __slots__ = ("locale", "message") LOCALE_FIELD_NUMBER: _ClassVar[int] MESSAGE_FIELD_NUMBER: _ClassVar[int] locale: str message: str def __init__( self, locale: _Optional[str] = ..., message: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/rpc/http.proto0000644000000000000000000000362415177035224021570 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.rpc; option go_package = "google.golang.org/genproto/googleapis/rpc/http;http"; option java_multiple_files = true; option java_outer_classname = "HttpProto"; option java_package = "com.google.rpc"; option objc_class_prefix = "RPC"; // Represents an HTTP request. message HttpRequest { // The HTTP request method. string method = 1; // The HTTP request URI. string uri = 2; // The HTTP request headers. The ordering of the headers is significant. // Multiple headers with the same key may present for the request. repeated HttpHeader headers = 3; // The HTTP request body. If the body is not expected, it should be empty. bytes body = 4; } // Represents an HTTP response. message HttpResponse { // The HTTP status code, such as 200 or 404. int32 status = 1; // The HTTP reason phrase, such as "OK" or "Not Found". string reason = 2; // The HTTP response headers. The ordering of the headers is significant. // Multiple headers with the same key may present for the response. repeated HttpHeader headers = 3; // The HTTP response body. If the body is not expected, it should be empty. bytes body = 4; } // Represents an HTTP header. message HttpHeader { // The HTTP header key. It is case insensitive. string key = 1; // The HTTP header value. string value = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/rpc/http_pb2.py0000644000000000000000000000501115177035224021610 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/rpc/http.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x15google/rpc/http.proto\x12\ngoogle.rpc"a\n\x0bHttpRequest\x12\x0e\n\x06method\x18\x01 \x01(\t\x12\x0b\n\x03uri\x18\x02 \x01(\t\x12\'\n\x07headers\x18\x03 \x03(\x0b\x32\x16.google.rpc.HttpHeader\x12\x0c\n\x04\x62ody\x18\x04 \x01(\x0c"e\n\x0cHttpResponse\x12\x0e\n\x06status\x18\x01 \x01(\x05\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\'\n\x07headers\x18\x03 \x03(\x0b\x32\x16.google.rpc.HttpHeader\x12\x0c\n\x04\x62ody\x18\x04 \x01(\x0c"(\n\nHttpHeader\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\tBX\n\x0e\x63om.google.rpcB\tHttpProtoP\x01Z3google.golang.org/genproto/googleapis/rpc/http;http\xa2\x02\x03RPCb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.rpc.http_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.rpcB\tHttpProtoP\001Z3google.golang.org/genproto/googleapis/rpc/http;http\242\002\003RPC" _globals["_HTTPREQUEST"]._serialized_start = 37 _globals["_HTTPREQUEST"]._serialized_end = 134 _globals["_HTTPRESPONSE"]._serialized_start = 136 _globals["_HTTPRESPONSE"]._serialized_end = 237 _globals["_HTTPHEADER"]._serialized_start = 239 _globals["_HTTPHEADER"]._serialized_end = 279 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/rpc/http_pb2.pyi0000644000000000000000000000464315177035223021772 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class HttpRequest(_message.Message): __slots__ = ("method", "uri", "headers", "body") METHOD_FIELD_NUMBER: _ClassVar[int] URI_FIELD_NUMBER: _ClassVar[int] HEADERS_FIELD_NUMBER: _ClassVar[int] BODY_FIELD_NUMBER: _ClassVar[int] method: str uri: str headers: _containers.RepeatedCompositeFieldContainer[HttpHeader] body: bytes def __init__( self, method: _Optional[str] = ..., uri: _Optional[str] = ..., headers: _Optional[_Iterable[_Union[HttpHeader, _Mapping]]] = ..., body: _Optional[bytes] = ..., ) -> None: ... class HttpResponse(_message.Message): __slots__ = ("status", "reason", "headers", "body") STATUS_FIELD_NUMBER: _ClassVar[int] REASON_FIELD_NUMBER: _ClassVar[int] HEADERS_FIELD_NUMBER: _ClassVar[int] BODY_FIELD_NUMBER: _ClassVar[int] status: int reason: str headers: _containers.RepeatedCompositeFieldContainer[HttpHeader] body: bytes def __init__( self, status: _Optional[int] = ..., reason: _Optional[str] = ..., headers: _Optional[_Iterable[_Union[HttpHeader, _Mapping]]] = ..., body: _Optional[bytes] = ..., ) -> None: ... class HttpHeader(_message.Message): __slots__ = ("key", "value") KEY_FIELD_NUMBER: _ClassVar[int] VALUE_FIELD_NUMBER: _ClassVar[int] key: str value: str def __init__( self, key: _Optional[str] = ..., value: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/rpc/status.proto0000644000000000000000000000355615177035227022143 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.rpc; import "google/protobuf/any.proto"; option go_package = "google.golang.org/genproto/googleapis/rpc/status;status"; option java_multiple_files = true; option java_outer_classname = "StatusProto"; option java_package = "com.google.rpc"; option objc_class_prefix = "RPC"; // 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). message Status { // The status code, which should be an enum value of // [google.rpc.Code][google.rpc.Code]. int32 code = 1; // 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][google.rpc.Status.details] field, or localized // by the client. string message = 2; // A list of messages that carry the error details. There is a common set of // message types for APIs to use. repeated google.protobuf.Any details = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/rpc/status_pb2.py0000644000000000000000000000416315177035223022162 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/rpc/status.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x17google/rpc/status.proto\x12\ngoogle.rpc\x1a\x19google/protobuf/any.proto"N\n\x06Status\x12\x0c\n\x04\x63ode\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\t\x12%\n\x07\x64\x65tails\x18\x03 \x03(\x0b\x32\x14.google.protobuf.AnyB^\n\x0e\x63om.google.rpcB\x0bStatusProtoP\x01Z7google.golang.org/genproto/googleapis/rpc/status;status\xa2\x02\x03RPCb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.rpc.status_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\016com.google.rpcB\013StatusProtoP\001Z7google.golang.org/genproto/googleapis/rpc/status;status\242\002\003RPC" _globals["_STATUS"]._serialized_start = 66 _globals["_STATUS"]._serialized_end = 144 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/rpc/status_pb2.pyi0000644000000000000000000000277315177035226022343 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import any_pb2 as _any_pb2 from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class Status(_message.Message): __slots__ = ("code", "message", "details") CODE_FIELD_NUMBER: _ClassVar[int] MESSAGE_FIELD_NUMBER: _ClassVar[int] DETAILS_FIELD_NUMBER: _ClassVar[int] code: int message: str details: _containers.RepeatedCompositeFieldContainer[_any_pb2.Any] def __init__( self, code: _Optional[int] = ..., message: _Optional[str] = ..., details: _Optional[_Iterable[_Union[_any_pb2.Any, _Mapping]]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1778138211.077103 googleapis_common_protos-1.75.0/google/type/0000755000000000000000000000000015177036143017715 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/calendar_period.proto0000644000000000000000000000334215177035222024114 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/calendarperiod;calendarperiod"; option java_multiple_files = true; option java_outer_classname = "CalendarPeriodProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // A `CalendarPeriod` represents the abstract concept of a time period that has // a canonical start. Grammatically, "the start of the current // `CalendarPeriod`." All calendar times begin at midnight UTC. enum CalendarPeriod { // Undefined period, raises an error. CALENDAR_PERIOD_UNSPECIFIED = 0; // A day. DAY = 1; // A week. Weeks begin on Monday, following // [ISO 8601](https://en.wikipedia.org/wiki/ISO_week_date). WEEK = 2; // A fortnight. The first calendar fortnight of the year begins at the start // of week 1 according to // [ISO 8601](https://en.wikipedia.org/wiki/ISO_week_date). FORTNIGHT = 3; // A month. MONTH = 4; // A quarter. Quarters start on dates 1-Jan, 1-Apr, 1-Jul, and 1-Oct of each // year. QUARTER = 5; // A half-year. Half-years start on dates 1-Jan and 1-Jul. HALF = 6; // A year. YEAR = 7; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/calendar_period_pb2.py0000644000000000000000000000435615177035226024156 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/calendar_period.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n!google/type/calendar_period.proto\x12\x0bgoogle.type*\x7f\n\x0e\x43\x61lendarPeriod\x12\x1f\n\x1b\x43\x41LENDAR_PERIOD_UNSPECIFIED\x10\x00\x12\x07\n\x03\x44\x41Y\x10\x01\x12\x08\n\x04WEEK\x10\x02\x12\r\n\tFORTNIGHT\x10\x03\x12\t\n\x05MONTH\x10\x04\x12\x0b\n\x07QUARTER\x10\x05\x12\x08\n\x04HALF\x10\x06\x12\x08\n\x04YEAR\x10\x07\x42x\n\x0f\x63om.google.typeB\x13\x43\x61lendarPeriodProtoP\x01ZHgoogle.golang.org/genproto/googleapis/type/calendarperiod;calendarperiod\xa2\x02\x03GTPb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.type.calendar_period_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\023CalendarPeriodProtoP\001ZHgoogle.golang.org/genproto/googleapis/type/calendarperiod;calendarperiod\242\002\003GTP" _globals["_CALENDARPERIOD"]._serialized_start = 50 _globals["_CALENDARPERIOD"]._serialized_end = 177 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/type/calendar_period_pb2.pyi0000644000000000000000000000257015177035224024321 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class CalendarPeriod(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () CALENDAR_PERIOD_UNSPECIFIED: _ClassVar[CalendarPeriod] DAY: _ClassVar[CalendarPeriod] WEEK: _ClassVar[CalendarPeriod] FORTNIGHT: _ClassVar[CalendarPeriod] MONTH: _ClassVar[CalendarPeriod] QUARTER: _ClassVar[CalendarPeriod] HALF: _ClassVar[CalendarPeriod] YEAR: _ClassVar[CalendarPeriod] CALENDAR_PERIOD_UNSPECIFIED: CalendarPeriod DAY: CalendarPeriod WEEK: CalendarPeriod FORTNIGHT: CalendarPeriod MONTH: CalendarPeriod QUARTER: CalendarPeriod HALF: CalendarPeriod YEAR: CalendarPeriod ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/type/color.proto0000644000000000000000000001432315177035223022121 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; import "google/protobuf/wrappers.proto"; option go_package = "google.golang.org/genproto/googleapis/type/color;color"; option java_multiple_files = true; option java_outer_classname = "ColorProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Represents a color in the RGBA color space. This representation is designed // for simplicity of conversion to and from color representations in various // languages over compactness. For example, the fields of this representation // can be trivially provided to the constructor of `java.awt.Color` in Java; it // can also be trivially provided to UIColor's `+colorWithRed:green:blue:alpha` // method in iOS; and, with just a little work, it can be easily formatted into // a CSS `rgba()` string in JavaScript. // // This reference page doesn't have information about the absolute color // space that should be used to interpret the RGB value—for example, sRGB, // Adobe RGB, // DCI-P3, and BT.2020. By default, applications should assume the sRGB color // space. // // When color equality needs to be decided, implementations, unless documented // otherwise, treat two colors as equal if all their red, green, blue, and alpha // values each differ by at most `1e-5`. // // Example (Java): // // import com.google.type.Color; // // // ... // public static java.awt.Color fromProto(Color protocolor) { // float alpha = protocolor.hasAlpha() // ? protocolor.getAlpha().getValue() // : 1.0; // // return new java.awt.Color( // protocolor.getRed(), // protocolor.getGreen(), // protocolor.getBlue(), // alpha); // } // // public static Color toProto(java.awt.Color color) { // float red = (float) color.getRed(); // float green = (float) color.getGreen(); // float blue = (float) color.getBlue(); // float denominator = 255.0; // Color.Builder resultBuilder = // Color // .newBuilder() // .setRed(red / denominator) // .setGreen(green / denominator) // .setBlue(blue / denominator); // int alpha = color.getAlpha(); // if (alpha != 255) { // result.setAlpha( // FloatValue // .newBuilder() // .setValue(((float) alpha) / denominator) // .build()); // } // return resultBuilder.build(); // } // // ... // // Example (iOS / Obj-C): // // // ... // static UIColor* fromProto(Color* protocolor) { // float red = [protocolor red]; // float green = [protocolor green]; // float blue = [protocolor blue]; // FloatValue* alpha_wrapper = [protocolor alpha]; // float alpha = 1.0; // if (alpha_wrapper != nil) { // alpha = [alpha_wrapper value]; // } // return [UIColor colorWithRed:red green:green blue:blue alpha:alpha]; // } // // static Color* toProto(UIColor* color) { // CGFloat red, green, blue, alpha; // if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) { // return nil; // } // Color* result = [[Color alloc] init]; // [result setRed:red]; // [result setGreen:green]; // [result setBlue:blue]; // if (alpha <= 0.9999) { // [result setAlpha:floatWrapperWithValue(alpha)]; // } // [result autorelease]; // return result; // } // // ... // // Example (JavaScript): // // // ... // // var protoToCssColor = function(rgb_color) { // var redFrac = rgb_color.red || 0.0; // var greenFrac = rgb_color.green || 0.0; // var blueFrac = rgb_color.blue || 0.0; // var red = Math.floor(redFrac * 255); // var green = Math.floor(greenFrac * 255); // var blue = Math.floor(blueFrac * 255); // // if (!('alpha' in rgb_color)) { // return rgbToCssColor(red, green, blue); // } // // var alphaFrac = rgb_color.alpha.value || 0.0; // var rgbParams = [red, green, blue].join(','); // return ['rgba(', rgbParams, ',', alphaFrac, ')'].join(''); // }; // // var rgbToCssColor = function(red, green, blue) { // var rgbNumber = new Number((red << 16) | (green << 8) | blue); // var hexString = rgbNumber.toString(16); // var missingZeros = 6 - hexString.length; // var resultBuilder = ['#']; // for (var i = 0; i < missingZeros; i++) { // resultBuilder.push('0'); // } // resultBuilder.push(hexString); // return resultBuilder.join(''); // }; // // // ... message Color { // The amount of red in the color as a value in the interval [0, 1]. float red = 1; // The amount of green in the color as a value in the interval [0, 1]. float green = 2; // The amount of blue in the color as a value in the interval [0, 1]. float blue = 3; // The fraction of this color that should be applied to the pixel. That is, // the final pixel color is defined by the equation: // // `pixel color = alpha * (this color) + (1.0 - alpha) * (background color)` // // This means that a value of 1.0 corresponds to a solid color, whereas // a value of 0.0 corresponds to a completely transparent color. This // uses a wrapper message rather than a simple float scalar so that it is // possible to distinguish between a default value and the value being unset. // If omitted, this color object is rendered as a solid color // (as if the alpha value had been explicitly given a value of 1.0). google.protobuf.FloatValue alpha = 4; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/color_pb2.py0000644000000000000000000000424215177035222022147 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/color.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import wrappers_pb2 as google_dot_protobuf_dot_wrappers__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x17google/type/color.proto\x12\x0bgoogle.type\x1a\x1egoogle/protobuf/wrappers.proto"]\n\x05\x43olor\x12\x0b\n\x03red\x18\x01 \x01(\x02\x12\r\n\x05green\x18\x02 \x01(\x02\x12\x0c\n\x04\x62lue\x18\x03 \x01(\x02\x12*\n\x05\x61lpha\x18\x04 \x01(\x0b\x32\x1b.google.protobuf.FloatValueB]\n\x0f\x63om.google.typeB\nColorProtoP\x01Z6google.golang.org/genproto/googleapis/type/color;color\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.type.color_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\nColorProtoP\001Z6google.golang.org/genproto/googleapis/type/color;color\242\002\003GTP" _globals["_COLOR"]._serialized_start = 72 _globals["_COLOR"]._serialized_end = 165 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/type/color_pb2.pyi0000644000000000000000000000272415177035223022324 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import wrappers_pb2 as _wrappers_pb2 DESCRIPTOR: _descriptor.FileDescriptor class Color(_message.Message): __slots__ = ("red", "green", "blue", "alpha") RED_FIELD_NUMBER: _ClassVar[int] GREEN_FIELD_NUMBER: _ClassVar[int] BLUE_FIELD_NUMBER: _ClassVar[int] ALPHA_FIELD_NUMBER: _ClassVar[int] red: float green: float blue: float alpha: _wrappers_pb2.FloatValue def __init__( self, red: _Optional[float] = ..., green: _Optional[float] = ..., blue: _Optional[float] = ..., alpha: _Optional[_Union[_wrappers_pb2.FloatValue, _Mapping]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/type/date.proto0000644000000000000000000000373215177035224021723 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/date;date"; option java_multiple_files = true; option java_outer_classname = "DateProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // 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.TimeOfDay] // * [google.type.DateTime][google.type.DateTime] // * [google.protobuf.Timestamp][google.protobuf.Timestamp] message Date { // Year of the date. Must be from 1 to 9999, or 0 to specify a date without // a year. int32 year = 1; // Month of a year. Must be from 1 to 12, or 0 to specify a year without a // month and day. int32 month = 2; // 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. int32 day = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/date_pb2.py0000644000000000000000000000373515177035222021754 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/date.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x16google/type/date.proto\x12\x0bgoogle.type"0\n\x04\x44\x61te\x12\x0c\n\x04year\x18\x01 \x01(\x05\x12\r\n\x05month\x18\x02 \x01(\x05\x12\x0b\n\x03\x64\x61y\x18\x03 \x01(\x05\x42Z\n\x0f\x63om.google.typeB\tDateProtoP\x01Z4google.golang.org/genproto/googleapis/type/date;date\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.type.date_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\tDateProtoP\001Z4google.golang.org/genproto/googleapis/type/date;date\242\002\003GTP" _globals["_DATE"]._serialized_start = 39 _globals["_DATE"]._serialized_end = 87 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/date_pb2.pyi0000644000000000000000000000224315177035226022122 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class Date(_message.Message): __slots__ = ("year", "month", "day") YEAR_FIELD_NUMBER: _ClassVar[int] MONTH_FIELD_NUMBER: _ClassVar[int] DAY_FIELD_NUMBER: _ClassVar[int] year: int month: int day: int def __init__( self, year: _Optional[int] = ..., month: _Optional[int] = ..., day: _Optional[int] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/datetime.proto0000644000000000000000000000772315177035226022610 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; import "google/protobuf/duration.proto"; option go_package = "google.golang.org/genproto/googleapis/type/datetime;datetime"; option java_multiple_files = true; option java_outer_classname = "DateTimeProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Represents civil time (or occasionally physical time). // // This type can represent a civil time in one of a few possible ways: // // * When utc_offset is set and time_zone is unset: a civil time on a calendar // day with a particular offset from UTC. // * When time_zone is set and utc_offset is unset: a civil time on a calendar // day in a particular time zone. // * When neither time_zone nor utc_offset is set: a civil time on a calendar // day in local time. // // The date is relative to the Proleptic Gregorian Calendar. // // If year, month, or day are 0, the DateTime is considered not to have a // specific year, month, or day respectively. // // This type may also be used to represent a physical time if all the date and // time fields are set and either case of the `time_offset` oneof is set. // Consider using `Timestamp` message for physical time instead. If your use // case also would like to store the user's timezone, that can be done in // another field. // // This type is more flexible than some applications may want. Make sure to // document and validate your application's limitations. message DateTime { // Optional. Year of date. Must be from 1 to 9999, or 0 if specifying a // datetime without a year. int32 year = 1; // Optional. Month of year. Must be from 1 to 12, or 0 if specifying a // datetime without a month. int32 month = 2; // Optional. Day of month. Must be from 1 to 31 and valid for the year and // month, or 0 if specifying a datetime without a day. int32 day = 3; // Optional. Hours of day in 24 hour format. Should be from 0 to 23, defaults // to 0 (midnight). An API may choose to allow the value "24:00:00" for // scenarios like business closing time. int32 hours = 4; // Optional. Minutes of hour of day. Must be from 0 to 59, defaults to 0. int32 minutes = 5; // Optional. Seconds of minutes of the time. Must normally be from 0 to 59, // defaults to 0. An API may allow the value 60 if it allows leap-seconds. int32 seconds = 6; // Optional. Fractions of seconds in nanoseconds. Must be from 0 to // 999,999,999, defaults to 0. int32 nanos = 7; // Optional. Specifies either the UTC offset or the time zone of the DateTime. // Choose carefully between them, considering that time zone data may change // in the future (for example, a country modifies their DST start/end dates, // and future DateTimes in the affected range had already been stored). // If omitted, the DateTime is considered to be in local time. oneof time_offset { // UTC offset. Must be whole seconds, between -18 hours and +18 hours. // For example, a UTC offset of -4:00 would be represented as // { seconds: -14400 }. google.protobuf.Duration utc_offset = 8; // Time zone. TimeZone time_zone = 9; } } // Represents a time zone from the // [IANA Time Zone Database](https://www.iana.org/time-zones). message TimeZone { // IANA Time Zone Database time zone. For example "America/New_York". string id = 1; // Optional. IANA Time Zone Database version number. For example "2019a". string version = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/type/datetime_pb2.py0000644000000000000000000000520115177035225022624 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/datetime.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1agoogle/type/datetime.proto\x12\x0bgoogle.type\x1a\x1egoogle/protobuf/duration.proto"\xe0\x01\n\x08\x44\x61teTime\x12\x0c\n\x04year\x18\x01 \x01(\x05\x12\r\n\x05month\x18\x02 \x01(\x05\x12\x0b\n\x03\x64\x61y\x18\x03 \x01(\x05\x12\r\n\x05hours\x18\x04 \x01(\x05\x12\x0f\n\x07minutes\x18\x05 \x01(\x05\x12\x0f\n\x07seconds\x18\x06 \x01(\x05\x12\r\n\x05nanos\x18\x07 \x01(\x05\x12/\n\nutc_offset\x18\x08 \x01(\x0b\x32\x19.google.protobuf.DurationH\x00\x12*\n\ttime_zone\x18\t \x01(\x0b\x32\x15.google.type.TimeZoneH\x00\x42\r\n\x0btime_offset"\'\n\x08TimeZone\x12\n\n\x02id\x18\x01 \x01(\t\x12\x0f\n\x07version\x18\x02 \x01(\tBf\n\x0f\x63om.google.typeB\rDateTimeProtoP\x01Z None: ... class TimeZone(_message.Message): __slots__ = ("id", "version") ID_FIELD_NUMBER: _ClassVar[int] VERSION_FIELD_NUMBER: _ClassVar[int] id: str version: str def __init__( self, id: _Optional[str] = ..., version: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/type/dayofweek.proto0000644000000000000000000000226415177035225022764 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/dayofweek;dayofweek"; option java_multiple_files = true; option java_outer_classname = "DayOfWeekProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Represents a day of the week. enum DayOfWeek { // The day of the week is unspecified. DAY_OF_WEEK_UNSPECIFIED = 0; // Monday MONDAY = 1; // Tuesday TUESDAY = 2; // Wednesday WEDNESDAY = 3; // Thursday THURSDAY = 4; // Friday FRIDAY = 5; // Saturday SATURDAY = 6; // Sunday SUNDAY = 7; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/type/dayofweek_pb2.py0000644000000000000000000000426115177035223023011 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/dayofweek.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n\x1bgoogle/type/dayofweek.proto\x12\x0bgoogle.type*\x84\x01\n\tDayOfWeek\x12\x1b\n\x17\x44\x41Y_OF_WEEK_UNSPECIFIED\x10\x00\x12\n\n\x06MONDAY\x10\x01\x12\x0b\n\x07TUESDAY\x10\x02\x12\r\n\tWEDNESDAY\x10\x03\x12\x0c\n\x08THURSDAY\x10\x04\x12\n\n\x06\x46RIDAY\x10\x05\x12\x0c\n\x08SATURDAY\x10\x06\x12\n\n\x06SUNDAY\x10\x07\x42i\n\x0f\x63om.google.typeB\x0e\x44\x61yOfWeekProtoP\x01Z>google.golang.org/genproto/googleapis/type/dayofweek;dayofweek\xa2\x02\x03GTPb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.type.dayofweek_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\016DayOfWeekProtoP\001Z>google.golang.org/genproto/googleapis/type/dayofweek;dayofweek\242\002\003GTP" _globals["_DAYOFWEEK"]._serialized_start = 45 _globals["_DAYOFWEEK"]._serialized_end = 177 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/dayofweek_pb2.pyi0000644000000000000000000000246715177035222023167 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class DayOfWeek(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () DAY_OF_WEEK_UNSPECIFIED: _ClassVar[DayOfWeek] MONDAY: _ClassVar[DayOfWeek] TUESDAY: _ClassVar[DayOfWeek] WEDNESDAY: _ClassVar[DayOfWeek] THURSDAY: _ClassVar[DayOfWeek] FRIDAY: _ClassVar[DayOfWeek] SATURDAY: _ClassVar[DayOfWeek] SUNDAY: _ClassVar[DayOfWeek] DAY_OF_WEEK_UNSPECIFIED: DayOfWeek MONDAY: DayOfWeek TUESDAY: DayOfWeek WEDNESDAY: DayOfWeek THURSDAY: DayOfWeek FRIDAY: DayOfWeek SATURDAY: DayOfWeek SUNDAY: DayOfWeek ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/type/decimal.proto0000644000000000000000000001020115177035227022374 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/decimal;decimal"; option java_multiple_files = true; option java_outer_classname = "DecimalProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // A representation of a decimal value, such as 2.5. Clients may convert values // into language-native decimal formats, such as Java's // [BigDecimal](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/math/BigDecimal.html) // or Python's // [decimal.Decimal](https://docs.python.org/3/library/decimal.html). message Decimal { // The decimal value, as a string. // // The string representation consists of an optional sign, `+` (`U+002B`) // or `-` (`U+002D`), followed by a sequence of zero or more decimal digits // ("the integer"), optionally followed by a fraction, optionally followed // by an exponent. An empty string **should** be interpreted as `0`. // // The fraction consists of a decimal point followed by zero or more decimal // digits. The string must contain at least one digit in either the integer // or the fraction. The number formed by the sign, the integer and the // fraction is referred to as the significand. // // The exponent consists of the character `e` (`U+0065`) or `E` (`U+0045`) // followed by one or more decimal digits. // // Services **should** normalize decimal values before storing them by: // // - Removing an explicitly-provided `+` sign (`+2.5` -> `2.5`). // - Replacing a zero-length integer value with `0` (`.5` -> `0.5`). // - Coercing the exponent character to upper-case, with explicit sign // (`2.5e8` -> `2.5E+8`). // - Removing an explicitly-provided zero exponent (`2.5E0` -> `2.5`). // // Services **may** perform additional normalization based on its own needs // and the internal decimal implementation selected, such as shifting the // decimal point and exponent value together (example: `2.5E-1` <-> `0.25`). // Additionally, services **may** preserve trailing zeroes in the fraction // to indicate increased precision, but are not required to do so. // // Note that only the `.` character is supported to divide the integer // and the fraction; `,` **should not** be supported regardless of locale. // Additionally, thousand separators **should not** be supported. If a // service does support them, values **must** be normalized. // // The ENBF grammar is: // // DecimalString = // '' | [Sign] Significand [Exponent]; // // Sign = '+' | '-'; // // Significand = // Digits ['.'] [Digits] | [Digits] '.' Digits; // // Exponent = ('e' | 'E') [Sign] Digits; // // Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' }; // // Services **should** clearly document the range of supported values, the // maximum supported precision (total number of digits), and, if applicable, // the scale (number of digits after the decimal point), as well as how it // behaves when receiving out-of-bounds values. // // Services **may** choose to accept values passed as input even when the // value has a higher precision or scale than the service supports, and // **should** round the value to fit the supported scale. Alternatively, the // service **may** error with `400 Bad Request` (`INVALID_ARGUMENT` in gRPC) // if precision would be lost. // // Services **should** error with `400 Bad Request` (`INVALID_ARGUMENT` in // gRPC) if the service receives a value outside of the supported range. string value = 1; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/decimal_pb2.py0000644000000000000000000000370215177035222022427 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/decimal.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x19google/type/decimal.proto\x12\x0bgoogle.type"\x18\n\x07\x44\x65\x63imal\x12\r\n\x05value\x18\x01 \x01(\tBc\n\x0f\x63om.google.typeB\x0c\x44\x65\x63imalProtoP\x01Z:google.golang.org/genproto/googleapis/type/decimal;decimal\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.type.decimal_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\014DecimalProtoP\001Z:google.golang.org/genproto/googleapis/type/decimal;decimal\242\002\003GTP" _globals["_DECIMAL"]._serialized_start = 42 _globals["_DECIMAL"]._serialized_end = 66 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/type/decimal_pb2.pyi0000644000000000000000000000172415177035223022603 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class Decimal(_message.Message): __slots__ = ("value",) VALUE_FIELD_NUMBER: _ClassVar[int] value: str def __init__(self, value: _Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/type/expr.proto0000644000000000000000000000525215177035225021764 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/expr;expr"; option java_multiple_files = true; option java_outer_classname = "ExprProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // 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. message Expr { // Textual representation of an expression in Common Expression Language // syntax. string expression = 1; // 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. string title = 2; // Optional. Description of the expression. This is a longer text which // describes the expression, e.g. when hovered over it in a UI. string description = 3; // Optional. String indicating the location of the expression for error // reporting, e.g. a file name and a position in the file. string location = 4; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/type/expr_pb2.py0000644000000000000000000000400415177035227022010 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/expr.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x16google/type/expr.proto\x12\x0bgoogle.type"P\n\x04\x45xpr\x12\x12\n\nexpression\x18\x01 \x01(\t\x12\r\n\x05title\x18\x02 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x03 \x01(\t\x12\x10\n\x08location\x18\x04 \x01(\tBZ\n\x0f\x63om.google.typeB\tExprProtoP\x01Z4google.golang.org/genproto/googleapis/type/expr;expr\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.type.expr_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\tExprProtoP\001Z4google.golang.org/genproto/googleapis/type/expr;expr\242\002\003GTP" _globals["_EXPR"]._serialized_start = 39 _globals["_EXPR"]._serialized_end = 119 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/type/expr_pb2.pyi0000644000000000000000000000251315177035227022164 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class Expr(_message.Message): __slots__ = ("expression", "title", "description", "location") EXPRESSION_FIELD_NUMBER: _ClassVar[int] TITLE_FIELD_NUMBER: _ClassVar[int] DESCRIPTION_FIELD_NUMBER: _ClassVar[int] LOCATION_FIELD_NUMBER: _ClassVar[int] expression: str title: str description: str location: str def __init__( self, expression: _Optional[str] = ..., title: _Optional[str] = ..., description: _Optional[str] = ..., location: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/type/fraction.proto0000644000000000000000000000220415177035225022605 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/fraction;fraction"; option java_multiple_files = true; option java_outer_classname = "FractionProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Represents a fraction in terms of a numerator divided by a denominator. message Fraction { // The numerator in the fraction, e.g. 2 in 2/3. int64 numerator = 1; // The value by which the numerator is divided, e.g. 3 in 2/3. Must be // positive. int64 denominator = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/fraction_pb2.py0000644000000000000000000000377315177035226022652 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/fraction.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1agoogle/type/fraction.proto\x12\x0bgoogle.type"2\n\x08\x46raction\x12\x11\n\tnumerator\x18\x01 \x01(\x03\x12\x13\n\x0b\x64\x65nominator\x18\x02 \x01(\x03\x42\x66\n\x0f\x63om.google.typeB\rFractionProtoP\x01Z None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/type/interval.proto0000644000000000000000000000314315177035223022625 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; import "google/protobuf/timestamp.proto"; option go_package = "google.golang.org/genproto/googleapis/type/interval;interval"; option java_multiple_files = true; option java_outer_classname = "IntervalProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Represents a time interval, encoded as a Timestamp start (inclusive) and a // Timestamp end (exclusive). // // The start must be less than or equal to the end. // When the start equals the end, the interval is empty (matches no time). // When both start and end are unspecified, the interval matches any time. message Interval { // Optional. Inclusive start of the interval. // // If specified, a Timestamp matching this interval will have to be the same // or after the start. google.protobuf.Timestamp start_time = 1; // Optional. Exclusive end of the interval. // // If specified, a Timestamp matching this interval will have to be before the // end. google.protobuf.Timestamp end_time = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/type/interval_pb2.py0000644000000000000000000000425015177035225022657 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/interval.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1agoogle/type/interval.proto\x12\x0bgoogle.type\x1a\x1fgoogle/protobuf/timestamp.proto"h\n\x08Interval\x12.\n\nstart_time\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12,\n\x08\x65nd_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.TimestampBf\n\x0f\x63om.google.typeB\rIntervalProtoP\x01Z None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/type/latlng.proto0000644000000000000000000000263115177035224022264 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/latlng;latlng"; option java_multiple_files = true; option java_outer_classname = "LatLngProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // 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. message LatLng { // The latitude in degrees. It must be in the range [-90.0, +90.0]. double latitude = 1; // The longitude in degrees. It must be in the range [-180.0, +180.0]. double longitude = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/type/latlng_pb2.py0000644000000000000000000000372215177035223022315 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/latlng.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x18google/type/latlng.proto\x12\x0bgoogle.type"-\n\x06LatLng\x12\x10\n\x08latitude\x18\x01 \x01(\x01\x12\x11\n\tlongitude\x18\x02 \x01(\x01\x42`\n\x0f\x63om.google.typeB\x0bLatLngProtoP\x01Z8google.golang.org/genproto/googleapis/type/latlng;latlng\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.type.latlng_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\013LatLngProtoP\001Z8google.golang.org/genproto/googleapis/type/latlng;latlng\242\002\003GTP" _globals["_LATLNG"]._serialized_start = 41 _globals["_LATLNG"]._serialized_end = 86 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/type/latlng_pb2.pyi0000644000000000000000000000214015177035225022461 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class LatLng(_message.Message): __slots__ = ("latitude", "longitude") LATITUDE_FIELD_NUMBER: _ClassVar[int] LONGITUDE_FIELD_NUMBER: _ClassVar[int] latitude: float longitude: float def __init__( self, latitude: _Optional[float] = ..., longitude: _Optional[float] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/type/localized_text.proto0000644000000000000000000000244515177035224024020 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/localized_text;localized_text"; option java_multiple_files = true; option java_outer_classname = "LocalizedTextProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Localized variant of a text in a particular language. message LocalizedText { // Localized string in the language corresponding to // [language_code][google.type.LocalizedText.language_code] below. string text = 1; // 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. string language_code = 2; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/localized_text_pb2.py0000644000000000000000000000405015177035226024044 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/localized_text.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n google/type/localized_text.proto\x12\x0bgoogle.type"4\n\rLocalizedText\x12\x0c\n\x04text\x18\x01 \x01(\t\x12\x15\n\rlanguage_code\x18\x02 \x01(\tBw\n\x0f\x63om.google.typeB\x12LocalizedTextProtoP\x01ZHgoogle.golang.org/genproto/googleapis/type/localized_text;localized_text\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.type.localized_text_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\022LocalizedTextProtoP\001ZHgoogle.golang.org/genproto/googleapis/type/localized_text;localized_text\242\002\003GTP" _globals["_LOCALIZEDTEXT"]._serialized_start = 49 _globals["_LOCALIZEDTEXT"]._serialized_end = 101 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/type/localized_text_pb2.pyi0000644000000000000000000000213715177035224024217 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class LocalizedText(_message.Message): __slots__ = ("text", "language_code") TEXT_FIELD_NUMBER: _ClassVar[int] LANGUAGE_CODE_FIELD_NUMBER: _ClassVar[int] text: str language_code: str def __init__( self, text: _Optional[str] = ..., language_code: _Optional[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/type/money.proto0000644000000000000000000000304315177035225022131 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/money;money"; option java_multiple_files = true; option java_outer_classname = "MoneyProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Represents an amount of money with its currency type. message Money { // The three-letter currency code defined in ISO 4217. string currency_code = 1; // The whole units of the amount. // For example if `currencyCode` is `"USD"`, then 1 unit is one US dollar. int64 units = 2; // 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. int32 nanos = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/money_pb2.py0000644000000000000000000000374315177035226022171 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/money.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x17google/type/money.proto\x12\x0bgoogle.type"<\n\x05Money\x12\x15\n\rcurrency_code\x18\x01 \x01(\t\x12\r\n\x05units\x18\x02 \x01(\x03\x12\r\n\x05nanos\x18\x03 \x01(\x05\x42]\n\x0f\x63om.google.typeB\nMoneyProtoP\x01Z6google.golang.org/genproto/googleapis/type/money;money\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.type.money_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\nMoneyProtoP\001Z6google.golang.org/genproto/googleapis/type/money;money\242\002\003GTP" _globals["_MONEY"]._serialized_start = 40 _globals["_MONEY"]._serialized_end = 100 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/type/money_pb2.pyi0000644000000000000000000000232015177035227022331 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class Money(_message.Message): __slots__ = ("currency_code", "units", "nanos") CURRENCY_CODE_FIELD_NUMBER: _ClassVar[int] UNITS_FIELD_NUMBER: _ClassVar[int] NANOS_FIELD_NUMBER: _ClassVar[int] currency_code: str units: int nanos: int def __init__( self, currency_code: _Optional[str] = ..., units: _Optional[int] = ..., nanos: _Optional[int] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/month.proto0000644000000000000000000000270715177035226022136 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/month;month"; option java_multiple_files = true; option java_outer_classname = "MonthProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Represents a month in the Gregorian calendar. enum Month { // The unspecified month. MONTH_UNSPECIFIED = 0; // The month of January. JANUARY = 1; // The month of February. FEBRUARY = 2; // The month of March. MARCH = 3; // The month of April. APRIL = 4; // The month of May. MAY = 5; // The month of June. JUNE = 6; // The month of July. JULY = 7; // The month of August. AUGUST = 8; // The month of September. SEPTEMBER = 9; // The month of October. OCTOBER = 10; // The month of November. NOVEMBER = 11; // The month of December. DECEMBER = 12; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/month_pb2.py0000644000000000000000000000440115177035226022157 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/month.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b"\n\x17google/type/month.proto\x12\x0bgoogle.type*\xb0\x01\n\x05Month\x12\x15\n\x11MONTH_UNSPECIFIED\x10\x00\x12\x0b\n\x07JANUARY\x10\x01\x12\x0c\n\x08\x46\x45\x42RUARY\x10\x02\x12\t\n\x05MARCH\x10\x03\x12\t\n\x05\x41PRIL\x10\x04\x12\x07\n\x03MAY\x10\x05\x12\x08\n\x04JUNE\x10\x06\x12\x08\n\x04JULY\x10\x07\x12\n\n\x06\x41UGUST\x10\x08\x12\r\n\tSEPTEMBER\x10\t\x12\x0b\n\x07OCTOBER\x10\n\x12\x0c\n\x08NOVEMBER\x10\x0b\x12\x0c\n\x08\x44\x45\x43\x45MBER\x10\x0c\x42]\n\x0f\x63om.google.typeB\nMonthProtoP\x01Z6google.golang.org/genproto/googleapis/type/month;month\xa2\x02\x03GTPb\x06proto3" ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "google.type.month_pb2", _globals) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\nMonthProtoP\001Z6google.golang.org/genproto/googleapis/type/month;month\242\002\003GTP" _globals["_MONTH"]._serialized_start = 41 _globals["_MONTH"]._serialized_end = 217 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/type/month_pb2.pyi0000644000000000000000000000266215177035227022340 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from google.protobuf import descriptor as _descriptor from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper DESCRIPTOR: _descriptor.FileDescriptor class Month(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): __slots__ = () MONTH_UNSPECIFIED: _ClassVar[Month] JANUARY: _ClassVar[Month] FEBRUARY: _ClassVar[Month] MARCH: _ClassVar[Month] APRIL: _ClassVar[Month] MAY: _ClassVar[Month] JUNE: _ClassVar[Month] JULY: _ClassVar[Month] AUGUST: _ClassVar[Month] SEPTEMBER: _ClassVar[Month] OCTOBER: _ClassVar[Month] NOVEMBER: _ClassVar[Month] DECEMBER: _ClassVar[Month] MONTH_UNSPECIFIED: Month JANUARY: Month FEBRUARY: Month MARCH: Month APRIL: Month MAY: Month JUNE: Month JULY: Month AUGUST: Month SEPTEMBER: Month OCTOBER: Month NOVEMBER: Month DECEMBER: Month ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137747.0 googleapis_common_protos-1.75.0/google/type/phone_number.proto0000644000000000000000000001126015177035223023461 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/phone_number;phone_number"; option java_multiple_files = true; option java_outer_classname = "PhoneNumberProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // An object representing a phone number, suitable as an API wire format. // // This representation: // // - should not be used for locale-specific formatting of a phone number, such // as "+1 (650) 253-0000 ext. 123" // // - is not designed for efficient storage // - may not be suitable for dialing - specialized libraries (see references) // should be used to parse the number for that purpose // // To do something meaningful with this number, such as format it for various // use-cases, convert it to an `i18n.phonenumbers.PhoneNumber` object first. // // For instance, in Java this would be: // // com.google.type.PhoneNumber wireProto = // com.google.type.PhoneNumber.newBuilder().build(); // com.google.i18n.phonenumbers.Phonenumber.PhoneNumber phoneNumber = // PhoneNumberUtil.getInstance().parse(wireProto.getE164Number(), "ZZ"); // if (!wireProto.getExtension().isEmpty()) { // phoneNumber.setExtension(wireProto.getExtension()); // } // // Reference(s): // - https://github.com/google/libphonenumber message PhoneNumber { // An object representing a short code, which is a phone number that is // typically much shorter than regular phone numbers and can be used to // address messages in MMS and SMS systems, as well as for abbreviated dialing // (For example "Text 611 to see how many minutes you have remaining on your // plan."). // // Short codes are restricted to a region and are not internationally // dialable, which means the same short code can exist in different regions, // with different usage and pricing, even if those regions share the same // country calling code (For example: US and CA). message ShortCode { // Required. The BCP-47 region code of the location where calls to this // short code can be made, such as "US" and "BB". // // Reference(s): // - http://www.unicode.org/reports/tr35/#unicode_region_subtag string region_code = 1; // Required. The short code digits, without a leading plus ('+') or country // calling code. For example "611". string number = 2; } // Required. Either a regular number, or a short code. New fields may be // added to the oneof below in the future, so clients should ignore phone // numbers for which none of the fields they coded against are set. oneof kind { // The phone number, represented as a leading plus sign ('+'), followed by a // phone number that uses a relaxed ITU E.164 format consisting of the // country calling code (1 to 3 digits) and the subscriber number, with no // additional spaces or formatting. For example: // // - correct: "+15552220123" // // - incorrect: "+1 (555) 222-01234 x123" // // The ITU E.164 format limits the latter to 12 digits, but in practice not // all countries respect that, so we relax that restriction here. // National-only numbers are not allowed. // // References: // // - https://www.itu.int/rec/T-REC-E.164-201011-I // // - https://en.wikipedia.org/wiki/E.164. // // - https://en.wikipedia.org/wiki/List_of_country_calling_codes string e164_number = 1; // A short code. // // Reference(s): // - https://wikipedia.org/wiki/Short_code ShortCode short_code = 2; } // The phone number's extension. The extension is not standardized in ITU // recommendations, except for being defined as a series of numbers with a // maximum length of 40 digits. Other than digits, some other dialing // characters such as ',' (indicating a wait) or '#' may be stored here. // // Note that no regions currently use extensions with short codes, so this // field is normally only set in conjunction with an E.164 number. It is held // separately from the E.164 number to allow for short code extensions in the // future. string extension = 3; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/type/phone_number_pb2.py0000644000000000000000000000456115177035227023523 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/phone_number.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1egoogle/type/phone_number.proto\x12\x0bgoogle.type"\xab\x01\n\x0bPhoneNumber\x12\x15\n\x0b\x65\x31\x36\x34_number\x18\x01 \x01(\tH\x00\x12\x38\n\nshort_code\x18\x02 \x01(\x0b\x32".google.type.PhoneNumber.ShortCodeH\x00\x12\x11\n\textension\x18\x03 \x01(\t\x1a\x30\n\tShortCode\x12\x13\n\x0bregion_code\x18\x01 \x01(\t\x12\x0e\n\x06number\x18\x02 \x01(\tB\x06\n\x04kindBq\n\x0f\x63om.google.typeB\x10PhoneNumberProtoP\x01ZDgoogle.golang.org/genproto/googleapis/type/phone_number;phone_number\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.type.phone_number_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\020PhoneNumberProtoP\001ZDgoogle.golang.org/genproto/googleapis/type/phone_number;phone_number\242\002\003GTP" _globals["_PHONENUMBER"]._serialized_start = 48 _globals["_PHONENUMBER"]._serialized_end = 219 _globals["_PHONENUMBER_SHORTCODE"]._serialized_start = 163 _globals["_PHONENUMBER_SHORTCODE"]._serialized_end = 211 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/phone_number_pb2.pyi0000644000000000000000000000332115177035226023664 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Mapping as _Mapping from typing import Optional as _Optional from typing import Union as _Union from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class PhoneNumber(_message.Message): __slots__ = ("e164_number", "short_code", "extension") class ShortCode(_message.Message): __slots__ = ("region_code", "number") REGION_CODE_FIELD_NUMBER: _ClassVar[int] NUMBER_FIELD_NUMBER: _ClassVar[int] region_code: str number: str def __init__( self, region_code: _Optional[str] = ..., number: _Optional[str] = ... ) -> None: ... E164_NUMBER_FIELD_NUMBER: _ClassVar[int] SHORT_CODE_FIELD_NUMBER: _ClassVar[int] EXTENSION_FIELD_NUMBER: _ClassVar[int] e164_number: str short_code: PhoneNumber.ShortCode extension: str def __init__( self, e164_number: _Optional[str] = ..., short_code: _Optional[_Union[PhoneNumber.ShortCode, _Mapping]] = ..., extension: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/type/postal_address.proto0000644000000000000000000001426215177035224024015 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/postaladdress;postaladdress"; option java_multiple_files = true; option java_outer_classname = "PostalAddressProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // Represents a postal address, such as for postal delivery or payments // addresses. With a postal address, a postal service can deliver items to a // premise, P.O. box, or similar. A postal address is not intended to model // geographical locations like roads, towns, or mountains. // // In typical usage, an address would be created by user input or from importing // existing data, depending on the type of process. // // Advice on address input or editing: // // - Use an internationalization-ready address widget such as // https://github.com/google/libaddressinput. // - Users should not be presented with UI elements for input or editing of // fields outside countries where that field is used. // // For more guidance on how to use this schema, see: // https://support.google.com/business/answer/6397478. message PostalAddress { // The schema revision of the `PostalAddress`. This must be set to 0, which is // the latest revision. // // All new revisions **must** be backward compatible with old revisions. int32 revision = 1; // Required. CLDR region code of the country/region of the address. This // is never inferred and it is up to the user to ensure the value is // correct. See https://cldr.unicode.org/ and // https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html // for details. Example: "CH" for Switzerland. string region_code = 2; // Optional. BCP-47 language code of the contents of this address (if // known). This is often the UI language of the input form or is expected // to match one of the languages used in the address' country/region, or their // transliterated equivalents. // This can affect formatting in certain countries, but is not critical // to the correctness of the data and will never affect any validation or // other non-formatting related operations. // // If this value is not known, it should be omitted (rather than specifying a // possibly incorrect default). // // Examples: "zh-Hant", "ja", "ja-Latn", "en". string language_code = 3; // Optional. Postal code of the address. Not all countries use or require // postal codes to be present, but where they are used, they may trigger // additional validation with other parts of the address (for example, // state or zip code validation in the United States). string postal_code = 4; // Optional. Additional, country-specific, sorting code. This is not used // in most regions. Where it is used, the value is either a string like // "CEDEX", optionally followed by a number (for example, "CEDEX 7"), or just // a number alone, representing the "sector code" (Jamaica), "delivery area // indicator" (Malawi) or "post office indicator" (Côte d'Ivoire). string sorting_code = 5; // Optional. Highest administrative subdivision which is used for postal // addresses of a country or region. // For example, this can be a state, a province, an oblast, or a prefecture. // For Spain, this is the province and not the autonomous // community (for example, "Barcelona" and not "Catalonia"). // Many countries don't use an administrative area in postal addresses. For // example, in Switzerland, this should be left unpopulated. string administrative_area = 6; // Optional. Generally refers to the city or town portion of the address. // Examples: US city, IT comune, UK post town. // In regions of the world where localities are not well defined or do not fit // into this structure well, leave `locality` empty and use `address_lines`. string locality = 7; // Optional. Sublocality of the address. // For example, this can be a neighborhood, borough, or district. string sublocality = 8; // Unstructured address lines describing the lower levels of an address. // // Because values in `address_lines` do not have type information and may // sometimes contain multiple values in a single field (for example, // "Austin, TX"), it is important that the line order is clear. The order of // address lines should be "envelope order" for the country or region of the // address. In places where this can vary (for example, Japan), // `address_language` is used to make it explicit (for example, "ja" for // large-to-small ordering and "ja-Latn" or "en" for small-to-large). In this // way, the most specific line of an address can be selected based on the // language. // // The minimum permitted structural representation of an address consists // of a `region_code` with all remaining information placed in the // `address_lines`. It would be possible to format such an address very // approximately without geocoding, but no semantic reasoning could be // made about any of the address components until it was at least // partially resolved. // // Creating an address only containing a `region_code` and `address_lines` and // then geocoding is the recommended way to handle completely unstructured // addresses (as opposed to guessing which parts of the address should be // localities or administrative areas). repeated string address_lines = 9; // Optional. The recipient at the address. // This field may, under certain circumstances, contain multiline information. // For example, it might contain "care of" information. repeated string recipients = 10; // Optional. The name of the organization at the address. string organization = 11; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/google/type/postal_address_pb2.py0000644000000000000000000000465015177035224024045 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/postal_address.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n google/type/postal_address.proto\x12\x0bgoogle.type"\xfd\x01\n\rPostalAddress\x12\x10\n\x08revision\x18\x01 \x01(\x05\x12\x13\n\x0bregion_code\x18\x02 \x01(\t\x12\x15\n\rlanguage_code\x18\x03 \x01(\t\x12\x13\n\x0bpostal_code\x18\x04 \x01(\t\x12\x14\n\x0csorting_code\x18\x05 \x01(\t\x12\x1b\n\x13\x61\x64ministrative_area\x18\x06 \x01(\t\x12\x10\n\x08locality\x18\x07 \x01(\t\x12\x13\n\x0bsublocality\x18\x08 \x01(\t\x12\x15\n\raddress_lines\x18\t \x03(\t\x12\x12\n\nrecipients\x18\n \x03(\t\x12\x14\n\x0corganization\x18\x0b \x01(\tBu\n\x0f\x63om.google.typeB\x12PostalAddressProtoP\x01ZFgoogle.golang.org/genproto/googleapis/type/postaladdress;postaladdress\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.type.postal_address_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\022PostalAddressProtoP\001ZFgoogle.golang.org/genproto/googleapis/type/postaladdress;postaladdress\242\002\003GTP" _globals["_POSTALADDRESS"]._serialized_start = 50 _globals["_POSTALADDRESS"]._serialized_end = 303 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/postal_address_pb2.pyi0000644000000000000000000000505515177035222024214 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Iterable as _Iterable from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf.internal import containers as _containers DESCRIPTOR: _descriptor.FileDescriptor class PostalAddress(_message.Message): __slots__ = ( "revision", "region_code", "language_code", "postal_code", "sorting_code", "administrative_area", "locality", "sublocality", "address_lines", "recipients", "organization", ) REVISION_FIELD_NUMBER: _ClassVar[int] REGION_CODE_FIELD_NUMBER: _ClassVar[int] LANGUAGE_CODE_FIELD_NUMBER: _ClassVar[int] POSTAL_CODE_FIELD_NUMBER: _ClassVar[int] SORTING_CODE_FIELD_NUMBER: _ClassVar[int] ADMINISTRATIVE_AREA_FIELD_NUMBER: _ClassVar[int] LOCALITY_FIELD_NUMBER: _ClassVar[int] SUBLOCALITY_FIELD_NUMBER: _ClassVar[int] ADDRESS_LINES_FIELD_NUMBER: _ClassVar[int] RECIPIENTS_FIELD_NUMBER: _ClassVar[int] ORGANIZATION_FIELD_NUMBER: _ClassVar[int] revision: int region_code: str language_code: str postal_code: str sorting_code: str administrative_area: str locality: str sublocality: str address_lines: _containers.RepeatedScalarFieldContainer[str] recipients: _containers.RepeatedScalarFieldContainer[str] organization: str def __init__( self, revision: _Optional[int] = ..., region_code: _Optional[str] = ..., language_code: _Optional[str] = ..., postal_code: _Optional[str] = ..., sorting_code: _Optional[str] = ..., administrative_area: _Optional[str] = ..., locality: _Optional[str] = ..., sublocality: _Optional[str] = ..., address_lines: _Optional[_Iterable[str]] = ..., recipients: _Optional[_Iterable[str]] = ..., organization: _Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/quaternion.proto0000644000000000000000000000736215177035222023174 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/quaternion;quaternion"; option java_multiple_files = true; option java_outer_classname = "QuaternionProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // A quaternion, represented by four 64-bit floating point values. // // A quaternion is defined as the quotient of two directed lines in a // three-dimensional space or equivalently as the quotient of two Euclidean // vectors (https://en.wikipedia.org/wiki/Quaternion). // // Quaternions are often used in calculations involving three-dimensional // rotations (https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation), // as they provide greater mathematical robustness by avoiding the gimbal lock // problems that can be encountered when using Euler angles // (https://en.wikipedia.org/wiki/Gimbal_lock). // // Quaternions are generally represented in this form: // // w + xi + yj + zk // // where x, y, z, and w are real numbers, and i, j, and k are three imaginary // numbers. // // The naming choice `(x, y, z, w)` comes from the desire to avoid confusion for // those interested in the geometric properties of the quaternion in the 3D // Cartesian space. Other texts often use alternative names or subscripts, such // as `(a, b, c, d)`, `(1, i, j, k)`, or `(0, 1, 2, 3)`, which are perhaps // better suited for mathematical interpretations. // // To avoid any confusion, as well as to maintain compatibility with a large // number of software libraries, the quaternions represented using the protocol // buffer below *must* follow the Hamilton convention, which defines `ij = k` // (i.e. a right-handed algebra), and therefore: // // i^2 = j^2 = k^2 = ijk = −1 // ij = −ji = k // jk = −kj = i // ki = −ik = j // // Please DO NOT use this to represent quaternions that follow the JPL // convention, or any of the other quaternion flavors out there. // // Definitions: // // - Quaternion norm (or magnitude): `sqrt(x^2 + y^2 + z^2 + w^2)`. // - Unit (or normalized) quaternion: a quaternion whose norm is 1. // - Pure quaternion: a quaternion whose scalar component (`w`) is 0. // - Rotation quaternion: a unit quaternion used to represent rotation. // - Orientation quaternion: a unit quaternion used to represent orientation. // // A quaternion can be normalized by dividing it by its norm. The resulting // quaternion maintains the same direction, but has a norm of 1, i.e. it moves // on the unit sphere. This is generally necessary for rotation and orientation // quaternions, to avoid rounding errors: // https://en.wikipedia.org/wiki/Rotation_formalisms_in_three_dimensions // // Note that `(x, y, z, w)` and `(-x, -y, -z, -w)` represent the same rotation, // but normalization would be even more useful, e.g. for comparison purposes, if // it would produce a unique representation. It is thus recommended that `w` be // kept positive, which can be achieved by changing all the signs when `w` is // negative. message Quaternion { // The x component. double x = 1; // The y component. double y = 2; // The z component. double z = 3; // The scalar component. double w = 4; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/quaternion_pb2.py0000644000000000000000000000406415177035222023220 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/quaternion.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1cgoogle/type/quaternion.proto\x12\x0bgoogle.type"8\n\nQuaternion\x12\t\n\x01x\x18\x01 \x01(\x01\x12\t\n\x01y\x18\x02 \x01(\x01\x12\t\n\x01z\x18\x03 \x01(\x01\x12\t\n\x01w\x18\x04 \x01(\x01\x42l\n\x0f\x63om.google.typeB\x0fQuaternionProtoP\x01Z@google.golang.org/genproto/googleapis/type/quaternion;quaternion\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.type.quaternion_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\017QuaternionProtoP\001Z@google.golang.org/genproto/googleapis/type/quaternion;quaternion\242\002\003GTP" _globals["_QUATERNION"]._serialized_start = 45 _globals["_QUATERNION"]._serialized_end = 101 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/google/type/quaternion_pb2.pyi0000644000000000000000000000235115177035226023372 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class Quaternion(_message.Message): __slots__ = ("x", "y", "z", "w") X_FIELD_NUMBER: _ClassVar[int] Y_FIELD_NUMBER: _ClassVar[int] Z_FIELD_NUMBER: _ClassVar[int] W_FIELD_NUMBER: _ClassVar[int] x: float y: float z: float w: float def __init__( self, x: _Optional[float] = ..., y: _Optional[float] = ..., z: _Optional[float] = ..., w: _Optional[float] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/google/type/timeofday.proto0000644000000000000000000000346015177035225022766 0ustar00rootroot// Copyright 2026 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. syntax = "proto3"; package google.type; option go_package = "google.golang.org/genproto/googleapis/type/timeofday;timeofday"; option java_multiple_files = true; option java_outer_classname = "TimeOfDayProto"; option java_package = "com.google.type"; option objc_class_prefix = "GTP"; // 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][google.type.Date] and // `google.protobuf.Timestamp`. message TimeOfDay { // Hours of a day in 24 hour format. Must be greater than or equal to 0 and // typically must be less than or equal to 23. An API may choose to allow the // value "24:00:00" for scenarios like business closing time. int32 hours = 1; // Minutes of an hour. Must be greater than or equal to 0 and less than or // equal to 59. int32 minutes = 2; // Seconds of a minute. Must be greater than or equal to 0 and typically must // be less than or equal to 59. An API may allow the value 60 if it allows // leap-seconds. int32 seconds = 3; // Fractions of seconds, in nanoseconds. Must be greater than or equal to 0 // and less than or equal to 999,999,999. int32 nanos = 4; } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137746.0 googleapis_common_protos-1.75.0/google/type/timeofday_pb2.py0000644000000000000000000000410015177035222023003 0ustar00rootroot# -*- coding: utf-8 -*- # Copyright 2025 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. # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/type/timeofday.proto # Protobuf Python Version: 4.25.3 """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import descriptor_pool as _descriptor_pool from google.protobuf import symbol_database as _symbol_database from google.protobuf.internal import builder as _builder # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( b'\n\x1bgoogle/type/timeofday.proto\x12\x0bgoogle.type"K\n\tTimeOfDay\x12\r\n\x05hours\x18\x01 \x01(\x05\x12\x0f\n\x07minutes\x18\x02 \x01(\x05\x12\x0f\n\x07seconds\x18\x03 \x01(\x05\x12\r\n\x05nanos\x18\x04 \x01(\x05\x42i\n\x0f\x63om.google.typeB\x0eTimeOfDayProtoP\x01Z>google.golang.org/genproto/googleapis/type/timeofday;timeofday\xa2\x02\x03GTPb\x06proto3' ) _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) _builder.BuildTopDescriptorsAndMessages( DESCRIPTOR, "google.type.timeofday_pb2", _globals ) if _descriptor._USE_C_DESCRIPTORS == False: _globals["DESCRIPTOR"]._options = None _globals[ "DESCRIPTOR" ]._serialized_options = b"\n\017com.google.typeB\016TimeOfDayProtoP\001Z>google.golang.org/genproto/googleapis/type/timeofday;timeofday\242\002\003GTP" _globals["_TIMEOFDAY"]._serialized_start = 44 _globals["_TIMEOFDAY"]._serialized_end = 119 # @@protoc_insertion_point(module_scope) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137751.0 googleapis_common_protos-1.75.0/google/type/timeofday_pb2.pyi0000644000000000000000000000245015177035227023167 0ustar00rootroot# Copyright 2025 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. from typing import ClassVar as _ClassVar from typing import Optional as _Optional from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message DESCRIPTOR: _descriptor.FileDescriptor class TimeOfDay(_message.Message): __slots__ = ("hours", "minutes", "seconds", "nanos") HOURS_FIELD_NUMBER: _ClassVar[int] MINUTES_FIELD_NUMBER: _ClassVar[int] SECONDS_FIELD_NUMBER: _ClassVar[int] NANOS_FIELD_NUMBER: _ClassVar[int] hours: int minutes: int seconds: int nanos: int def __init__( self, hours: _Optional[int] = ..., minutes: _Optional[int] = ..., seconds: _Optional[int] = ..., nanos: _Optional[int] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0783265 googleapis_common_protos-1.75.0/googleapis_common_protos.egg-info/0000755000000000000000000000000015177036143024261 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778138211.0 googleapis_common_protos-1.75.0/googleapis_common_protos.egg-info/PKG-INFO0000644000000000000000000002055715177036143025367 0ustar00rootrootMetadata-Version: 2.4 Name: googleapis-common-protos Version: 1.75.0 Summary: Common protobufs used in Google APIs Author-email: Google LLC License: Apache 2.0 Project-URL: Repository, https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: Apache Software License 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: Programming Language :: Python :: 3.14 Classifier: Operating System :: OS Independent Classifier: Topic :: Internet Requires-Python: >=3.9 Description-Content-Type: text/x-rst License-File: LICENSE Requires-Dist: protobuf<8.0.0,>=4.25.8 Provides-Extra: grpc Requires-Dist: grpcio<2.0.0,>=1.44.0; extra == "grpc" Dynamic: license-file Python Client for Service Config ================================ |stable| |pypi| |versions| - `Client Library Documentation`_ .. |stable| image:: https://img.shields.io/badge/support-stable-gold.svg :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#stability-levels .. |pypi| image:: https://img.shields.io/pypi/v/googleapis-common-protos.svg :target: https://pypi.org/project/googleapis-common-protos/ .. |versions| image:: https://img.shields.io/pypi/pyversions/googleapis-common-protos.svg :target: https://pypi.org/project/googleapis-common-protos/ .. _Client Library Documentation: https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos/summary_overview Quick Start ----------- In order to use this library, you first need to go through the following steps: 1. `Select or create a Cloud Platform project.`_ 2. `Enable billing for your project.`_ 3. `Set up Authentication.`_ .. _Select or create a Cloud Platform project.: https://console.cloud.google.com/project .. _Enable billing for your project.: https://cloud.google.com/billing/docs/how-to/modify-project#enable_billing_for_a_project .. _Set up Authentication.: https://googleapis.dev/python/google-api-core/latest/auth.html Installation ~~~~~~~~~~~~ Install this library in a virtual environment using `venv`_. `venv`_ is a tool that creates isolated Python environments. These isolated environments can have separate versions of Python packages, which allows you to isolate one project's dependencies from the dependencies of other projects. With `venv`_, it's possible to install this library without needing system install permissions, and without clashing with the installed system dependencies. .. _`venv`: https://docs.python.org/3/library/venv.html Code samples and snippets ~~~~~~~~~~~~~~~~~~~~~~~~~ Code samples and snippets live in the `samples/`_ folder. .. _samples/: https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos/samples Supported Python Versions ^^^^^^^^^^^^^^^^^^^^^^^^^ Our client libraries are compatible with all current `active`_ and `maintenance`_ versions of Python. Python >= 3.9, including 3.14 .. _active: https://devguide.python.org/devcycle/#in-development-main-branch .. _maintenance: https://devguide.python.org/devcycle/#maintenance-branches Unsupported Python Versions ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Python <= 3.8 If you are using an `end-of-life`_ version of Python, we recommend that you update as soon as possible to an actively supported version. .. _end-of-life: https://devguide.python.org/devcycle/#end-of-life-branches Mac/Linux ^^^^^^^^^ .. code-block:: console python3 -m venv source /bin/activate pip install googleapis-common-protos Windows ^^^^^^^ .. code-block:: console py -m venv .\\Scripts\activate pip install googleapis-common-protos Next Steps ~~~~~~~~~~ - Read the `Client Library Documentation`_ for Service Config to see other available methods on the client. - View this `README`_ to see the full list of Cloud APIs that we cover. .. _README: https://github.com/googleapis/google-cloud-python/blob/main/README.rst Logging ------- This library uses the standard Python :code:`logging` functionality to log some RPC events that could be of interest for debugging and monitoring purposes. Note the following: #. Logs may contain sensitive information. Take care to **restrict access to the logs** if they are saved, whether it be on local storage or on Google Cloud Logging. #. Google may refine the occurrence, level, and content of various log messages in this library without flagging such changes as breaking. **Do not depend on immutability of the logging events**. #. By default, the logging events from this library are not handled. You must **explicitly configure log handling** using one of the mechanisms below. Simple, environment-based configuration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To enable logging for this library without any changes in your code, set the :code:`GOOGLE_SDK_PYTHON_LOGGING_SCOPE` environment variable to a valid Google logging scope. This configures handling of logging events (at level :code:`logging.DEBUG` or higher) from this library in a default manner, emitting the logged messages in a structured format. It does not currently allow customizing the logging levels captured nor the handlers, formatters, etc. used for any logging event. A logging scope is a period-separated namespace that begins with :code:`google`, identifying the Python module or package to log. - Valid logging scopes: :code:`google`, :code:`google.cloud.asset.v1`, :code:`google.api`, :code:`google.auth`, etc. - Invalid logging scopes: :code:`foo`, :code:`123`, etc. **NOTE**: If the logging scope is invalid, the library does not set up any logging handlers. Environment-Based Examples ^^^^^^^^^^^^^^^^^^^^^^^^^^ - Enabling the default handler for all Google-based loggers .. code-block:: console export GOOGLE_SDK_PYTHON_LOGGING_SCOPE=google - Enabling the default handler for a specific Google module (for a client library called :code:`library_v1`): .. code-block:: console export GOOGLE_SDK_PYTHON_LOGGING_SCOPE=google.cloud.library_v1 Advanced, code-based configuration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can also configure a valid logging scope using Python's standard `logging` mechanism. Code-Based Examples ^^^^^^^^^^^^^^^^^^^ - Configuring a handler for all Google-based loggers .. code-block:: python import logging from google.cloud import library_v1 base_logger = logging.getLogger("google") base_logger.addHandler(logging.StreamHandler()) base_logger.setLevel(logging.DEBUG) - Configuring a handler for a specific Google module (for a client library called :code:`library_v1`): .. code-block:: python import logging from google.cloud import library_v1 base_logger = logging.getLogger("google.cloud.library_v1") base_logger.addHandler(logging.StreamHandler()) base_logger.setLevel(logging.DEBUG) Logging details ~~~~~~~~~~~~~~~ #. Regardless of which of the mechanisms above you use to configure logging for this library, by default logging events are not propagated up to the root logger from the `google`-level logger. If you need the events to be propagated to the root logger, you must explicitly set :code:`logging.getLogger("google").propagate = True` in your code. #. You can mix the different logging configurations above for different Google modules. For example, you may want use a code-based logging configuration for one library, but decide you need to also set up environment-based logging configuration for another library. #. If you attempt to use both code-based and environment-based configuration for the same module, the environment-based configuration will be ineffectual if the code -based configuration gets applied first. #. The Google-specific logging configurations (default handlers for environment-based configuration; not propagating logging events to the root logger) get executed the first time *any* client library is instantiated in your application, and only if the affected loggers have not been previously configured. (This is the reason for 2.i. above.) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778138211.0 googleapis_common_protos-1.75.0/googleapis_common_protos.egg-info/SOURCES.txt0000644000000000000000000001402415177036143026146 0ustar00rootrootLICENSE MANIFEST.in README.rst pyproject.toml setup.py google/api/annotations.proto google/api/annotations_pb2.py google/api/annotations_pb2.pyi google/api/auth.proto google/api/auth_pb2.py google/api/auth_pb2.pyi google/api/backend.proto google/api/backend_pb2.py google/api/backend_pb2.pyi google/api/billing.proto google/api/billing_pb2.py google/api/billing_pb2.pyi google/api/client.proto google/api/client_pb2.py google/api/client_pb2.pyi google/api/config_change.proto google/api/config_change_pb2.py google/api/config_change_pb2.pyi google/api/consumer.proto google/api/consumer_pb2.py google/api/consumer_pb2.pyi google/api/context.proto google/api/context_pb2.py google/api/context_pb2.pyi google/api/control.proto google/api/control_pb2.py google/api/control_pb2.pyi google/api/distribution.proto google/api/distribution_pb2.py google/api/distribution_pb2.pyi google/api/documentation.proto google/api/documentation_pb2.py google/api/documentation_pb2.pyi google/api/endpoint.proto google/api/endpoint_pb2.py google/api/endpoint_pb2.pyi google/api/error_reason.proto google/api/error_reason_pb2.py google/api/error_reason_pb2.pyi google/api/field_behavior.proto google/api/field_behavior_pb2.py google/api/field_behavior_pb2.pyi google/api/field_info.proto google/api/field_info_pb2.py google/api/field_info_pb2.pyi google/api/http.proto google/api/http_pb2.py google/api/http_pb2.pyi google/api/httpbody.proto google/api/httpbody_pb2.py google/api/httpbody_pb2.pyi google/api/label.proto google/api/label_pb2.py google/api/label_pb2.pyi google/api/launch_stage.proto google/api/launch_stage_pb2.py google/api/launch_stage_pb2.pyi google/api/log.proto google/api/log_pb2.py google/api/log_pb2.pyi google/api/logging.proto google/api/logging_pb2.py google/api/logging_pb2.pyi google/api/metric.proto google/api/metric_pb2.py google/api/metric_pb2.pyi google/api/monitored_resource.proto google/api/monitored_resource_pb2.py google/api/monitored_resource_pb2.pyi google/api/monitoring.proto google/api/monitoring_pb2.py google/api/monitoring_pb2.pyi google/api/policy.proto google/api/policy_pb2.py google/api/policy_pb2.pyi google/api/quota.proto google/api/quota_pb2.py google/api/quota_pb2.pyi google/api/resource.proto google/api/resource_pb2.py google/api/resource_pb2.pyi google/api/routing.proto google/api/routing_pb2.py google/api/routing_pb2.pyi google/api/service.proto google/api/service_pb2.py google/api/service_pb2.pyi google/api/source_info.proto google/api/source_info_pb2.py google/api/source_info_pb2.pyi google/api/system_parameter.proto google/api/system_parameter_pb2.py google/api/system_parameter_pb2.pyi google/api/usage.proto google/api/usage_pb2.py google/api/usage_pb2.pyi google/api/visibility.proto google/api/visibility_pb2.py google/api/visibility_pb2.pyi google/cloud/common_resources.proto google/cloud/common_resources_pb2.py google/cloud/common_resources_pb2.pyi google/cloud/extended_operations.proto google/cloud/extended_operations_pb2.py google/cloud/extended_operations_pb2.pyi google/cloud/location/locations.proto google/cloud/location/locations_pb2.py google/cloud/location/locations_pb2.pyi google/gapic/metadata/gapic_metadata.proto google/gapic/metadata/gapic_metadata_pb2.py google/gapic/metadata/gapic_metadata_pb2.pyi google/logging/type/http_request.proto google/logging/type/http_request_pb2.py google/logging/type/http_request_pb2.pyi google/logging/type/log_severity.proto google/logging/type/log_severity_pb2.py google/logging/type/log_severity_pb2.pyi google/longrunning/operations_grpc.py google/longrunning/operations_grpc_pb2.py google/longrunning/operations_pb2.py google/longrunning/operations_pb2_grpc.py google/longrunning/operations_proto.proto google/longrunning/operations_proto.py google/longrunning/operations_proto_pb2.py google/longrunning/operations_proto_pb2.pyi google/rpc/code.proto google/rpc/code_pb2.py google/rpc/code_pb2.pyi google/rpc/error_details.proto google/rpc/error_details_pb2.py google/rpc/error_details_pb2.pyi google/rpc/http.proto google/rpc/http_pb2.py google/rpc/http_pb2.pyi google/rpc/status.proto google/rpc/status_pb2.py google/rpc/status_pb2.pyi google/rpc/context/attribute_context.proto google/rpc/context/attribute_context_pb2.py google/rpc/context/attribute_context_pb2.pyi google/rpc/context/audit_context.proto google/rpc/context/audit_context_pb2.py google/rpc/context/audit_context_pb2.pyi google/type/calendar_period.proto google/type/calendar_period_pb2.py google/type/calendar_period_pb2.pyi google/type/color.proto google/type/color_pb2.py google/type/color_pb2.pyi google/type/date.proto google/type/date_pb2.py google/type/date_pb2.pyi google/type/datetime.proto google/type/datetime_pb2.py google/type/datetime_pb2.pyi google/type/dayofweek.proto google/type/dayofweek_pb2.py google/type/dayofweek_pb2.pyi google/type/decimal.proto google/type/decimal_pb2.py google/type/decimal_pb2.pyi google/type/expr.proto google/type/expr_pb2.py google/type/expr_pb2.pyi google/type/fraction.proto google/type/fraction_pb2.py google/type/fraction_pb2.pyi google/type/interval.proto google/type/interval_pb2.py google/type/interval_pb2.pyi google/type/latlng.proto google/type/latlng_pb2.py google/type/latlng_pb2.pyi google/type/localized_text.proto google/type/localized_text_pb2.py google/type/localized_text_pb2.pyi google/type/money.proto google/type/money_pb2.py google/type/money_pb2.pyi google/type/month.proto google/type/month_pb2.py google/type/month_pb2.pyi google/type/phone_number.proto google/type/phone_number_pb2.py google/type/phone_number_pb2.pyi google/type/postal_address.proto google/type/postal_address_pb2.py google/type/postal_address_pb2.pyi google/type/quaternion.proto google/type/quaternion_pb2.py google/type/quaternion_pb2.pyi google/type/timeofday.proto google/type/timeofday_pb2.py google/type/timeofday_pb2.pyi googleapis_common_protos.egg-info/PKG-INFO googleapis_common_protos.egg-info/SOURCES.txt googleapis_common_protos.egg-info/dependency_links.txt googleapis_common_protos.egg-info/requires.txt googleapis_common_protos.egg-info/top_level.txt tests/unit/test_google_api_error_reason.py tests/unit/test_packaging.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778138211.0 googleapis_common_protos-1.75.0/googleapis_common_protos.egg-info/dependency_links.txt0000644000000000000000000000000115177036143030327 0ustar00rootroot ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778138211.0 googleapis_common_protos-1.75.0/googleapis_common_protos.egg-info/requires.txt0000644000000000000000000000006615177036143026663 0ustar00rootrootprotobuf<8.0.0,>=4.25.8 [grpc] grpcio<2.0.0,>=1.44.0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778138211.0 googleapis_common_protos-1.75.0/googleapis_common_protos.egg-info/top_level.txt0000644000000000000000000000000715177036143027010 0ustar00rootrootgoogle ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/pyproject.toml0000644000000000000000000000340715177035224020377 0ustar00rootroot# Copyright 2024 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. [build-system] requires = ["setuptools"] build-backend = "setuptools.build_meta" [project] name = "googleapis-common-protos" version = "1.75.0" authors = [{ name = "Google LLC", email = "googleapis-packages@google.com" }] license = { text = "Apache 2.0" } requires-python = ">= 3.9" readme = "README.rst" description = "Common protobufs used in Google APIs" classifiers = [ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: Apache Software License", "Programming Language :: Python", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", "Operating System :: OS Independent", "Topic :: Internet", ] dependencies = [ "protobuf >= 4.25.8, < 8.0.0", ] [project.urls] Repository = "https://github.com/googleapis/google-cloud-python/tree/main/packages/googleapis-common-protos" [project.optional-dependencies] grpc = ["grpcio >= 1.44.0, < 2.0.0"] [tool.setuptools.packages.find] include = ["google*"] ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0795033 googleapis_common_protos-1.75.0/setup.cfg0000644000000000000000000000004615177036143017301 0ustar00rootroot[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137748.0 googleapis_common_protos-1.75.0/setup.py0000644000000000000000000000114615177035224017173 0ustar00rootroot# Copyright 2020 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 # # https://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. import setuptools setuptools.setup() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0453506 googleapis_common_protos-1.75.0/tests/0000755000000000000000000000000015177036143016622 5ustar00rootroot././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1778138211.0781825 googleapis_common_protos-1.75.0/tests/unit/0000755000000000000000000000000015177036143017601 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137749.0 googleapis_common_protos-1.75.0/tests/unit/test_google_api_error_reason.py0000644000000000000000000000124415177035225026100 0ustar00rootroot# Copyright 2022 Google LLC 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. def test_error_reason(): from google.api import error_reason_pb2 # noqa: F401 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1778137750.0 googleapis_common_protos-1.75.0/tests/unit/test_packaging.py0000644000000000000000000000351615177035226023144 0ustar00rootroot# Copyright 2023 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. import os import subprocess import sys def test_namespace_package_compat(tmp_path): """ The ``google`` namespace package should not be masked by the presence of ``googleapis-common-protos``. """ google = tmp_path / "google" google.mkdir() google.joinpath("othermod.py").write_text("") env = dict(os.environ, PYTHONPATH=str(tmp_path)) cmd = [sys.executable, "-m", "google.othermod"] subprocess.check_call(cmd, env=env) """ The ``google.cloud`` namespace package should not be masked by the presence of ``googleapis-common-protos``. """ google_cloud = tmp_path / "google/cloud" google_cloud.mkdir() google_cloud.joinpath("othermod.py").write_text("") env = dict(os.environ, PYTHONPATH=str(tmp_path)) cmd = [sys.executable, "-m", "google.cloud.othermod"] subprocess.check_call(cmd, env=env) """ The ``google.logging`` namespace package should not be masked by the presence of ``googleapis-common-protos``. """ google_logging = tmp_path / "google/logging" google_logging.mkdir() google_logging.joinpath("othermod.py").write_text("") env = dict(os.environ, PYTHONPATH=str(tmp_path)) cmd = [sys.executable, "-m", "google.logging.othermod"] subprocess.check_call(cmd, env=env)