google-cloud-memorystore 0.2.0__tar.gz → 0.3.0__tar.gz

{google_cloud_memorystore-0.2.0/google_cloud_memorystore.egg-info → google_cloud_memorystore-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-memorystore
-Version: 0.2.0
+Version: 0.3.0
 Summary: Google Cloud Memorystore API client library
 Home-page: https://github.com/googleapis/google-cloud-python/tree/main/packages/google-cloud-memorystore
 Author: Google LLC

{google_cloud_memorystore-0.2.0 → google_cloud_memorystore-0.3.0}/google/cloud/memorystore/__init__.py

@@ -32,6 +32,7 @@ from google.cloud.memorystore_v1.types.memorystore import (
     DeleteBackupRequest,
     DeleteInstanceRequest,
     DiscoveryEndpoint,
+    EncryptionInfo,
     ExportBackupRequest,
     GetBackupCollectionRequest,
     GetBackupRequest,
@@ -72,6 +73,7 @@ __all__ = (
     "DeleteBackupRequest",
     "DeleteInstanceRequest",
     "DiscoveryEndpoint",
+    "EncryptionInfo",
     "ExportBackupRequest",
     "GetBackupCollectionRequest",
     "GetBackupRequest",

{google_cloud_memorystore-0.2.0 → google_cloud_memorystore-0.3.0}/google/cloud/memorystore/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "0.2.0"  # {x-release-please-version}
+__version__ = "0.3.0"  # {x-release-please-version}

google_cloud_memorystore-0.3.0/google/cloud/memorystore_v1/__init__.py

@@ -0,0 +1,207 @@
+# -*- 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.
+#
+import sys
+
+import google.api_core as api_core
+
+from google.cloud.memorystore_v1 import gapic_version as package_version
+
+__version__ = package_version.__version__
+
+if sys.version_info >= (3, 8):  # pragma: NO COVER
+    from importlib import metadata
+else:  # pragma: NO COVER
+    # TODO(https://github.com/googleapis/python-api-core/issues/835): Remove
+    # this code path once we drop support for Python 3.7
+    import importlib_metadata as metadata
+
+from .services.memorystore import MemorystoreClient
+from .types.memorystore import (
+    AutomatedBackupConfig,
+    Backup,
+    BackupCollection,
+    BackupFile,
+    BackupInstanceRequest,
+    CertificateAuthority,
+    ConnectionType,
+    CreateInstanceRequest,
+    CrossInstanceReplicationConfig,
+    DeleteBackupRequest,
+    DeleteInstanceRequest,
+    DiscoveryEndpoint,
+    EncryptionInfo,
+    ExportBackupRequest,
+    GetBackupCollectionRequest,
+    GetBackupRequest,
+    GetCertificateAuthorityRequest,
+    GetInstanceRequest,
+    Instance,
+    ListBackupCollectionsRequest,
+    ListBackupCollectionsResponse,
+    ListBackupsRequest,
+    ListBackupsResponse,
+    ListInstancesRequest,
+    ListInstancesResponse,
+    MaintenancePolicy,
+    MaintenanceSchedule,
+    NodeConfig,
+    OperationMetadata,
+    PersistenceConfig,
+    PscAttachmentDetail,
+    PscAutoConnection,
+    PscConnection,
+    PscConnectionStatus,
+    RescheduleMaintenanceRequest,
+    UpdateInstanceRequest,
+    WeeklyMaintenanceWindow,
+    ZoneDistributionConfig,
+)
+
+if hasattr(api_core, "check_python_version") and hasattr(
+    api_core, "check_dependency_versions"
+):  # pragma: NO COVER
+    api_core.check_python_version("google.cloud.memorystore_v1")  # type: ignore
+    api_core.check_dependency_versions("google.cloud.memorystore_v1")  # type: ignore
+else:  # pragma: NO COVER
+    # An older version of api_core is installed which does not define the
+    # functions above. We do equivalent checks manually.
+    try:
+        import sys
+        import warnings
+
+        _py_version_str = sys.version.split()[0]
+        _package_label = "google.cloud.memorystore_v1"
+        if sys.version_info < (3, 9):
+            warnings.warn(
+                "You are using a non-supported Python version "
+                + f"({_py_version_str}).  Google will not post any further "
+                + f"updates to {_package_label} supporting this Python version. "
+                + "Please upgrade to the latest Python version, or at "
+                + f"least to Python 3.9, and then update {_package_label}.",
+                FutureWarning,
+            )
+        if sys.version_info[:2] == (3, 9):
+            warnings.warn(
+                f"You are using a Python version ({_py_version_str}) "
+                + f"which Google will stop supporting in {_package_label} in "
+                + "January 2026. Please "
+                + "upgrade to the latest Python version, or at "
+                + "least to Python 3.10, before then, and "
+                + f"then update {_package_label}.",
+                FutureWarning,
+            )
+
+        def parse_version_to_tuple(version_string: str):
+            """Safely converts a semantic version string to a comparable tuple of integers.
+            Example: "4.25.8" -> (4, 25, 8)
+            Ignores non-numeric parts and handles common version formats.
+            Args:
+                version_string: Version string in the format "x.y.z" or "x.y.z<suffix>"
+            Returns:
+                Tuple of integers for the parsed version string.
+            """
+            parts = []
+            for part in version_string.split("."):
+                try:
+                    parts.append(int(part))
+                except ValueError:
+                    # If it's a non-numeric part (e.g., '1.0.0b1' -> 'b1'), stop here.
+                    # This is a simplification compared to 'packaging.parse_version', but sufficient
+                    # for comparing strictly numeric semantic versions.
+                    break
+            return tuple(parts)
+
+        def _get_version(dependency_name):
+            try:
+                version_string: str = metadata.version(dependency_name)
+                parsed_version = parse_version_to_tuple(version_string)
+                return (parsed_version, version_string)
+            except Exception:
+                # Catch exceptions from metadata.version() (e.g., PackageNotFoundError)
+                # or errors during parse_version_to_tuple
+                return (None, "--")
+
+        _dependency_package = "google.protobuf"
+        _next_supported_version = "4.25.8"
+        _next_supported_version_tuple = (4, 25, 8)
+        _recommendation = " (we recommend 6.x)"
+        (_version_used, _version_used_string) = _get_version(_dependency_package)
+        if _version_used and _version_used < _next_supported_version_tuple:
+            warnings.warn(
+                f"Package {_package_label} depends on "
+                + f"{_dependency_package}, currently installed at version "
+                + f"{_version_used_string}. Future updates to "
+                + f"{_package_label} will require {_dependency_package} at "
+                + f"version {_next_supported_version} or higher{_recommendation}."
+                + " Please ensure "
+                + "that either (a) your Python environment doesn't pin the "
+                + f"version of {_dependency_package}, so that updates to "
+                + f"{_package_label} can require the higher version, or "
+                + "(b) you manually update your Python environment to use at "
+                + f"least version {_next_supported_version} of "
+                + f"{_dependency_package}.",
+                FutureWarning,
+            )
+    except Exception:
+        warnings.warn(
+            "Could not determine the version of Python "
+            + "currently being used. To continue receiving "
+            + "updates for {_package_label}, ensure you are "
+            + "using a supported version of Python; see "
+            + "https://devguide.python.org/versions/"
+        )
+
+__all__ = (
+    "AutomatedBackupConfig",
+    "Backup",
+    "BackupCollection",
+    "BackupFile",
+    "BackupInstanceRequest",
+    "CertificateAuthority",
+    "ConnectionType",
+    "CreateInstanceRequest",
+    "CrossInstanceReplicationConfig",
+    "DeleteBackupRequest",
+    "DeleteInstanceRequest",
+    "DiscoveryEndpoint",
+    "EncryptionInfo",
+    "ExportBackupRequest",
+    "GetBackupCollectionRequest",
+    "GetBackupRequest",
+    "GetCertificateAuthorityRequest",
+    "GetInstanceRequest",
+    "Instance",
+    "ListBackupCollectionsRequest",
+    "ListBackupCollectionsResponse",
+    "ListBackupsRequest",
+    "ListBackupsResponse",
+    "ListInstancesRequest",
+    "ListInstancesResponse",
+    "MaintenancePolicy",
+    "MaintenanceSchedule",
+    "MemorystoreClient",
+    "NodeConfig",
+    "OperationMetadata",
+    "PersistenceConfig",
+    "PscAttachmentDetail",
+    "PscAutoConnection",
+    "PscConnection",
+    "PscConnectionStatus",
+    "RescheduleMaintenanceRequest",
+    "UpdateInstanceRequest",
+    "WeeklyMaintenanceWindow",
+    "ZoneDistributionConfig",
+)

{google_cloud_memorystore-0.2.0/google/cloud/memorystore_v1beta → google_cloud_memorystore-0.3.0/google/cloud/memorystore_v1}/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "0.2.0"  # {x-release-please-version}
+__version__ = "0.3.0"  # {x-release-please-version}

{google_cloud_memorystore-0.2.0 → google_cloud_memorystore-0.3.0}/google/cloud/memorystore_v1/services/memorystore/client.py

@@ -151,6 +151,34 @@ class MemorystoreClient(metaclass=MemorystoreClientMeta):
     _DEFAULT_ENDPOINT_TEMPLATE = "memorystore.{UNIVERSE_DOMAIN}"
     _DEFAULT_UNIVERSE = "googleapis.com"
 
+    @staticmethod
+    def _use_client_cert_effective():
+        """Returns whether client certificate should be used for mTLS if the
+        google-auth version supports should_use_client_cert automatic mTLS enablement.
+
+        Alternatively, read from the GOOGLE_API_USE_CLIENT_CERTIFICATE env var.
+
+        Returns:
+            bool: whether client certificate should be used for mTLS
+        Raises:
+            ValueError: (If using a version of google-auth without should_use_client_cert and
+            GOOGLE_API_USE_CLIENT_CERTIFICATE is set to an unexpected value.)
+        """
+        # check if google-auth version supports should_use_client_cert for automatic mTLS enablement
+        if hasattr(mtls, "should_use_client_cert"):  # pragma: NO COVER
+            return mtls.should_use_client_cert()
+        else:  # pragma: NO COVER
+            # if unsupported, fallback to reading from env var
+            use_client_cert_str = os.getenv(
+                "GOOGLE_API_USE_CLIENT_CERTIFICATE", "false"
+            ).lower()
+            if use_client_cert_str not in ("true", "false"):
+                raise ValueError(
+                    "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be"
+                    " either `true` or `false`"
+                )
+            return use_client_cert_str == "true"
+
     @classmethod
     def from_service_account_info(cls, info: dict, *args, **kwargs):
         """Creates an instance of this client using the provided credentials
@@ -290,6 +318,32 @@ class MemorystoreClient(metaclass=MemorystoreClientMeta):
         )
         return m.groupdict() if m else {}
 
+    @staticmethod
+    def crypto_key_version_path(
+        project: str,
+        location: str,
+        key_ring: str,
+        crypto_key: str,
+        crypto_key_version: str,
+    ) -> str:
+        """Returns a fully-qualified crypto_key_version string."""
+        return "projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{crypto_key}/cryptoKeyVersions/{crypto_key_version}".format(
+            project=project,
+            location=location,
+            key_ring=key_ring,
+            crypto_key=crypto_key,
+            crypto_key_version=crypto_key_version,
+        )
+
+    @staticmethod
+    def parse_crypto_key_version_path(path: str) -> Dict[str, str]:
+        """Parses a crypto_key_version path into its component segments."""
+        m = re.match(
+            r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/keyRings/(?P<key_ring>.+?)/cryptoKeys/(?P<crypto_key>.+?)/cryptoKeyVersions/(?P<crypto_key_version>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
     @staticmethod
     def forwarding_rule_path(
         project: str,
@@ -493,12 +547,8 @@ class MemorystoreClient(metaclass=MemorystoreClientMeta):
         )
         if client_options is None:
             client_options = client_options_lib.ClientOptions()
-        use_client_cert = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false")
+        use_client_cert = MemorystoreClient._use_client_cert_effective()
         use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto")
-        if use_client_cert not in ("true", "false"):
-            raise ValueError(
-                "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
-            )
         if use_mtls_endpoint not in ("auto", "never", "always"):
             raise MutualTLSChannelError(
                 "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`"
@@ -506,7 +556,7 @@ class MemorystoreClient(metaclass=MemorystoreClientMeta):
 
         # Figure out the client cert source to use.
         client_cert_source = None
-        if use_client_cert == "true":
+        if use_client_cert:
             if client_options.client_cert_source:
                 client_cert_source = client_options.client_cert_source
             elif mtls.has_default_client_cert_source():
@@ -538,20 +588,14 @@ class MemorystoreClient(metaclass=MemorystoreClientMeta):
             google.auth.exceptions.MutualTLSChannelError: If GOOGLE_API_USE_MTLS_ENDPOINT
                 is not any of ["auto", "never", "always"].
         """
-        use_client_cert = os.getenv(
-            "GOOGLE_API_USE_CLIENT_CERTIFICATE", "false"
-        ).lower()
+        use_client_cert = MemorystoreClient._use_client_cert_effective()
         use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower()
         universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN")
-        if use_client_cert not in ("true", "false"):
-            raise ValueError(
-                "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
-            )
         if use_mtls_endpoint not in ("auto", "never", "always"):
             raise MutualTLSChannelError(
                 "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`"
             )
-        return use_client_cert == "true", use_mtls_endpoint, universe_domain_env
+        return use_client_cert, use_mtls_endpoint, universe_domain_env
 
     @staticmethod
     def _get_client_cert_source(provided_cert_source, use_cert_flag):

{google_cloud_memorystore-0.2.0 → google_cloud_memorystore-0.3.0}/google/cloud/memorystore_v1/types/__init__.py

@@ -26,6 +26,7 @@ from .memorystore import (
     DeleteBackupRequest,
     DeleteInstanceRequest,
     DiscoveryEndpoint,
+    EncryptionInfo,
     ExportBackupRequest,
     GetBackupCollectionRequest,
     GetBackupRequest,
@@ -65,6 +66,7 @@ __all__ = (
     "DeleteBackupRequest",
     "DeleteInstanceRequest",
     "DiscoveryEndpoint",
+    "EncryptionInfo",
     "ExportBackupRequest",
     "GetBackupCollectionRequest",
     "GetBackupRequest",

{google_cloud_memorystore-0.2.0 → google_cloud_memorystore-0.3.0}/google/cloud/memorystore_v1/types/memorystore.py

@@ -64,6 +64,7 @@ __protobuf__ = proto.module(
         "GetCertificateAuthorityRequest",
         "CertificateAuthority",
         "OperationMetadata",
+        "EncryptionInfo",
     },
 )
 
@@ -165,9 +166,13 @@ class Instance(proto.Message):
         shard_count (int):
             Optional. Number of shards for the instance.
         discovery_endpoints (MutableSequence[google.cloud.memorystore_v1.types.DiscoveryEndpoint]):
-            Output only. Deprecated: Use the
-            endpoints.connections.psc_auto_connection or
-            endpoints.connections.psc_connection values instead.
+            Output only. Deprecated: The discovery_endpoints parameter
+            is deprecated. As a result, it will not be populated if the
+            connections are created using endpoints parameter. Instead
+            of this parameter, for discovery, use
+            endpoints.connections.pscConnection and
+            endpoints.connections.pscAutoConnection with connectionType
+            CONNECTION_TYPE_DISCOVERY.
         node_type (google.cloud.memorystore_v1.types.Instance.NodeType):
             Optional. Machine type for individual nodes
             of the instance.
@@ -201,11 +206,26 @@ class Instance(proto.Message):
             Optional. Endpoints for the instance.
         mode (google.cloud.memorystore_v1.types.Instance.Mode):
             Optional. The mode config for the instance.
+        simulate_maintenance_event (bool):
+            Optional. Input only. Simulate a maintenance
+            event.
+
+            This field is a member of `oneof`_ ``_simulate_maintenance_event``.
         ondemand_maintenance (bool):
             Optional. Input only. Ondemand maintenance
             for the instance.
 
             This field is a member of `oneof`_ ``_ondemand_maintenance``.
+        satisfies_pzs (bool):
+            Optional. Output only. Reserved for future
+            use.
+
+            This field is a member of `oneof`_ ``_satisfies_pzs``.
+        satisfies_pzi (bool):
+            Optional. Output only. Reserved for future
+            use.
+
+            This field is a member of `oneof`_ ``_satisfies_pzi``.
         maintenance_policy (google.cloud.memorystore_v1.types.MaintenancePolicy):
             Optional. The maintenance policy for the
             instance. If not provided, the maintenance event
@@ -225,6 +245,14 @@ class Instance(proto.Message):
             are deleted.
 
             This field is a member of `oneof`_ ``_async_instance_endpoints_deletion_enabled``.
+        kms_key (str):
+            Optional. The KMS key used to encrypt the
+            at-rest data of the cluster.
+
+            This field is a member of `oneof`_ ``_kms_key``.
+        encryption_info (google.cloud.memorystore_v1.types.EncryptionInfo):
+            Output only. Encryption information of the
+            data at rest of the cluster.
         backup_collection (str):
             Output only. The backup collection full
             resource name. Example:
@@ -234,6 +262,24 @@ class Instance(proto.Message):
         automated_backup_config (google.cloud.memorystore_v1.types.AutomatedBackupConfig):
             Optional. The automated backup config for the
             instance.
+        maintenance_version (str):
+            Optional. This field can be used to trigger self service
+            update to indicate the desired maintenance version. The
+            input to this field can be determined by the
+            available_maintenance_versions field.
+
+            This field is a member of `oneof`_ ``_maintenance_version``.
+        effective_maintenance_version (str):
+            Output only. This field represents the actual
+            maintenance version of the instance.
+
+            This field is a member of `oneof`_ ``_effective_maintenance_version``.
+        available_maintenance_versions (MutableSequence[str]):
+            Output only. This field is used to determine
+            the available maintenance versions for the self
+            service update.
+        allow_fewer_zones_deployment (bool):
+            Optional. Immutable. Deprecated, do not use.
     """
 
     class State(proto.Enum):
@@ -616,11 +662,26 @@ class Instance(proto.Message):
         number=26,
         enum=Mode,
     )
+    simulate_maintenance_event: bool = proto.Field(
+        proto.BOOL,
+        number=27,
+        optional=True,
+    )
     ondemand_maintenance: bool = proto.Field(
         proto.BOOL,
         number=28,
         optional=True,
     )
+    satisfies_pzs: bool = proto.Field(
+        proto.BOOL,
+        number=29,
+        optional=True,
+    )
+    satisfies_pzi: bool = proto.Field(
+        proto.BOOL,
+        number=30,
+        optional=True,
+    )
     maintenance_policy: "MaintenancePolicy" = proto.Field(
         proto.MESSAGE,
         number=31,
@@ -641,6 +702,16 @@ class Instance(proto.Message):
         number=44,
         optional=True,
     )
+    kms_key: str = proto.Field(
+        proto.STRING,
+        number=45,
+        optional=True,
+    )
+    encryption_info: "EncryptionInfo" = proto.Field(
+        proto.MESSAGE,
+        number=46,
+        message="EncryptionInfo",
+    )
     backup_collection: str = proto.Field(
         proto.STRING,
         number=47,
@@ -651,6 +722,24 @@ class Instance(proto.Message):
         number=48,
         message="AutomatedBackupConfig",
     )
+    maintenance_version: str = proto.Field(
+        proto.STRING,
+        number=49,
+        optional=True,
+    )
+    effective_maintenance_version: str = proto.Field(
+        proto.STRING,
+        number=50,
+        optional=True,
+    )
+    available_maintenance_versions: MutableSequence[str] = proto.RepeatedField(
+        proto.STRING,
+        number=51,
+    )
+    allow_fewer_zones_deployment: bool = proto.Field(
+        proto.BOOL,
+        number=54,
+    )
 
 
 class AutomatedBackupConfig(proto.Message):
@@ -751,6 +840,15 @@ class BackupCollection(proto.Message):
         create_time (google.protobuf.timestamp_pb2.Timestamp):
             Output only. The time when the backup
             collection was created.
+        total_backup_size_bytes (int):
+            Output only. Total size of all backups in the
+            backup collection.
+        total_backup_count (int):
+            Output only. Total number of backups in the
+            backup collection.
+        last_backup_time (google.protobuf.timestamp_pb2.Timestamp):
+            Output only. The last time a backup was
+            created in the backup collection.
     """
 
     name: str = proto.Field(
@@ -778,6 +876,19 @@ class BackupCollection(proto.Message):
         number=7,
         message=timestamp_pb2.Timestamp,
     )
+    total_backup_size_bytes: int = proto.Field(
+        proto.INT64,
+        number=8,
+    )
+    total_backup_count: int = proto.Field(
+        proto.INT64,
+        number=10,
+    )
+    last_backup_time: timestamp_pb2.Timestamp = proto.Field(
+        proto.MESSAGE,
+        number=11,
+        message=timestamp_pb2.Timestamp,
+    )
 
 
 class Backup(proto.Message):
@@ -821,6 +932,9 @@ class Backup(proto.Message):
             Output only. Type of the backup.
         state (google.cloud.memorystore_v1.types.Backup.State):
             Output only. State of the backup.
+        encryption_info (google.cloud.memorystore_v1.types.EncryptionInfo):
+            Output only. Encryption information of the
+            backup.
         uid (str):
             Output only. System assigned unique
             identifier of the backup.
@@ -922,6 +1036,11 @@ class Backup(proto.Message):
         number=13,
         enum=State,
     )
+    encryption_info: "EncryptionInfo" = proto.Field(
+        proto.MESSAGE,
+        number=14,
+        message="EncryptionInfo",
+    )
     uid: str = proto.Field(
         proto.STRING,
         number=15,
@@ -2297,4 +2416,99 @@ class OperationMetadata(proto.Message):
     )
 
 
+class EncryptionInfo(proto.Message):
+    r"""EncryptionInfo describes the encryption information of a
+    cluster.
+
+    Attributes:
+        encryption_type (google.cloud.memorystore_v1.types.EncryptionInfo.Type):
+            Output only. Type of encryption.
+        kms_key_versions (MutableSequence[str]):
+            Output only. KMS key versions that are being
+            used to protect the data at-rest.
+        kms_key_primary_state (google.cloud.memorystore_v1.types.EncryptionInfo.KmsKeyState):
+            Output only. The state of the primary version
+            of the KMS key perceived by the system. This
+            field is not populated in backups.
+        last_update_time (google.protobuf.timestamp_pb2.Timestamp):
+            Output only. The most recent time when the
+            encryption info was updated.
+    """
+
+    class Type(proto.Enum):
+        r"""Possible encryption types.
+
+        Values:
+            TYPE_UNSPECIFIED (0):
+                Encryption type not specified. Defaults to
+                GOOGLE_DEFAULT_ENCRYPTION.
+            GOOGLE_DEFAULT_ENCRYPTION (1):
+                The data is encrypted at rest with a key that
+                is fully managed by Google. No key version will
+                be populated. This is the default state.
+            CUSTOMER_MANAGED_ENCRYPTION (2):
+                The data is encrypted at rest with a key that
+                is managed by the customer. KMS key versions
+                will be populated.
+        """
+        TYPE_UNSPECIFIED = 0
+        GOOGLE_DEFAULT_ENCRYPTION = 1
+        CUSTOMER_MANAGED_ENCRYPTION = 2
+
+    class KmsKeyState(proto.Enum):
+        r"""The state of the KMS key perceived by the system. Refer to
+        the public documentation for the impact of each state.
+
+        Values:
+            KMS_KEY_STATE_UNSPECIFIED (0):
+                The default value. This value is unused.
+            ENABLED (1):
+                The KMS key is enabled and correctly
+                configured.
+            PERMISSION_DENIED (2):
+                Permission denied on the KMS key.
+            DISABLED (3):
+                The KMS key is disabled.
+            DESTROYED (4):
+                The KMS key is destroyed.
+            DESTROY_SCHEDULED (5):
+                The KMS key is scheduled to be destroyed.
+            EKM_KEY_UNREACHABLE_DETECTED (6):
+                The EKM key is unreachable.
+            BILLING_DISABLED (7):
+                Billing is disabled for the project.
+            UNKNOWN_FAILURE (8):
+                All other unknown failures.
+        """
+        KMS_KEY_STATE_UNSPECIFIED = 0
+        ENABLED = 1
+        PERMISSION_DENIED = 2
+        DISABLED = 3
+        DESTROYED = 4
+        DESTROY_SCHEDULED = 5
+        EKM_KEY_UNREACHABLE_DETECTED = 6
+        BILLING_DISABLED = 7
+        UNKNOWN_FAILURE = 8
+
+    encryption_type: Type = proto.Field(
+        proto.ENUM,
+        number=1,
+        enum=Type,
+    )
+    kms_key_versions: MutableSequence[str] = proto.RepeatedField(
+        proto.STRING,
+        number=2,
+    )
+    kms_key_primary_state: KmsKeyState = proto.Field(
+        proto.ENUM,
+        number=3,
+        enum=KmsKeyState,
+    )
+    last_update_time: timestamp_pb2.Timestamp = proto.Field(
+        proto.MESSAGE,
+        number=4,
+        message=timestamp_pb2.Timestamp,
+    )
+
+
 __all__ = tuple(sorted(__protobuf__.manifest))