pulumi-vault 7.1.0__py3-none-any.whl → 7.2.0__py3-none-any.whl

pulumi_vault/managed/outputs.py

@@ -2,8 +2,7 @@
 # *** WARNING: this file was generated by pulumi-language-python. ***
 # *** Do not edit by hand unless you're certain you know what you are doing! ***
 
-import builtins
-import copy
+import builtins as _builtins
 import warnings
 import sys
 import pulumi
@@ -57,35 +56,35 @@ class KeysAw(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 access_key: builtins.str,
-                 key_bits: builtins.str,
-                 key_type: builtins.str,
-                 kms_key: builtins.str,
-                 name: builtins.str,
-                 secret_key: builtins.str,
-                 allow_generate_key: Optional[builtins.bool] = None,
-                 allow_replace_key: Optional[builtins.bool] = None,
-                 allow_store_key: Optional[builtins.bool] = None,
-                 any_mount: Optional[builtins.bool] = None,
-                 curve: Optional[builtins.str] = None,
-                 endpoint: Optional[builtins.str] = None,
-                 region: Optional[builtins.str] = None,
-                 uuid: Optional[builtins.str] = None):
-        """
-        :param builtins.str access_key: The AWS access key to use
-        :param builtins.str key_bits: The size in bits for an RSA key. This field is required when 'key_type' is 'RSA'
-        :param builtins.str key_type: The type of key to use
-        :param builtins.str kms_key: An identifier for the key
-        :param builtins.str name: A unique lowercase name that serves as identifying the key
-        :param builtins.str secret_key: The AWS secret key to use
-        :param builtins.bool allow_generate_key: If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
-        :param builtins.bool allow_replace_key: Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
-        :param builtins.bool allow_store_key: Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
-        :param builtins.bool any_mount: Allow usage from any mount point within the namespace if 'true'
-        :param builtins.str curve: The curve to use for an ECDSA key. Used when key_type is 'ECDSA'. Required if 'allow_generate_key' is true
-        :param builtins.str endpoint: Used to specify a custom AWS endpoint
-        :param builtins.str region: The AWS region where the keys are stored (or will be stored)
-        :param builtins.str uuid: ID of the managed key read from Vault
+                 access_key: _builtins.str,
+                 key_bits: _builtins.str,
+                 key_type: _builtins.str,
+                 kms_key: _builtins.str,
+                 name: _builtins.str,
+                 secret_key: _builtins.str,
+                 allow_generate_key: Optional[_builtins.bool] = None,
+                 allow_replace_key: Optional[_builtins.bool] = None,
+                 allow_store_key: Optional[_builtins.bool] = None,
+                 any_mount: Optional[_builtins.bool] = None,
+                 curve: Optional[_builtins.str] = None,
+                 endpoint: Optional[_builtins.str] = None,
+                 region: Optional[_builtins.str] = None,
+                 uuid: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str access_key: The AWS access key to use
+        :param _builtins.str key_bits: The size in bits for an RSA key. This field is required when 'key_type' is 'RSA'
+        :param _builtins.str key_type: The type of key to use
+        :param _builtins.str kms_key: An identifier for the key
+        :param _builtins.str name: A unique lowercase name that serves as identifying the key
+        :param _builtins.str secret_key: The AWS secret key to use
+        :param _builtins.bool allow_generate_key: If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
+        :param _builtins.bool allow_replace_key: Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
+        :param _builtins.bool allow_store_key: Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
+        :param _builtins.bool any_mount: Allow usage from any mount point within the namespace if 'true'
+        :param _builtins.str curve: The curve to use for an ECDSA key. Used when key_type is 'ECDSA'. Required if 'allow_generate_key' is true
+        :param _builtins.str endpoint: Used to specify a custom AWS endpoint
+        :param _builtins.str region: The AWS region where the keys are stored (or will be stored)
+        :param _builtins.str uuid: ID of the managed key read from Vault
         """
         pulumi.set(__self__, "access_key", access_key)
         pulumi.set(__self__, "key_bits", key_bits)
@@ -110,113 +109,113 @@ class KeysAw(dict):
         if uuid is not None:
             pulumi.set(__self__, "uuid", uuid)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessKey")
-    def access_key(self) -> builtins.str:
+    def access_key(self) -> _builtins.str:
         """
         The AWS access key to use
         """
         return pulumi.get(self, "access_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyBits")
-    def key_bits(self) -> builtins.str:
+    def key_bits(self) -> _builtins.str:
         """
         The size in bits for an RSA key. This field is required when 'key_type' is 'RSA'
         """
         return pulumi.get(self, "key_bits")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyType")
-    def key_type(self) -> builtins.str:
+    def key_type(self) -> _builtins.str:
         """
         The type of key to use
         """
         return pulumi.get(self, "key_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="kmsKey")
-    def kms_key(self) -> builtins.str:
+    def kms_key(self) -> _builtins.str:
         """
         An identifier for the key
         """
         return pulumi.get(self, "kms_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         A unique lowercase name that serves as identifying the key
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="secretKey")
-    def secret_key(self) -> builtins.str:
+    def secret_key(self) -> _builtins.str:
         """
         The AWS secret key to use
         """
         return pulumi.get(self, "secret_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowGenerateKey")
-    def allow_generate_key(self) -> Optional[builtins.bool]:
+    def allow_generate_key(self) -> Optional[_builtins.bool]:
         """
         If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
         """
         return pulumi.get(self, "allow_generate_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowReplaceKey")
-    def allow_replace_key(self) -> Optional[builtins.bool]:
+    def allow_replace_key(self) -> Optional[_builtins.bool]:
         """
         Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
         """
         return pulumi.get(self, "allow_replace_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowStoreKey")
-    def allow_store_key(self) -> Optional[builtins.bool]:
+    def allow_store_key(self) -> Optional[_builtins.bool]:
         """
         Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
         """
         return pulumi.get(self, "allow_store_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="anyMount")
-    def any_mount(self) -> Optional[builtins.bool]:
+    def any_mount(self) -> Optional[_builtins.bool]:
         """
         Allow usage from any mount point within the namespace if 'true'
         """
         return pulumi.get(self, "any_mount")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def curve(self) -> Optional[builtins.str]:
+    def curve(self) -> Optional[_builtins.str]:
         """
         The curve to use for an ECDSA key. Used when key_type is 'ECDSA'. Required if 'allow_generate_key' is true
         """
         return pulumi.get(self, "curve")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def endpoint(self) -> Optional[builtins.str]:
+    def endpoint(self) -> Optional[_builtins.str]:
         """
         Used to specify a custom AWS endpoint
         """
         return pulumi.get(self, "endpoint")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def region(self) -> Optional[builtins.str]:
+    def region(self) -> Optional[_builtins.str]:
         """
         The AWS region where the keys are stored (or will be stored)
         """
         return pulumi.get(self, "region")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uuid(self) -> Optional[builtins.str]:
+    def uuid(self) -> Optional[_builtins.str]:
         """
         ID of the managed key read from Vault
         """
@@ -263,37 +262,37 @@ class KeysAzure(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 client_id: builtins.str,
-                 client_secret: builtins.str,
-                 key_name: builtins.str,
-                 key_type: builtins.str,
-                 name: builtins.str,
-                 tenant_id: builtins.str,
-                 vault_name: builtins.str,
-                 allow_generate_key: Optional[builtins.bool] = None,
-                 allow_replace_key: Optional[builtins.bool] = None,
-                 allow_store_key: Optional[builtins.bool] = None,
-                 any_mount: Optional[builtins.bool] = None,
-                 environment: Optional[builtins.str] = None,
-                 key_bits: Optional[builtins.str] = None,
-                 resource: Optional[builtins.str] = None,
-                 uuid: Optional[builtins.str] = None):
-        """
-        :param builtins.str client_id: The client id for credentials to query the Azure APIs
-        :param builtins.str client_secret: The client secret for credentials to query the Azure APIs
-        :param builtins.str key_name: The Key Vault key to use for encryption and decryption
-        :param builtins.str key_type: The type of key to use
-        :param builtins.str name: A unique lowercase name that serves as identifying the key
-        :param builtins.str tenant_id: The tenant id for the Azure Active Directory organization
-        :param builtins.str vault_name: The Key Vault vault to use the encryption keys for encryption and decryption
-        :param builtins.bool allow_generate_key: If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
-        :param builtins.bool allow_replace_key: Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
-        :param builtins.bool allow_store_key: Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
-        :param builtins.bool any_mount: Allow usage from any mount point within the namespace if 'true'
-        :param builtins.str environment: The Azure Cloud environment API endpoints to use
-        :param builtins.str key_bits: The size in bits for an RSA key. This field is required when 'key_type' is 'RSA' or when 'allow_generate_key' is true
-        :param builtins.str resource: The Azure Key Vault resource's DNS Suffix to connect to
-        :param builtins.str uuid: ID of the managed key read from Vault
+                 client_id: _builtins.str,
+                 client_secret: _builtins.str,
+                 key_name: _builtins.str,
+                 key_type: _builtins.str,
+                 name: _builtins.str,
+                 tenant_id: _builtins.str,
+                 vault_name: _builtins.str,
+                 allow_generate_key: Optional[_builtins.bool] = None,
+                 allow_replace_key: Optional[_builtins.bool] = None,
+                 allow_store_key: Optional[_builtins.bool] = None,
+                 any_mount: Optional[_builtins.bool] = None,
+                 environment: Optional[_builtins.str] = None,
+                 key_bits: Optional[_builtins.str] = None,
+                 resource: Optional[_builtins.str] = None,
+                 uuid: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str client_id: The client id for credentials to query the Azure APIs
+        :param _builtins.str client_secret: The client secret for credentials to query the Azure APIs
+        :param _builtins.str key_name: The Key Vault key to use for encryption and decryption
+        :param _builtins.str key_type: The type of key to use
+        :param _builtins.str name: A unique lowercase name that serves as identifying the key
+        :param _builtins.str tenant_id: The tenant id for the Azure Active Directory organization
+        :param _builtins.str vault_name: The Key Vault vault to use the encryption keys for encryption and decryption
+        :param _builtins.bool allow_generate_key: If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
+        :param _builtins.bool allow_replace_key: Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
+        :param _builtins.bool allow_store_key: Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
+        :param _builtins.bool any_mount: Allow usage from any mount point within the namespace if 'true'
+        :param _builtins.str environment: The Azure Cloud environment API endpoints to use
+        :param _builtins.str key_bits: The size in bits for an RSA key. This field is required when 'key_type' is 'RSA' or when 'allow_generate_key' is true
+        :param _builtins.str resource: The Azure Key Vault resource's DNS Suffix to connect to
+        :param _builtins.str uuid: ID of the managed key read from Vault
         """
         pulumi.set(__self__, "client_id", client_id)
         pulumi.set(__self__, "client_secret", client_secret)
@@ -319,121 +318,121 @@ class KeysAzure(dict):
         if uuid is not None:
             pulumi.set(__self__, "uuid", uuid)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="clientId")
-    def client_id(self) -> builtins.str:
+    def client_id(self) -> _builtins.str:
         """
         The client id for credentials to query the Azure APIs
         """
         return pulumi.get(self, "client_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="clientSecret")
-    def client_secret(self) -> builtins.str:
+    def client_secret(self) -> _builtins.str:
         """
         The client secret for credentials to query the Azure APIs
         """
         return pulumi.get(self, "client_secret")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyName")
-    def key_name(self) -> builtins.str:
+    def key_name(self) -> _builtins.str:
         """
         The Key Vault key to use for encryption and decryption
         """
         return pulumi.get(self, "key_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyType")
-    def key_type(self) -> builtins.str:
+    def key_type(self) -> _builtins.str:
         """
         The type of key to use
         """
         return pulumi.get(self, "key_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         A unique lowercase name that serves as identifying the key
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="tenantId")
-    def tenant_id(self) -> builtins.str:
+    def tenant_id(self) -> _builtins.str:
         """
         The tenant id for the Azure Active Directory organization
         """
         return pulumi.get(self, "tenant_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="vaultName")
-    def vault_name(self) -> builtins.str:
+    def vault_name(self) -> _builtins.str:
         """
         The Key Vault vault to use the encryption keys for encryption and decryption
         """
         return pulumi.get(self, "vault_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowGenerateKey")
-    def allow_generate_key(self) -> Optional[builtins.bool]:
+    def allow_generate_key(self) -> Optional[_builtins.bool]:
         """
         If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
         """
         return pulumi.get(self, "allow_generate_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowReplaceKey")
-    def allow_replace_key(self) -> Optional[builtins.bool]:
+    def allow_replace_key(self) -> Optional[_builtins.bool]:
         """
         Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
         """
         return pulumi.get(self, "allow_replace_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowStoreKey")
-    def allow_store_key(self) -> Optional[builtins.bool]:
+    def allow_store_key(self) -> Optional[_builtins.bool]:
         """
         Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
         """
         return pulumi.get(self, "allow_store_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="anyMount")
-    def any_mount(self) -> Optional[builtins.bool]:
+    def any_mount(self) -> Optional[_builtins.bool]:
         """
         Allow usage from any mount point within the namespace if 'true'
         """
         return pulumi.get(self, "any_mount")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def environment(self) -> Optional[builtins.str]:
+    def environment(self) -> Optional[_builtins.str]:
         """
         The Azure Cloud environment API endpoints to use
         """
         return pulumi.get(self, "environment")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyBits")
-    def key_bits(self) -> Optional[builtins.str]:
+    def key_bits(self) -> Optional[_builtins.str]:
         """
         The size in bits for an RSA key. This field is required when 'key_type' is 'RSA' or when 'allow_generate_key' is true
         """
         return pulumi.get(self, "key_bits")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def resource(self) -> Optional[builtins.str]:
+    def resource(self) -> Optional[_builtins.str]:
         """
         The Azure Key Vault resource's DNS Suffix to connect to
         """
         return pulumi.get(self, "resource")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uuid(self) -> Optional[builtins.str]:
+    def uuid(self) -> Optional[_builtins.str]:
         """
         ID of the managed key read from Vault
         """
@@ -476,39 +475,39 @@ class KeysPkc(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 key_id: builtins.str,
-                 key_label: builtins.str,
-                 library: builtins.str,
-                 mechanism: builtins.str,
-                 name: builtins.str,
-                 pin: builtins.str,
-                 allow_generate_key: Optional[builtins.bool] = None,
-                 allow_replace_key: Optional[builtins.bool] = None,
-                 allow_store_key: Optional[builtins.bool] = None,
-                 any_mount: Optional[builtins.bool] = None,
-                 curve: Optional[builtins.str] = None,
-                 force_rw_session: Optional[builtins.str] = None,
-                 key_bits: Optional[builtins.str] = None,
-                 slot: Optional[builtins.str] = None,
-                 token_label: Optional[builtins.str] = None,
-                 uuid: Optional[builtins.str] = None):
-        """
-        :param builtins.str key_id: The id of a PKCS#11 key to use
-        :param builtins.str key_label: The label of the key to use
-        :param builtins.str library: The name of the kms_library stanza to use from Vault's config to lookup the local library path
-        :param builtins.str mechanism: The encryption/decryption mechanism to use, specified as a hexadecimal (prefixed by 0x) string.
-        :param builtins.str name: A unique lowercase name that serves as identifying the key
-        :param builtins.str pin: The PIN for login
-        :param builtins.bool allow_generate_key: If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
-        :param builtins.bool allow_replace_key: Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
-        :param builtins.bool allow_store_key: Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
-        :param builtins.bool any_mount: Allow usage from any mount point within the namespace if 'true'
-        :param builtins.str curve: Supplies the curve value when using the 'CKM_ECDSA' mechanism. Required if 'allow_generate_key' is true
-        :param builtins.str force_rw_session: Force all operations to open up a read-write session to the HSM
-        :param builtins.str key_bits: Supplies the size in bits of the key when using 'CKM_RSA_PKCS_PSS', 'CKM_RSA_PKCS_OAEP' or 'CKM_RSA_PKCS' as a value for 'mechanism'. Required if 'allow_generate_key' is true
-        :param builtins.str slot: The slot number to use, specified as a string in a decimal format (e.g. '2305843009213693953')
-        :param builtins.str token_label: The slot token label to use
-        :param builtins.str uuid: ID of the managed key read from Vault
+                 key_id: _builtins.str,
+                 key_label: _builtins.str,
+                 library: _builtins.str,
+                 mechanism: _builtins.str,
+                 name: _builtins.str,
+                 pin: _builtins.str,
+                 allow_generate_key: Optional[_builtins.bool] = None,
+                 allow_replace_key: Optional[_builtins.bool] = None,
+                 allow_store_key: Optional[_builtins.bool] = None,
+                 any_mount: Optional[_builtins.bool] = None,
+                 curve: Optional[_builtins.str] = None,
+                 force_rw_session: Optional[_builtins.str] = None,
+                 key_bits: Optional[_builtins.str] = None,
+                 slot: Optional[_builtins.str] = None,
+                 token_label: Optional[_builtins.str] = None,
+                 uuid: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str key_id: The id of a PKCS#11 key to use
+        :param _builtins.str key_label: The label of the key to use
+        :param _builtins.str library: The name of the kms_library stanza to use from Vault's config to lookup the local library path
+        :param _builtins.str mechanism: The encryption/decryption mechanism to use, specified as a hexadecimal (prefixed by 0x) string.
+        :param _builtins.str name: A unique lowercase name that serves as identifying the key
+        :param _builtins.str pin: The PIN for login
+        :param _builtins.bool allow_generate_key: If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
+        :param _builtins.bool allow_replace_key: Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
+        :param _builtins.bool allow_store_key: Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
+        :param _builtins.bool any_mount: Allow usage from any mount point within the namespace if 'true'
+        :param _builtins.str curve: Supplies the curve value when using the 'CKM_ECDSA' mechanism. Required if 'allow_generate_key' is true
+        :param _builtins.str force_rw_session: Force all operations to open up a read-write session to the HSM
+        :param _builtins.str key_bits: Supplies the size in bits of the key when using 'CKM_RSA_PKCS_PSS', 'CKM_RSA_PKCS_OAEP' or 'CKM_RSA_PKCS' as a value for 'mechanism'. Required if 'allow_generate_key' is true
+        :param _builtins.str slot: The slot number to use, specified as a string in a decimal format (e.g. '2305843009213693953')
+        :param _builtins.str token_label: The slot token label to use
+        :param _builtins.str uuid: ID of the managed key read from Vault
         """
         pulumi.set(__self__, "key_id", key_id)
         pulumi.set(__self__, "key_label", key_label)
@@ -537,129 +536,129 @@ class KeysPkc(dict):
         if uuid is not None:
             pulumi.set(__self__, "uuid", uuid)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyId")
-    def key_id(self) -> builtins.str:
+    def key_id(self) -> _builtins.str:
         """
         The id of a PKCS#11 key to use
         """
         return pulumi.get(self, "key_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyLabel")
-    def key_label(self) -> builtins.str:
+    def key_label(self) -> _builtins.str:
         """
         The label of the key to use
         """
         return pulumi.get(self, "key_label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def library(self) -> builtins.str:
+    def library(self) -> _builtins.str:
         """
         The name of the kms_library stanza to use from Vault's config to lookup the local library path
         """
         return pulumi.get(self, "library")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def mechanism(self) -> builtins.str:
+    def mechanism(self) -> _builtins.str:
         """
         The encryption/decryption mechanism to use, specified as a hexadecimal (prefixed by 0x) string.
         """
         return pulumi.get(self, "mechanism")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         A unique lowercase name that serves as identifying the key
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def pin(self) -> builtins.str:
+    def pin(self) -> _builtins.str:
         """
         The PIN for login
         """
         return pulumi.get(self, "pin")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowGenerateKey")
-    def allow_generate_key(self) -> Optional[builtins.bool]:
+    def allow_generate_key(self) -> Optional[_builtins.bool]:
         """
         If no existing key can be found in the referenced backend, instructs Vault to generate a key within the backend
         """
         return pulumi.get(self, "allow_generate_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowReplaceKey")
-    def allow_replace_key(self) -> Optional[builtins.bool]:
+    def allow_replace_key(self) -> Optional[_builtins.bool]:
         """
         Controls the ability for Vault to replace through generation or importing a key into the configured backend even if a key is present, if set to false those operations are forbidden if a key exists.
         """
         return pulumi.get(self, "allow_replace_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowStoreKey")
-    def allow_store_key(self) -> Optional[builtins.bool]:
+    def allow_store_key(self) -> Optional[_builtins.bool]:
         """
         Controls the ability for Vault to import a key to the configured backend, if 'false', those operations will be forbidden
         """
         return pulumi.get(self, "allow_store_key")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="anyMount")
-    def any_mount(self) -> Optional[builtins.bool]:
+    def any_mount(self) -> Optional[_builtins.bool]:
         """
         Allow usage from any mount point within the namespace if 'true'
         """
         return pulumi.get(self, "any_mount")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def curve(self) -> Optional[builtins.str]:
+    def curve(self) -> Optional[_builtins.str]:
         """
         Supplies the curve value when using the 'CKM_ECDSA' mechanism. Required if 'allow_generate_key' is true
         """
         return pulumi.get(self, "curve")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="forceRwSession")
-    def force_rw_session(self) -> Optional[builtins.str]:
+    def force_rw_session(self) -> Optional[_builtins.str]:
         """
         Force all operations to open up a read-write session to the HSM
         """
         return pulumi.get(self, "force_rw_session")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyBits")
-    def key_bits(self) -> Optional[builtins.str]:
+    def key_bits(self) -> Optional[_builtins.str]:
         """
         Supplies the size in bits of the key when using 'CKM_RSA_PKCS_PSS', 'CKM_RSA_PKCS_OAEP' or 'CKM_RSA_PKCS' as a value for 'mechanism'. Required if 'allow_generate_key' is true
         """
         return pulumi.get(self, "key_bits")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def slot(self) -> Optional[builtins.str]:
+    def slot(self) -> Optional[_builtins.str]:
         """
         The slot number to use, specified as a string in a decimal format (e.g. '2305843009213693953')
         """
         return pulumi.get(self, "slot")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="tokenLabel")
-    def token_label(self) -> Optional[builtins.str]:
+    def token_label(self) -> Optional[_builtins.str]:
         """
         The slot token label to use
         """
         return pulumi.get(self, "token_label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uuid(self) -> Optional[builtins.str]:
+    def uuid(self) -> Optional[_builtins.str]:
         """
         ID of the managed key read from Vault
         """