pulumi-oci 1.11.0a1695829678__py3-none-any.whl → 1.12.0__py3-none-any.whl

pulumi_oci/kms/encrypted_data.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
 
 __all__ = ['EncryptedDataArgs', 'EncryptedData']
@@ -31,21 +31,42 @@ class EncryptedDataArgs:
                ** IMPORTANT **
                Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         :param pulumi.Input[Mapping[str, Any]] associated_data: Information that can be used to provide an encryption context for the encrypted data. The length of the string representation of the associated data must be fewer than 4096 characters.
-        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and  that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the  key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP).  `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash  and uses OAEP.
+        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP). `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash and uses OAEP.
         :param pulumi.Input[str] key_version_id: The OCID of the key version used to encrypt the ciphertext.
         :param pulumi.Input[Mapping[str, Any]] logging_context: Information that provides context for audit logging. You can provide this additional data as key-value pairs to include in the audit logs when audit logging is enabled.
         """
-        pulumi.set(__self__, "crypto_endpoint", crypto_endpoint)
-        pulumi.set(__self__, "key_id", key_id)
-        pulumi.set(__self__, "plaintext", plaintext)
+        EncryptedDataArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            crypto_endpoint=crypto_endpoint,
+            key_id=key_id,
+            plaintext=plaintext,
+            associated_data=associated_data,
+            encryption_algorithm=encryption_algorithm,
+            key_version_id=key_version_id,
+            logging_context=logging_context,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             crypto_endpoint: pulumi.Input[str],
+             key_id: pulumi.Input[str],
+             plaintext: pulumi.Input[str],
+             associated_data: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             encryption_algorithm: Optional[pulumi.Input[str]] = None,
+             key_version_id: Optional[pulumi.Input[str]] = None,
+             logging_context: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("crypto_endpoint", crypto_endpoint)
+        _setter("key_id", key_id)
+        _setter("plaintext", plaintext)
         if associated_data is not None:
-            pulumi.set(__self__, "associated_data", associated_data)
+            _setter("associated_data", associated_data)
         if encryption_algorithm is not None:
-            pulumi.set(__self__, "encryption_algorithm", encryption_algorithm)
+            _setter("encryption_algorithm", encryption_algorithm)
         if key_version_id is not None:
-            pulumi.set(__self__, "key_version_id", key_version_id)
+            _setter("key_version_id", key_version_id)
         if logging_context is not None:
-            pulumi.set(__self__, "logging_context", logging_context)
+            _setter("logging_context", logging_context)
 
     @property
     @pulumi.getter(name="cryptoEndpoint")
@@ -103,7 +124,7 @@ class EncryptedDataArgs:
     @pulumi.getter(name="encryptionAlgorithm")
     def encryption_algorithm(self) -> Optional[pulumi.Input[str]]:
         """
-        The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and  that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the  key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP).  `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash  and uses OAEP.
+        The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP). `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash and uses OAEP.
         """
         return pulumi.get(self, "encryption_algorithm")
 
@@ -152,7 +173,7 @@ class _EncryptedDataState:
         :param pulumi.Input[Mapping[str, Any]] associated_data: Information that can be used to provide an encryption context for the encrypted data. The length of the string representation of the associated data must be fewer than 4096 characters.
         :param pulumi.Input[str] ciphertext: The encrypted data.
         :param pulumi.Input[str] crypto_endpoint: The service endpoint to perform cryptographic operations against. Cryptographic operations include 'Encrypt,' 'Decrypt,' and 'GenerateDataEncryptionKey' operations. see Vault Crypto endpoint.
-        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and  that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the  key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP).  `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash  and uses OAEP.
+        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP). `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash and uses OAEP.
         :param pulumi.Input[str] key_id: The OCID of the key to encrypt with.
         :param pulumi.Input[str] key_version_id: The OCID of the key version used to encrypt the ciphertext.
         :param pulumi.Input[Mapping[str, Any]] logging_context: Information that provides context for audit logging. You can provide this additional data as key-value pairs to include in the audit logs when audit logging is enabled.
@@ -162,22 +183,45 @@ class _EncryptedDataState:
                ** IMPORTANT **
                Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         """
+        _EncryptedDataState._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            associated_data=associated_data,
+            ciphertext=ciphertext,
+            crypto_endpoint=crypto_endpoint,
+            encryption_algorithm=encryption_algorithm,
+            key_id=key_id,
+            key_version_id=key_version_id,
+            logging_context=logging_context,
+            plaintext=plaintext,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             associated_data: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             ciphertext: Optional[pulumi.Input[str]] = None,
+             crypto_endpoint: Optional[pulumi.Input[str]] = None,
+             encryption_algorithm: Optional[pulumi.Input[str]] = None,
+             key_id: Optional[pulumi.Input[str]] = None,
+             key_version_id: Optional[pulumi.Input[str]] = None,
+             logging_context: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             plaintext: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if associated_data is not None:
-            pulumi.set(__self__, "associated_data", associated_data)
+            _setter("associated_data", associated_data)
         if ciphertext is not None:
-            pulumi.set(__self__, "ciphertext", ciphertext)
+            _setter("ciphertext", ciphertext)
         if crypto_endpoint is not None:
-            pulumi.set(__self__, "crypto_endpoint", crypto_endpoint)
+            _setter("crypto_endpoint", crypto_endpoint)
         if encryption_algorithm is not None:
-            pulumi.set(__self__, "encryption_algorithm", encryption_algorithm)
+            _setter("encryption_algorithm", encryption_algorithm)
         if key_id is not None:
-            pulumi.set(__self__, "key_id", key_id)
+            _setter("key_id", key_id)
         if key_version_id is not None:
-            pulumi.set(__self__, "key_version_id", key_version_id)
+            _setter("key_version_id", key_version_id)
         if logging_context is not None:
-            pulumi.set(__self__, "logging_context", logging_context)
+            _setter("logging_context", logging_context)
         if plaintext is not None:
-            pulumi.set(__self__, "plaintext", plaintext)
+            _setter("plaintext", plaintext)
 
     @property
     @pulumi.getter(name="associatedData")
@@ -219,7 +263,7 @@ class _EncryptedDataState:
     @pulumi.getter(name="encryptionAlgorithm")
     def encryption_algorithm(self) -> Optional[pulumi.Input[str]]:
         """
-        The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and  that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the  key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP).  `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash  and uses OAEP.
+        The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP). `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash and uses OAEP.
         """
         return pulumi.get(self, "encryption_algorithm")
 
@@ -323,7 +367,7 @@ class EncryptedData(pulumi.CustomResource):
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[Mapping[str, Any]] associated_data: Information that can be used to provide an encryption context for the encrypted data. The length of the string representation of the associated data must be fewer than 4096 characters.
         :param pulumi.Input[str] crypto_endpoint: The service endpoint to perform cryptographic operations against. Cryptographic operations include 'Encrypt,' 'Decrypt,' and 'GenerateDataEncryptionKey' operations. see Vault Crypto endpoint.
-        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and  that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the  key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP).  `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash  and uses OAEP.
+        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP). `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash and uses OAEP.
         :param pulumi.Input[str] key_id: The OCID of the key to encrypt with.
         :param pulumi.Input[str] key_version_id: The OCID of the key version used to encrypt the ciphertext.
         :param pulumi.Input[Mapping[str, Any]] logging_context: Information that provides context for audit logging. You can provide this additional data as key-value pairs to include in the audit logs when audit logging is enabled.
@@ -375,6 +419,10 @@ class EncryptedData(pulumi.CustomResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
+            kwargs = kwargs or {}
+            def _setter(key, value):
+                kwargs[key] = value
+            EncryptedDataArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,
@@ -438,7 +486,7 @@ class EncryptedData(pulumi.CustomResource):
         :param pulumi.Input[Mapping[str, Any]] associated_data: Information that can be used to provide an encryption context for the encrypted data. The length of the string representation of the associated data must be fewer than 4096 characters.
         :param pulumi.Input[str] ciphertext: The encrypted data.
         :param pulumi.Input[str] crypto_endpoint: The service endpoint to perform cryptographic operations against. Cryptographic operations include 'Encrypt,' 'Decrypt,' and 'GenerateDataEncryptionKey' operations. see Vault Crypto endpoint.
-        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and  that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the  key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP).  `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash  and uses OAEP.
+        :param pulumi.Input[str] encryption_algorithm: The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP). `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash and uses OAEP.
         :param pulumi.Input[str] key_id: The OCID of the key to encrypt with.
         :param pulumi.Input[str] key_version_id: The OCID of the key version used to encrypt the ciphertext.
         :param pulumi.Input[Mapping[str, Any]] logging_context: Information that provides context for audit logging. You can provide this additional data as key-value pairs to include in the audit logs when audit logging is enabled.
@@ -490,7 +538,7 @@ class EncryptedData(pulumi.CustomResource):
     @pulumi.getter(name="encryptionAlgorithm")
     def encryption_algorithm(self) -> pulumi.Output[str]:
         """
-        The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and  that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the  key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP).  `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash  and uses OAEP.
+        The encryption algorithm to use to encrypt and decrypt data with a customer-managed key. `AES_256_GCM` indicates that the key is a symmetric key that uses the Advanced Encryption Standard (AES) algorithm and that the mode of encryption is the Galois/Counter Mode (GCM). `RSA_OAEP_SHA_1` indicates that the key is an asymmetric key that uses the RSA encryption algorithm and uses Optimal Asymmetric Encryption Padding (OAEP). `RSA_OAEP_SHA_256` indicates that the key is an asymmetric key that uses the RSA encryption algorithm with a SHA-256 hash and uses OAEP.
         """
         return pulumi.get(self, "encryption_algorithm")
 

pulumi_oci/kms/generated_key.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
 from . import outputs
 from ._inputs import *
@@ -35,14 +35,33 @@ class GeneratedKeyArgs:
                ** IMPORTANT **
                Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         """
-        pulumi.set(__self__, "crypto_endpoint", crypto_endpoint)
-        pulumi.set(__self__, "include_plaintext_key", include_plaintext_key)
-        pulumi.set(__self__, "key_id", key_id)
-        pulumi.set(__self__, "key_shape", key_shape)
+        GeneratedKeyArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            crypto_endpoint=crypto_endpoint,
+            include_plaintext_key=include_plaintext_key,
+            key_id=key_id,
+            key_shape=key_shape,
+            associated_data=associated_data,
+            logging_context=logging_context,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             crypto_endpoint: pulumi.Input[str],
+             include_plaintext_key: pulumi.Input[bool],
+             key_id: pulumi.Input[str],
+             key_shape: pulumi.Input['GeneratedKeyKeyShapeArgs'],
+             associated_data: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             logging_context: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("crypto_endpoint", crypto_endpoint)
+        _setter("include_plaintext_key", include_plaintext_key)
+        _setter("key_id", key_id)
+        _setter("key_shape", key_shape)
         if associated_data is not None:
-            pulumi.set(__self__, "associated_data", associated_data)
+            _setter("associated_data", associated_data)
         if logging_context is not None:
-            pulumi.set(__self__, "logging_context", logging_context)
+            _setter("logging_context", logging_context)
 
     @property
     @pulumi.getter(name="cryptoEndpoint")
@@ -149,24 +168,49 @@ class _GeneratedKeyState:
         :param pulumi.Input[str] plaintext: The plaintext data encryption key, a base64-encoded sequence of random bytes, which is included if the [GenerateDataEncryptionKey](https://docs.cloud.oracle.com/iaas/api/#/en/key/latest/GeneratedKey/GenerateDataEncryptionKey) request includes the `includePlaintextKey` parameter and sets its value to "true".
         :param pulumi.Input[str] plaintext_checksum: The checksum of the plaintext data encryption key, which is included if the [GenerateDataEncryptionKey](https://docs.cloud.oracle.com/iaas/api/#/en/key/latest/GeneratedKey/GenerateDataEncryptionKey) request includes the `includePlaintextKey` parameter and sets its value to "true".
         """
+        _GeneratedKeyState._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            associated_data=associated_data,
+            ciphertext=ciphertext,
+            crypto_endpoint=crypto_endpoint,
+            include_plaintext_key=include_plaintext_key,
+            key_id=key_id,
+            key_shape=key_shape,
+            logging_context=logging_context,
+            plaintext=plaintext,
+            plaintext_checksum=plaintext_checksum,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             associated_data: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             ciphertext: Optional[pulumi.Input[str]] = None,
+             crypto_endpoint: Optional[pulumi.Input[str]] = None,
+             include_plaintext_key: Optional[pulumi.Input[bool]] = None,
+             key_id: Optional[pulumi.Input[str]] = None,
+             key_shape: Optional[pulumi.Input['GeneratedKeyKeyShapeArgs']] = None,
+             logging_context: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             plaintext: Optional[pulumi.Input[str]] = None,
+             plaintext_checksum: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if associated_data is not None:
-            pulumi.set(__self__, "associated_data", associated_data)
+            _setter("associated_data", associated_data)
         if ciphertext is not None:
-            pulumi.set(__self__, "ciphertext", ciphertext)
+            _setter("ciphertext", ciphertext)
         if crypto_endpoint is not None:
-            pulumi.set(__self__, "crypto_endpoint", crypto_endpoint)
+            _setter("crypto_endpoint", crypto_endpoint)
         if include_plaintext_key is not None:
-            pulumi.set(__self__, "include_plaintext_key", include_plaintext_key)
+            _setter("include_plaintext_key", include_plaintext_key)
         if key_id is not None:
-            pulumi.set(__self__, "key_id", key_id)
+            _setter("key_id", key_id)
         if key_shape is not None:
-            pulumi.set(__self__, "key_shape", key_shape)
+            _setter("key_shape", key_shape)
         if logging_context is not None:
-            pulumi.set(__self__, "logging_context", logging_context)
+            _setter("logging_context", logging_context)
         if plaintext is not None:
-            pulumi.set(__self__, "plaintext", plaintext)
+            _setter("plaintext", plaintext)
         if plaintext_checksum is not None:
-            pulumi.set(__self__, "plaintext_checksum", plaintext_checksum)
+            _setter("plaintext_checksum", plaintext_checksum)
 
     @property
     @pulumi.getter(name="associatedData")
@@ -378,6 +422,10 @@ class GeneratedKey(pulumi.CustomResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
+            kwargs = kwargs or {}
+            def _setter(key, value):
+                kwargs[key] = value
+            GeneratedKeyArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,
@@ -408,6 +456,11 @@ class GeneratedKey(pulumi.CustomResource):
             if key_id is None and not opts.urn:
                 raise TypeError("Missing required property 'key_id'")
             __props__.__dict__["key_id"] = key_id
+            if key_shape is not None and not isinstance(key_shape, GeneratedKeyKeyShapeArgs):
+                key_shape = key_shape or {}
+                def _setter(key, value):
+                    key_shape[key] = value
+                GeneratedKeyKeyShapeArgs._configure(_setter, **key_shape)
             if key_shape is None and not opts.urn:
                 raise TypeError("Missing required property 'key_shape'")
             __props__.__dict__["key_shape"] = key_shape

pulumi_oci/kms/get_decrypted_data.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
 
 __all__ = [

pulumi_oci/kms/get_ekms_private_endpoint.py

@@ -0,0 +1,274 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from .. import _utilities
+
+__all__ = [
+    'GetEkmsPrivateEndpointResult',
+    'AwaitableGetEkmsPrivateEndpointResult',
+    'get_ekms_private_endpoint',
+    'get_ekms_private_endpoint_output',
+]
+
+@pulumi.output_type
+class GetEkmsPrivateEndpointResult:
+    """
+    A collection of values returned by getEkmsPrivateEndpoint.
+    """
+    def __init__(__self__, ca_bundle=None, compartment_id=None, defined_tags=None, display_name=None, ekms_private_endpoint_id=None, external_key_manager_ip=None, freeform_tags=None, id=None, lifecycle_details=None, port=None, private_endpoint_ip=None, state=None, subnet_id=None, time_created=None, time_updated=None):
+        if ca_bundle and not isinstance(ca_bundle, str):
+            raise TypeError("Expected argument 'ca_bundle' to be a str")
+        pulumi.set(__self__, "ca_bundle", ca_bundle)
+        if compartment_id and not isinstance(compartment_id, str):
+            raise TypeError("Expected argument 'compartment_id' to be a str")
+        pulumi.set(__self__, "compartment_id", compartment_id)
+        if defined_tags and not isinstance(defined_tags, dict):
+            raise TypeError("Expected argument 'defined_tags' to be a dict")
+        pulumi.set(__self__, "defined_tags", defined_tags)
+        if display_name and not isinstance(display_name, str):
+            raise TypeError("Expected argument 'display_name' to be a str")
+        pulumi.set(__self__, "display_name", display_name)
+        if ekms_private_endpoint_id and not isinstance(ekms_private_endpoint_id, str):
+            raise TypeError("Expected argument 'ekms_private_endpoint_id' to be a str")
+        pulumi.set(__self__, "ekms_private_endpoint_id", ekms_private_endpoint_id)
+        if external_key_manager_ip and not isinstance(external_key_manager_ip, str):
+            raise TypeError("Expected argument 'external_key_manager_ip' to be a str")
+        pulumi.set(__self__, "external_key_manager_ip", external_key_manager_ip)
+        if freeform_tags and not isinstance(freeform_tags, dict):
+            raise TypeError("Expected argument 'freeform_tags' to be a dict")
+        pulumi.set(__self__, "freeform_tags", freeform_tags)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if lifecycle_details and not isinstance(lifecycle_details, str):
+            raise TypeError("Expected argument 'lifecycle_details' to be a str")
+        pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        if port and not isinstance(port, int):
+            raise TypeError("Expected argument 'port' to be a int")
+        pulumi.set(__self__, "port", port)
+        if private_endpoint_ip and not isinstance(private_endpoint_ip, str):
+            raise TypeError("Expected argument 'private_endpoint_ip' to be a str")
+        pulumi.set(__self__, "private_endpoint_ip", private_endpoint_ip)
+        if state and not isinstance(state, str):
+            raise TypeError("Expected argument 'state' to be a str")
+        pulumi.set(__self__, "state", state)
+        if subnet_id and not isinstance(subnet_id, str):
+            raise TypeError("Expected argument 'subnet_id' to be a str")
+        pulumi.set(__self__, "subnet_id", subnet_id)
+        if time_created and not isinstance(time_created, str):
+            raise TypeError("Expected argument 'time_created' to be a str")
+        pulumi.set(__self__, "time_created", time_created)
+        if time_updated and not isinstance(time_updated, str):
+            raise TypeError("Expected argument 'time_updated' to be a str")
+        pulumi.set(__self__, "time_updated", time_updated)
+
+    @property
+    @pulumi.getter(name="caBundle")
+    def ca_bundle(self) -> str:
+        """
+        CABundle to validate TLS certificate of the external key manager system in PEM format
+        """
+        return pulumi.get(self, "ca_bundle")
+
+    @property
+    @pulumi.getter(name="compartmentId")
+    def compartment_id(self) -> str:
+        """
+        Identifier of the compartment this EKMS private endpoint belongs to
+        """
+        return pulumi.get(self, "compartment_id")
+
+    @property
+    @pulumi.getter(name="definedTags")
+    def defined_tags(self) -> Mapping[str, Any]:
+        """
+        Usage of predefined tag keys. These predefined keys are scoped to namespaces. Example: `{"foo-namespace.bar-key": "value"}`
+        """
+        return pulumi.get(self, "defined_tags")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> str:
+        """
+        Mutable name of the EKMS private endpoint
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter(name="ekmsPrivateEndpointId")
+    def ekms_private_endpoint_id(self) -> str:
+        return pulumi.get(self, "ekms_private_endpoint_id")
+
+    @property
+    @pulumi.getter(name="externalKeyManagerIp")
+    def external_key_manager_ip(self) -> str:
+        """
+        Private IP of the external key manager system to connect to from the EKMS private endpoint
+        """
+        return pulumi.get(self, "external_key_manager_ip")
+
+    @property
+    @pulumi.getter(name="freeformTags")
+    def freeform_tags(self) -> Mapping[str, Any]:
+        """
+        Simple key-value pair that is applied without any predefined name, type, or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        """
+        return pulumi.get(self, "freeform_tags")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        Unique identifier that is immutable
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="lifecycleDetails")
+    def lifecycle_details(self) -> str:
+        """
+        A message describing the current state in more detail. For example, can be used to provide actionable information for a resource in 'Failed' state.
+        """
+        return pulumi.get(self, "lifecycle_details")
+
+    @property
+    @pulumi.getter
+    def port(self) -> int:
+        """
+        The port of the external key manager system
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter(name="privateEndpointIp")
+    def private_endpoint_ip(self) -> str:
+        """
+        The IP address in the customer's VCN for the EKMS private endpoint. This is taken from subnet
+        """
+        return pulumi.get(self, "private_endpoint_ip")
+
+    @property
+    @pulumi.getter
+    def state(self) -> str:
+        """
+        The current state of the EKMS private endpoint resource.
+        """
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> str:
+        """
+        Subnet Identifier
+        """
+        return pulumi.get(self, "subnet_id")
+
+    @property
+    @pulumi.getter(name="timeCreated")
+    def time_created(self) -> str:
+        """
+        The time the EKMS private endpoint was created. An [RFC3339](https://tools.ietf.org/html/rfc3339) formatted datetime string.
+        """
+        return pulumi.get(self, "time_created")
+
+    @property
+    @pulumi.getter(name="timeUpdated")
+    def time_updated(self) -> str:
+        """
+        The time the EKMS private endpoint was updated. An [RFC3339](https://tools.ietf.org/html/rfc3339) formatted datetime string.
+        """
+        return pulumi.get(self, "time_updated")
+
+
+class AwaitableGetEkmsPrivateEndpointResult(GetEkmsPrivateEndpointResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetEkmsPrivateEndpointResult(
+            ca_bundle=self.ca_bundle,
+            compartment_id=self.compartment_id,
+            defined_tags=self.defined_tags,
+            display_name=self.display_name,
+            ekms_private_endpoint_id=self.ekms_private_endpoint_id,
+            external_key_manager_ip=self.external_key_manager_ip,
+            freeform_tags=self.freeform_tags,
+            id=self.id,
+            lifecycle_details=self.lifecycle_details,
+            port=self.port,
+            private_endpoint_ip=self.private_endpoint_ip,
+            state=self.state,
+            subnet_id=self.subnet_id,
+            time_created=self.time_created,
+            time_updated=self.time_updated)
+
+
+def get_ekms_private_endpoint(ekms_private_endpoint_id: Optional[str] = None,
+                              opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetEkmsPrivateEndpointResult:
+    """
+    This data source provides details about a specific Ekms Private Endpoint resource in Oracle Cloud Infrastructure Kms service.
+
+    Gets a specific EKMS private by identifier.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_ekms_private_endpoint = oci.Kms.get_ekms_private_endpoint(ekms_private_endpoint_id=oci_kms_ekms_private_endpoint["test_ekms_private_endpoint"]["id"])
+    ```
+
+
+    :param str ekms_private_endpoint_id: Unique EKMS private endpoint identifier.
+    """
+    __args__ = dict()
+    __args__['ekmsPrivateEndpointId'] = ekms_private_endpoint_id
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('oci:Kms/getEkmsPrivateEndpoint:getEkmsPrivateEndpoint', __args__, opts=opts, typ=GetEkmsPrivateEndpointResult).value
+
+    return AwaitableGetEkmsPrivateEndpointResult(
+        ca_bundle=pulumi.get(__ret__, 'ca_bundle'),
+        compartment_id=pulumi.get(__ret__, 'compartment_id'),
+        defined_tags=pulumi.get(__ret__, 'defined_tags'),
+        display_name=pulumi.get(__ret__, 'display_name'),
+        ekms_private_endpoint_id=pulumi.get(__ret__, 'ekms_private_endpoint_id'),
+        external_key_manager_ip=pulumi.get(__ret__, 'external_key_manager_ip'),
+        freeform_tags=pulumi.get(__ret__, 'freeform_tags'),
+        id=pulumi.get(__ret__, 'id'),
+        lifecycle_details=pulumi.get(__ret__, 'lifecycle_details'),
+        port=pulumi.get(__ret__, 'port'),
+        private_endpoint_ip=pulumi.get(__ret__, 'private_endpoint_ip'),
+        state=pulumi.get(__ret__, 'state'),
+        subnet_id=pulumi.get(__ret__, 'subnet_id'),
+        time_created=pulumi.get(__ret__, 'time_created'),
+        time_updated=pulumi.get(__ret__, 'time_updated'))
+
+
+@_utilities.lift_output_func(get_ekms_private_endpoint)
+def get_ekms_private_endpoint_output(ekms_private_endpoint_id: Optional[pulumi.Input[str]] = None,
+                                     opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetEkmsPrivateEndpointResult]:
+    """
+    This data source provides details about a specific Ekms Private Endpoint resource in Oracle Cloud Infrastructure Kms service.
+
+    Gets a specific EKMS private by identifier.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_ekms_private_endpoint = oci.Kms.get_ekms_private_endpoint(ekms_private_endpoint_id=oci_kms_ekms_private_endpoint["test_ekms_private_endpoint"]["id"])
+    ```
+
+
+    :param str ekms_private_endpoint_id: Unique EKMS private endpoint identifier.
+    """
+    ...