pulumi-nomad 2.5.0a1744783739__py3-none-any.whl → 2.5.1a1753398000__py3-none-any.whl

pulumi_nomad/outputs.py

@@ -1,9 +1,8 @@
 # coding=utf-8
-# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** 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
@@ -18,6 +17,8 @@ from . import outputs
 
 __all__ = [
     'AclAuthMethodConfig',
+    'AclAuthMethodConfigOidcClientAssertion',
+    'AclAuthMethodConfigOidcClientAssertionPrivateKey',
     'AclPolicyJobAcl',
     'AclRolePolicy',
     'AclTokenRole',
@@ -35,6 +36,10 @@ __all__ = [
     'CsiVolumeTopologyRequestPreferredTopology',
     'CsiVolumeTopologyRequestRequired',
     'CsiVolumeTopologyRequestRequiredTopology',
+    'DynamicHostVolumeCapability',
+    'DynamicHostVolumeConstraint',
+    'DynamicHostVolumeRegistrationCapability',
+    'DynamicHostVolumeRegistrationConstraint',
     'ExternalVolumeCapability',
     'ExternalVolumeMountOptions',
     'ExternalVolumeTopology',
@@ -67,6 +72,8 @@ __all__ = [
     'GetAclTokensAclTokenResult',
     'GetAclTokensAclTokenRoleResult',
     'GetAllocationsAllocationResult',
+    'GetDynamicHostVolumeCapabilityResult',
+    'GetDynamicHostVolumeConstraintResult',
     'GetJobConstraintResult',
     'GetJobPeriodicConfigResult',
     'GetJobTaskGroupResult',
@@ -112,6 +119,8 @@ class AclAuthMethodConfig(dict):
             suggest = "list_claim_mappings"
         elif key == "notBeforeLeeway":
             suggest = "not_before_leeway"
+        elif key == "oidcClientAssertion":
+            suggest = "oidc_client_assertion"
         elif key == "oidcClientId":
             suggest = "oidc_client_id"
         elif key == "oidcClientSecret":
@@ -120,10 +129,14 @@ class AclAuthMethodConfig(dict):
             suggest = "oidc_disable_userinfo"
         elif key == "oidcDiscoveryUrl":
             suggest = "oidc_discovery_url"
+        elif key == "oidcEnablePkce":
+            suggest = "oidc_enable_pkce"
         elif key == "oidcScopes":
             suggest = "oidc_scopes"
         elif key == "signingAlgs":
             suggest = "signing_algs"
+        elif key == "verboseLogging":
+            suggest = "verbose_logging"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in AclAuthMethodConfig. Access the value via the '{suggest}' property getter instead.")
@@ -137,60 +150,71 @@ class AclAuthMethodConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 allowed_redirect_uris: Optional[Sequence[builtins.str]] = None,
-                 bound_audiences: Optional[Sequence[builtins.str]] = None,
-                 bound_issuers: Optional[Sequence[builtins.str]] = None,
-                 claim_mappings: Optional[Mapping[str, builtins.str]] = None,
-                 clock_skew_leeway: Optional[builtins.str] = None,
-                 discovery_ca_pems: Optional[Sequence[builtins.str]] = None,
-                 expiration_leeway: Optional[builtins.str] = None,
-                 jwks_ca_cert: Optional[builtins.str] = None,
-                 jwks_url: Optional[builtins.str] = None,
-                 jwt_validation_pub_keys: Optional[Sequence[builtins.str]] = None,
-                 list_claim_mappings: Optional[Mapping[str, builtins.str]] = None,
-                 not_before_leeway: Optional[builtins.str] = None,
-                 oidc_client_id: Optional[builtins.str] = None,
-                 oidc_client_secret: Optional[builtins.str] = None,
-                 oidc_disable_userinfo: Optional[builtins.bool] = None,
-                 oidc_discovery_url: Optional[builtins.str] = None,
-                 oidc_scopes: Optional[Sequence[builtins.str]] = None,
-                 signing_algs: Optional[Sequence[builtins.str]] = None):
-        """
-        :param Sequence[builtins.str] allowed_redirect_uris: `([]string: <optional>)` - A list of allowed values
+                 allowed_redirect_uris: Optional[Sequence[_builtins.str]] = None,
+                 bound_audiences: Optional[Sequence[_builtins.str]] = None,
+                 bound_issuers: Optional[Sequence[_builtins.str]] = None,
+                 claim_mappings: Optional[Mapping[str, _builtins.str]] = None,
+                 clock_skew_leeway: Optional[_builtins.str] = None,
+                 discovery_ca_pems: Optional[Sequence[_builtins.str]] = None,
+                 expiration_leeway: Optional[_builtins.str] = None,
+                 jwks_ca_cert: Optional[_builtins.str] = None,
+                 jwks_url: Optional[_builtins.str] = None,
+                 jwt_validation_pub_keys: Optional[Sequence[_builtins.str]] = None,
+                 list_claim_mappings: Optional[Mapping[str, _builtins.str]] = None,
+                 not_before_leeway: Optional[_builtins.str] = None,
+                 oidc_client_assertion: Optional['outputs.AclAuthMethodConfigOidcClientAssertion'] = None,
+                 oidc_client_id: Optional[_builtins.str] = None,
+                 oidc_client_secret: Optional[_builtins.str] = None,
+                 oidc_disable_userinfo: Optional[_builtins.bool] = None,
+                 oidc_discovery_url: Optional[_builtins.str] = None,
+                 oidc_enable_pkce: Optional[_builtins.bool] = None,
+                 oidc_scopes: Optional[Sequence[_builtins.str]] = None,
+                 signing_algs: Optional[Sequence[_builtins.str]] = None,
+                 verbose_logging: Optional[_builtins.bool] = None):
+        """
+        :param Sequence[_builtins.str] allowed_redirect_uris: `([]string: <optional>)` - A list of allowed values
                that can be used for the redirect URI.
-        :param Sequence[builtins.str] bound_audiences: `([]string: <optional>)` - List of auth claims that are
+        :param Sequence[_builtins.str] bound_audiences: `([]string: <optional>)` - List of auth claims that are
                valid for login.
-        :param Sequence[builtins.str] bound_issuers: `([]string: <optional>)` - The value against which to match
+        :param Sequence[_builtins.str] bound_issuers: `([]string: <optional>)` - The value against which to match
                the iss claim in a JWT.
-        :param Mapping[str, builtins.str] claim_mappings: Mappings of claims (key) that will be copied to a metadata field (value).
-        :param builtins.str clock_skew_leeway: `(string: <optional>)` - Duration of leeway when validating
+        :param Mapping[str, _builtins.str] claim_mappings: Mappings of claims (key) that will be copied to a metadata field (value).
+        :param _builtins.str clock_skew_leeway: `(string: <optional>)` - Duration of leeway when validating
                all claims in the form of a time duration such as "5m" or "1h".
-        :param Sequence[builtins.str] discovery_ca_pems: `([]string: <optional>)` - PEM encoded CA certs for use
+        :param Sequence[_builtins.str] discovery_ca_pems: `([]string: <optional>)` - PEM encoded CA certs for use
                by the TLS client used to talk with the OIDC Discovery URL.
-        :param builtins.str expiration_leeway: `(string: <optional>)` - Duration of leeway when validating
+        :param _builtins.str expiration_leeway: `(string: <optional>)` - Duration of leeway when validating
                expiration of a JWT in the form of a time duration such as "5m" or "1h".
-        :param builtins.str jwks_ca_cert: `(string: <optional>)` - PEM encoded CA cert for use by the 
+        :param _builtins.str jwks_ca_cert: `(string: <optional>)` - PEM encoded CA cert for use by the 
                TLS client used to talk with the JWKS server.
-        :param builtins.str jwks_url: `(string: <optional>)` - JSON Web Key Sets url for authenticating
+        :param _builtins.str jwks_url: `(string: <optional>)` - JSON Web Key Sets url for authenticating
                signatures.
-        :param Sequence[builtins.str] jwt_validation_pub_keys: `([]string: <optional>)` - List of PEM-encoded 
+        :param Sequence[_builtins.str] jwt_validation_pub_keys: `([]string: <optional>)` - List of PEM-encoded 
                public keys to use to authenticate signatures locally.
-        :param Mapping[str, builtins.str] list_claim_mappings: Mappings of list claims (key) that will be copied to a metadata field (value).
-        :param builtins.str not_before_leeway: `(string: <optional>)` - Duration of leeway when validating
+        :param Mapping[str, _builtins.str] list_claim_mappings: Mappings of list claims (key) that will be copied to a metadata field (value).
+        :param _builtins.str not_before_leeway: `(string: <optional>)` - Duration of leeway when validating
                not before values of a token in the form of a time duration such as "5m" or "1h".
-        :param builtins.str oidc_client_id: `(string: <optional>)` - The OAuth Client ID configured
+        :param 'AclAuthMethodConfigOidcClientAssertionArgs' oidc_client_assertion: `(OIDCClientAssertion: <optional>)` - Optionally
+               send a signed JWT ("[private key jwt][]") as a client assertion to the OIDC
+               provider. Browse to the [OIDC concepts][concepts-assertions] page to learn
+               more.
+        :param _builtins.str oidc_client_id: `(string: <optional>)` - The OAuth Client ID configured
                with the OIDC provider.
-        :param builtins.str oidc_client_secret: `(string: <optional>)` - The OAuth Client Secret
+        :param _builtins.str oidc_client_secret: `(string: <optional>)` - The OAuth Client Secret
                configured with the OIDC provider.
-        :param builtins.bool oidc_disable_userinfo: `(bool: false)` - When set to `true`, Nomad will
+        :param _builtins.bool oidc_disable_userinfo: `(bool: false)` - When set to `true`, Nomad will
                not make a request to the identity provider to get OIDC `UserInfo`.
                You may wish to set this if your identity provider doesn't send any
                additional claims from the `UserInfo` endpoint.
-        :param builtins.str oidc_discovery_url: `(string: <optional>)` - The OIDC Discovery URL,
+        :param _builtins.str oidc_discovery_url: `(string: <optional>)` - The OIDC Discovery URL,
                without any .well-known component (base path).
-        :param Sequence[builtins.str] oidc_scopes: `([]string: <optional>)` - List of OIDC scopes.
-        :param Sequence[builtins.str] signing_algs: `([]string: <optional>)` - A list of supported signing
+        :param _builtins.bool oidc_enable_pkce: `(bool: false)` - When set to `true`, Nomad will include
+               [PKCE][] verification in the auth flow. Even with PKCE enabled in Nomad,
+               you may still need to enable it in your OIDC provider.
+        :param Sequence[_builtins.str] oidc_scopes: `([]string: <optional>)` - List of OIDC scopes.
+        :param Sequence[_builtins.str] signing_algs: `([]string: <optional>)` - A list of supported signing
                algorithms.
+        :param _builtins.bool verbose_logging: Enable OIDC verbose logging on the Nomad server.
         """
         if allowed_redirect_uris is not None:
             pulumi.set(__self__, "allowed_redirect_uris", allowed_redirect_uris)
@@ -216,6 +240,8 @@ class AclAuthMethodConfig(dict):
             pulumi.set(__self__, "list_claim_mappings", list_claim_mappings)
         if not_before_leeway is not None:
             pulumi.set(__self__, "not_before_leeway", not_before_leeway)
+        if oidc_client_assertion is not None:
+            pulumi.set(__self__, "oidc_client_assertion", oidc_client_assertion)
         if oidc_client_id is not None:
             pulumi.set(__self__, "oidc_client_id", oidc_client_id)
         if oidc_client_secret is not None:
@@ -224,138 +250,153 @@ class AclAuthMethodConfig(dict):
             pulumi.set(__self__, "oidc_disable_userinfo", oidc_disable_userinfo)
         if oidc_discovery_url is not None:
             pulumi.set(__self__, "oidc_discovery_url", oidc_discovery_url)
+        if oidc_enable_pkce is not None:
+            pulumi.set(__self__, "oidc_enable_pkce", oidc_enable_pkce)
         if oidc_scopes is not None:
             pulumi.set(__self__, "oidc_scopes", oidc_scopes)
         if signing_algs is not None:
             pulumi.set(__self__, "signing_algs", signing_algs)
+        if verbose_logging is not None:
+            pulumi.set(__self__, "verbose_logging", verbose_logging)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowedRedirectUris")
-    def allowed_redirect_uris(self) -> Optional[Sequence[builtins.str]]:
+    def allowed_redirect_uris(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - A list of allowed values
         that can be used for the redirect URI.
         """
         return pulumi.get(self, "allowed_redirect_uris")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="boundAudiences")
-    def bound_audiences(self) -> Optional[Sequence[builtins.str]]:
+    def bound_audiences(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - List of auth claims that are
         valid for login.
         """
         return pulumi.get(self, "bound_audiences")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="boundIssuers")
-    def bound_issuers(self) -> Optional[Sequence[builtins.str]]:
+    def bound_issuers(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - The value against which to match
         the iss claim in a JWT.
         """
         return pulumi.get(self, "bound_issuers")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="claimMappings")
-    def claim_mappings(self) -> Optional[Mapping[str, builtins.str]]:
+    def claim_mappings(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         Mappings of claims (key) that will be copied to a metadata field (value).
         """
         return pulumi.get(self, "claim_mappings")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="clockSkewLeeway")
-    def clock_skew_leeway(self) -> Optional[builtins.str]:
+    def clock_skew_leeway(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - Duration of leeway when validating
         all claims in the form of a time duration such as "5m" or "1h".
         """
         return pulumi.get(self, "clock_skew_leeway")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="discoveryCaPems")
-    def discovery_ca_pems(self) -> Optional[Sequence[builtins.str]]:
+    def discovery_ca_pems(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - PEM encoded CA certs for use
         by the TLS client used to talk with the OIDC Discovery URL.
         """
         return pulumi.get(self, "discovery_ca_pems")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="expirationLeeway")
-    def expiration_leeway(self) -> Optional[builtins.str]:
+    def expiration_leeway(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - Duration of leeway when validating
         expiration of a JWT in the form of a time duration such as "5m" or "1h".
         """
         return pulumi.get(self, "expiration_leeway")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="jwksCaCert")
-    def jwks_ca_cert(self) -> Optional[builtins.str]:
+    def jwks_ca_cert(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - PEM encoded CA cert for use by the 
         TLS client used to talk with the JWKS server.
         """
         return pulumi.get(self, "jwks_ca_cert")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="jwksUrl")
-    def jwks_url(self) -> Optional[builtins.str]:
+    def jwks_url(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - JSON Web Key Sets url for authenticating
         signatures.
         """
         return pulumi.get(self, "jwks_url")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="jwtValidationPubKeys")
-    def jwt_validation_pub_keys(self) -> Optional[Sequence[builtins.str]]:
+    def jwt_validation_pub_keys(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - List of PEM-encoded 
         public keys to use to authenticate signatures locally.
         """
         return pulumi.get(self, "jwt_validation_pub_keys")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="listClaimMappings")
-    def list_claim_mappings(self) -> Optional[Mapping[str, builtins.str]]:
+    def list_claim_mappings(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         Mappings of list claims (key) that will be copied to a metadata field (value).
         """
         return pulumi.get(self, "list_claim_mappings")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="notBeforeLeeway")
-    def not_before_leeway(self) -> Optional[builtins.str]:
+    def not_before_leeway(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - Duration of leeway when validating
         not before values of a token in the form of a time duration such as "5m" or "1h".
         """
         return pulumi.get(self, "not_before_leeway")
 
-    @property
+    @_builtins.property
+    @pulumi.getter(name="oidcClientAssertion")
+    def oidc_client_assertion(self) -> Optional['outputs.AclAuthMethodConfigOidcClientAssertion']:
+        """
+        `(OIDCClientAssertion: <optional>)` - Optionally
+        send a signed JWT ("[private key jwt][]") as a client assertion to the OIDC
+        provider. Browse to the [OIDC concepts][concepts-assertions] page to learn
+        more.
+        """
+        return pulumi.get(self, "oidc_client_assertion")
+
+    @_builtins.property
     @pulumi.getter(name="oidcClientId")
-    def oidc_client_id(self) -> Optional[builtins.str]:
+    def oidc_client_id(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - The OAuth Client ID configured
         with the OIDC provider.
         """
         return pulumi.get(self, "oidc_client_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="oidcClientSecret")
-    def oidc_client_secret(self) -> Optional[builtins.str]:
+    def oidc_client_secret(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - The OAuth Client Secret
         configured with the OIDC provider.
         """
         return pulumi.get(self, "oidc_client_secret")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="oidcDisableUserinfo")
-    def oidc_disable_userinfo(self) -> Optional[builtins.bool]:
+    def oidc_disable_userinfo(self) -> Optional[_builtins.bool]:
         """
         `(bool: false)` - When set to `true`, Nomad will
         not make a request to the identity provider to get OIDC `UserInfo`.
@@ -364,32 +405,307 @@ class AclAuthMethodConfig(dict):
         """
         return pulumi.get(self, "oidc_disable_userinfo")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="oidcDiscoveryUrl")
-    def oidc_discovery_url(self) -> Optional[builtins.str]:
+    def oidc_discovery_url(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - The OIDC Discovery URL,
         without any .well-known component (base path).
         """
         return pulumi.get(self, "oidc_discovery_url")
 
-    @property
+    @_builtins.property
+    @pulumi.getter(name="oidcEnablePkce")
+    def oidc_enable_pkce(self) -> Optional[_builtins.bool]:
+        """
+        `(bool: false)` - When set to `true`, Nomad will include
+        [PKCE][] verification in the auth flow. Even with PKCE enabled in Nomad,
+        you may still need to enable it in your OIDC provider.
+        """
+        return pulumi.get(self, "oidc_enable_pkce")
+
+    @_builtins.property
     @pulumi.getter(name="oidcScopes")
-    def oidc_scopes(self) -> Optional[Sequence[builtins.str]]:
+    def oidc_scopes(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - List of OIDC scopes.
         """
         return pulumi.get(self, "oidc_scopes")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="signingAlgs")
-    def signing_algs(self) -> Optional[Sequence[builtins.str]]:
+    def signing_algs(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - A list of supported signing
         algorithms.
         """
         return pulumi.get(self, "signing_algs")
 
+    @_builtins.property
+    @pulumi.getter(name="verboseLogging")
+    def verbose_logging(self) -> Optional[_builtins.bool]:
+        """
+        Enable OIDC verbose logging on the Nomad server.
+        """
+        return pulumi.get(self, "verbose_logging")
+
+
+@pulumi.output_type
+class AclAuthMethodConfigOidcClientAssertion(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keySource":
+            suggest = "key_source"
+        elif key == "extraHeaders":
+            suggest = "extra_headers"
+        elif key == "keyAlgorithm":
+            suggest = "key_algorithm"
+        elif key == "privateKey":
+            suggest = "private_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AclAuthMethodConfigOidcClientAssertion. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AclAuthMethodConfigOidcClientAssertion.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AclAuthMethodConfigOidcClientAssertion.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_source: _builtins.str,
+                 audiences: Optional[Sequence[_builtins.str]] = None,
+                 extra_headers: Optional[Mapping[str, _builtins.str]] = None,
+                 key_algorithm: Optional[_builtins.str] = None,
+                 private_key: Optional['outputs.AclAuthMethodConfigOidcClientAssertionPrivateKey'] = None):
+        """
+        :param _builtins.str key_source: `(string: <required>)` - Specifies where to get the private
+               key to sign the JWT.
+               Available sources:
+               - "nomad": Use current active key in Nomad's keyring
+               - "private_key": Use key material in the `private_key` field
+               - "client_secret": Use the `oidc_client_secret` as an HMAC key
+        :param Sequence[_builtins.str] audiences: `([]string: optional)` - Who processes the assertion.
+               Defaults to the auth method's `oidc_discovery_url`.
+        :param Mapping[str, _builtins.str] extra_headers: `(map[string]string: optional)` - Add to the JWT headers,
+               alongside "kid" and "type". Setting the "kid" header here is not allowed;
+               use `private_key.key_id`.
+        :param _builtins.str key_algorithm: `(string: <optional>)` is the key's algorithm.
+               Its default values are based on the `key_source`:
+               - "nomad": "RS256"; this is from Nomad's keyring and must not be changed
+               - "private_key": "RS256"; must be RS256, RS384, or RS512
+               - "client_secret": "HS256"; must be HS256, HS384, or HS512
+        :param 'AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs' private_key: `(OIDCClientAssertionKey: <optional>)` - External key
+               to sign the JWT. `key_source` must be "private_key" to enable this.
+        """
+        pulumi.set(__self__, "key_source", key_source)
+        if audiences is not None:
+            pulumi.set(__self__, "audiences", audiences)
+        if extra_headers is not None:
+            pulumi.set(__self__, "extra_headers", extra_headers)
+        if key_algorithm is not None:
+            pulumi.set(__self__, "key_algorithm", key_algorithm)
+        if private_key is not None:
+            pulumi.set(__self__, "private_key", private_key)
+
+    @_builtins.property
+    @pulumi.getter(name="keySource")
+    def key_source(self) -> _builtins.str:
+        """
+        `(string: <required>)` - Specifies where to get the private
+        key to sign the JWT.
+        Available sources:
+        - "nomad": Use current active key in Nomad's keyring
+        - "private_key": Use key material in the `private_key` field
+        - "client_secret": Use the `oidc_client_secret` as an HMAC key
+        """
+        return pulumi.get(self, "key_source")
+
+    @_builtins.property
+    @pulumi.getter
+    def audiences(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        `([]string: optional)` - Who processes the assertion.
+        Defaults to the auth method's `oidc_discovery_url`.
+        """
+        return pulumi.get(self, "audiences")
+
+    @_builtins.property
+    @pulumi.getter(name="extraHeaders")
+    def extra_headers(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        `(map[string]string: optional)` - Add to the JWT headers,
+        alongside "kid" and "type". Setting the "kid" header here is not allowed;
+        use `private_key.key_id`.
+        """
+        return pulumi.get(self, "extra_headers")
+
+    @_builtins.property
+    @pulumi.getter(name="keyAlgorithm")
+    def key_algorithm(self) -> Optional[_builtins.str]:
+        """
+        `(string: <optional>)` is the key's algorithm.
+        Its default values are based on the `key_source`:
+        - "nomad": "RS256"; this is from Nomad's keyring and must not be changed
+        - "private_key": "RS256"; must be RS256, RS384, or RS512
+        - "client_secret": "HS256"; must be HS256, HS384, or HS512
+        """
+        return pulumi.get(self, "key_algorithm")
+
+    @_builtins.property
+    @pulumi.getter(name="privateKey")
+    def private_key(self) -> Optional['outputs.AclAuthMethodConfigOidcClientAssertionPrivateKey']:
+        """
+        `(OIDCClientAssertionKey: <optional>)` - External key
+        to sign the JWT. `key_source` must be "private_key" to enable this.
+        """
+        return pulumi.get(self, "private_key")
+
+
+@pulumi.output_type
+class AclAuthMethodConfigOidcClientAssertionPrivateKey(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyId":
+            suggest = "key_id"
+        elif key == "keyIdHeader":
+            suggest = "key_id_header"
+        elif key == "pemCert":
+            suggest = "pem_cert"
+        elif key == "pemCertFile":
+            suggest = "pem_cert_file"
+        elif key == "pemKey":
+            suggest = "pem_key"
+        elif key == "pemKeyFile":
+            suggest = "pem_key_file"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AclAuthMethodConfigOidcClientAssertionPrivateKey. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AclAuthMethodConfigOidcClientAssertionPrivateKey.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AclAuthMethodConfigOidcClientAssertionPrivateKey.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_id: Optional[_builtins.str] = None,
+                 key_id_header: Optional[_builtins.str] = None,
+                 pem_cert: Optional[_builtins.str] = None,
+                 pem_cert_file: Optional[_builtins.str] = None,
+                 pem_key: Optional[_builtins.str] = None,
+                 pem_key_file: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str key_id: `(string: optional)` - Becomes the JWT's "kid" header.
+               Mutually exclusive with `pem_cert` and `pem_cert_file`.
+               Allowed `key_id_header` values: "kid" (the default)
+        :param _builtins.str key_id_header: `(string: optional)` - Which header the provider uses
+               to find the public key to verify the signed JWT.
+               The default and allowed values depend on whether you set `key_id`,
+               `pem_cert`, or `pem_cert_file`. You must set exactly one of those
+               options, so refer to them for their requirements.
+        :param _builtins.str pem_cert: `(string: optional)` - An x509 certificate, signed by the
+               private key or a CA, in pem format. Nomad uses this certificate to
+               derive an [x5t#S256][] (or [x5t][]) key_id.
+               Mutually exclusive with `pem_cert_file` and `key_id`.
+               Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
+        :param _builtins.str pem_cert_file: `(string: optional)` - An absolute path to an x509
+               certificate on Nomad servers' disk, signed by the private key or a CA,
+               in pem format.
+               Nomad uses this certificate to derive an [x5t#S256][] (or [x5t][])
+               header. Mutually exclusive with `pem_cert` and key_id.
+               Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
+        :param _builtins.str pem_key: `(string: <optional>)` - An RSA private key, in pem format.
+               It is used to sign the JWT. Mutually exclusive with `pem_key`.
+        :param _builtins.str pem_key_file: `(string: optional)` - An absolute path to a private key
+               on Nomad servers' disk, in pem format. It is used to sign the JWT.
+               Mutually exclusive with `pem_key_file`.
+        """
+        if key_id is not None:
+            pulumi.set(__self__, "key_id", key_id)
+        if key_id_header is not None:
+            pulumi.set(__self__, "key_id_header", key_id_header)
+        if pem_cert is not None:
+            pulumi.set(__self__, "pem_cert", pem_cert)
+        if pem_cert_file is not None:
+            pulumi.set(__self__, "pem_cert_file", pem_cert_file)
+        if pem_key is not None:
+            pulumi.set(__self__, "pem_key", pem_key)
+        if pem_key_file is not None:
+            pulumi.set(__self__, "pem_key_file", pem_key_file)
+
+    @_builtins.property
+    @pulumi.getter(name="keyId")
+    def key_id(self) -> Optional[_builtins.str]:
+        """
+        `(string: optional)` - Becomes the JWT's "kid" header.
+        Mutually exclusive with `pem_cert` and `pem_cert_file`.
+        Allowed `key_id_header` values: "kid" (the default)
+        """
+        return pulumi.get(self, "key_id")
+
+    @_builtins.property
+    @pulumi.getter(name="keyIdHeader")
+    def key_id_header(self) -> Optional[_builtins.str]:
+        """
+        `(string: optional)` - Which header the provider uses
+        to find the public key to verify the signed JWT.
+        The default and allowed values depend on whether you set `key_id`,
+        `pem_cert`, or `pem_cert_file`. You must set exactly one of those
+        options, so refer to them for their requirements.
+        """
+        return pulumi.get(self, "key_id_header")
+
+    @_builtins.property
+    @pulumi.getter(name="pemCert")
+    def pem_cert(self) -> Optional[_builtins.str]:
+        """
+        `(string: optional)` - An x509 certificate, signed by the
+        private key or a CA, in pem format. Nomad uses this certificate to
+        derive an [x5t#S256][] (or [x5t][]) key_id.
+        Mutually exclusive with `pem_cert_file` and `key_id`.
+        Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
+        """
+        return pulumi.get(self, "pem_cert")
+
+    @_builtins.property
+    @pulumi.getter(name="pemCertFile")
+    def pem_cert_file(self) -> Optional[_builtins.str]:
+        """
+        `(string: optional)` - An absolute path to an x509
+        certificate on Nomad servers' disk, signed by the private key or a CA,
+        in pem format.
+        Nomad uses this certificate to derive an [x5t#S256][] (or [x5t][])
+        header. Mutually exclusive with `pem_cert` and key_id.
+        Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
+        """
+        return pulumi.get(self, "pem_cert_file")
+
+    @_builtins.property
+    @pulumi.getter(name="pemKey")
+    def pem_key(self) -> Optional[_builtins.str]:
+        """
+        `(string: <optional>)` - An RSA private key, in pem format.
+        It is used to sign the JWT. Mutually exclusive with `pem_key`.
+        """
+        return pulumi.get(self, "pem_key")
+
+    @_builtins.property
+    @pulumi.getter(name="pemKeyFile")
+    def pem_key_file(self) -> Optional[_builtins.str]:
+        """
+        `(string: optional)` - An absolute path to a private key
+        on Nomad servers' disk, in pem format. It is used to sign the JWT.
+        Mutually exclusive with `pem_key_file`.
+        """
+        return pulumi.get(self, "pem_key_file")
+
 
 @pulumi.output_type
 class AclPolicyJobAcl(dict):
@@ -411,15 +727,15 @@ class AclPolicyJobAcl(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 job_id: builtins.str,
-                 group: Optional[builtins.str] = None,
-                 namespace: Optional[builtins.str] = None,
-                 task: Optional[builtins.str] = None):
+                 job_id: _builtins.str,
+                 group: Optional[_builtins.str] = None,
+                 namespace: Optional[_builtins.str] = None,
+                 task: Optional[_builtins.str] = None):
         """
-        :param builtins.str job_id: Job
-        :param builtins.str group: Group
-        :param builtins.str namespace: Namespace
-        :param builtins.str task: Task
+        :param _builtins.str job_id: Job
+        :param _builtins.str group: Group
+        :param _builtins.str namespace: Namespace
+        :param _builtins.str task: Task
         """
         pulumi.set(__self__, "job_id", job_id)
         if group is not None:
@@ -429,33 +745,33 @@ class AclPolicyJobAcl(dict):
         if task is not None:
             pulumi.set(__self__, "task", task)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="jobId")
-    def job_id(self) -> builtins.str:
+    def job_id(self) -> _builtins.str:
         """
         Job
         """
         return pulumi.get(self, "job_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def group(self) -> Optional[builtins.str]:
+    def group(self) -> Optional[_builtins.str]:
         """
         Group
         """
         return pulumi.get(self, "group")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def namespace(self) -> Optional[builtins.str]:
+    def namespace(self) -> Optional[_builtins.str]:
         """
         Namespace
         """
         return pulumi.get(self, "namespace")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def task(self) -> Optional[builtins.str]:
+    def task(self) -> Optional[_builtins.str]:
         """
         Task
         """
@@ -465,15 +781,15 @@ class AclPolicyJobAcl(dict):
 @pulumi.output_type
 class AclRolePolicy(dict):
     def __init__(__self__, *,
-                 name: builtins.str):
+                 name: _builtins.str):
         """
-        :param builtins.str name: `(string: <required>)` - A human-friendly name for this ACL Role.
+        :param _builtins.str name: `(string: <required>)` - A human-friendly name for this ACL Role.
         """
         pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string: <required>)` - A human-friendly name for this ACL Role.
         """
@@ -483,27 +799,27 @@ class AclRolePolicy(dict):
 @pulumi.output_type
 class AclTokenRole(dict):
     def __init__(__self__, *,
-                 id: builtins.str,
-                 name: Optional[builtins.str] = None):
+                 id: _builtins.str,
+                 name: Optional[_builtins.str] = None):
         """
-        :param builtins.str id: The ID of the ACL role to link.
-        :param builtins.str name: `(string: "")` - A human-friendly name for this token.
+        :param _builtins.str id: The ID of the ACL role to link.
+        :param _builtins.str name: `(string: "")` - A human-friendly name for this token.
         """
         pulumi.set(__self__, "id", id)
         if name is not None:
             pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> builtins.str:
+    def id(self) -> _builtins.str:
         """
         The ID of the ACL role to link.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> Optional[builtins.str]:
+    def name(self) -> Optional[_builtins.str]:
         """
         `(string: "")` - A human-friendly name for this token.
         """
@@ -532,25 +848,25 @@ class CsiVolumeCapability(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 access_mode: builtins.str,
-                 attachment_mode: builtins.str):
+                 access_mode: _builtins.str,
+                 attachment_mode: _builtins.str):
         """
-        :param builtins.str access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
+        :param _builtins.str access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
                - `single-node-reader-only`
                - `single-node-writer`
                - `multi-node-reader-only`
                - `multi-node-single-writer`
                - `multi-node-multi-writer`
-        :param builtins.str attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
+        :param _builtins.str attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
                - `block-device`
                - `file-system`
         """
         pulumi.set(__self__, "access_mode", access_mode)
         pulumi.set(__self__, "attachment_mode", attachment_mode)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessMode")
-    def access_mode(self) -> builtins.str:
+    def access_mode(self) -> _builtins.str:
         """
         `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
         - `single-node-reader-only`
@@ -561,9 +877,9 @@ class CsiVolumeCapability(dict):
         """
         return pulumi.get(self, "access_mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="attachmentMode")
-    def attachment_mode(self) -> builtins.str:
+    def attachment_mode(self) -> _builtins.str:
         """
         `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
         - `block-device`
@@ -594,28 +910,28 @@ class CsiVolumeMountOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 fs_type: Optional[builtins.str] = None,
-                 mount_flags: Optional[Sequence[builtins.str]] = None):
+                 fs_type: Optional[_builtins.str] = None,
+                 mount_flags: Optional[Sequence[_builtins.str]] = None):
         """
-        :param builtins.str fs_type: `(string: optional)` - The file system type.
-        :param Sequence[builtins.str] mount_flags: `[]string: optional` - The flags passed to `mount`.
+        :param _builtins.str fs_type: `(string: optional)` - The file system type.
+        :param Sequence[_builtins.str] mount_flags: `[]string: optional` - The flags passed to `mount`.
         """
         if fs_type is not None:
             pulumi.set(__self__, "fs_type", fs_type)
         if mount_flags is not None:
             pulumi.set(__self__, "mount_flags", mount_flags)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fsType")
-    def fs_type(self) -> Optional[builtins.str]:
+    def fs_type(self) -> Optional[_builtins.str]:
         """
         `(string: optional)` - The file system type.
         """
         return pulumi.get(self, "fs_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="mountFlags")
-    def mount_flags(self) -> Optional[Sequence[builtins.str]]:
+    def mount_flags(self) -> Optional[Sequence[_builtins.str]]:
         """
         `[]string: optional` - The flags passed to `mount`.
         """
@@ -644,25 +960,25 @@ class CsiVolumeRegistrationCapability(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 access_mode: builtins.str,
-                 attachment_mode: builtins.str):
+                 access_mode: _builtins.str,
+                 attachment_mode: _builtins.str):
         """
-        :param builtins.str access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
+        :param _builtins.str access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
                - `single-node-reader-only`
                - `single-node-writer`
                - `multi-node-reader-only`
                - `multi-node-single-writer`
                - `multi-node-multi-writer`
-        :param builtins.str attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
+        :param _builtins.str attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
                - `block-device`
                - `file-system`
         """
         pulumi.set(__self__, "access_mode", access_mode)
         pulumi.set(__self__, "attachment_mode", attachment_mode)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessMode")
-    def access_mode(self) -> builtins.str:
+    def access_mode(self) -> _builtins.str:
         """
         `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
         - `single-node-reader-only`
@@ -673,9 +989,9 @@ class CsiVolumeRegistrationCapability(dict):
         """
         return pulumi.get(self, "access_mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="attachmentMode")
-    def attachment_mode(self) -> builtins.str:
+    def attachment_mode(self) -> _builtins.str:
         """
         `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
         - `block-device`
@@ -706,28 +1022,28 @@ class CsiVolumeRegistrationMountOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 fs_type: Optional[builtins.str] = None,
-                 mount_flags: Optional[Sequence[builtins.str]] = None):
+                 fs_type: Optional[_builtins.str] = None,
+                 mount_flags: Optional[Sequence[_builtins.str]] = None):
         """
-        :param builtins.str fs_type: `(string: <optional>)` - The file system type.
-        :param Sequence[builtins.str] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
+        :param _builtins.str fs_type: `(string: <optional>)` - The file system type.
+        :param Sequence[_builtins.str] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
         """
         if fs_type is not None:
             pulumi.set(__self__, "fs_type", fs_type)
         if mount_flags is not None:
             pulumi.set(__self__, "mount_flags", mount_flags)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fsType")
-    def fs_type(self) -> Optional[builtins.str]:
+    def fs_type(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - The file system type.
         """
         return pulumi.get(self, "fs_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="mountFlags")
-    def mount_flags(self) -> Optional[Sequence[builtins.str]]:
+    def mount_flags(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - The flags passed to `mount`.
         """
@@ -737,9 +1053,9 @@ class CsiVolumeRegistrationMountOptions(dict):
 @pulumi.output_type
 class CsiVolumeRegistrationTopology(dict):
     def __init__(__self__, *,
-                 segments: Optional[Mapping[str, builtins.str]] = None):
+                 segments: Optional[Mapping[str, _builtins.str]] = None):
         """
-        :param Mapping[str, builtins.str] segments: `(map[string]string)` - Define the attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: `(map[string]string)` - Define the attributes for the topology request.
                
                In addition to the above arguments, the following attributes are exported and
                can be referenced:
@@ -747,9 +1063,9 @@ class CsiVolumeRegistrationTopology(dict):
         if segments is not None:
             pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Optional[Mapping[str, builtins.str]]:
+    def segments(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         `(map[string]string)` - Define the attributes for the topology request.
 
@@ -769,7 +1085,7 @@ class CsiVolumeRegistrationTopologyRequest(dict):
         if required is not None:
             pulumi.set(__self__, "required", required)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def required(self) -> Optional['outputs.CsiVolumeRegistrationTopologyRequestRequired']:
         """
@@ -787,7 +1103,7 @@ class CsiVolumeRegistrationTopologyRequestRequired(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.CsiVolumeRegistrationTopologyRequestRequiredTopology']:
         """
@@ -799,15 +1115,15 @@ class CsiVolumeRegistrationTopologyRequestRequired(dict):
 @pulumi.output_type
 class CsiVolumeRegistrationTopologyRequestRequiredTopology(dict):
     def __init__(__self__, *,
-                 segments: Mapping[str, builtins.str]):
+                 segments: Mapping[str, _builtins.str]):
         """
-        :param Mapping[str, builtins.str] segments: Define attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: Define attributes for the topology request.
         """
         pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Mapping[str, builtins.str]:
+    def segments(self) -> Mapping[str, _builtins.str]:
         """
         Define attributes for the topology request.
         """
@@ -817,9 +1133,9 @@ class CsiVolumeRegistrationTopologyRequestRequiredTopology(dict):
 @pulumi.output_type
 class CsiVolumeTopology(dict):
     def __init__(__self__, *,
-                 segments: Optional[Mapping[str, builtins.str]] = None):
+                 segments: Optional[Mapping[str, _builtins.str]] = None):
         """
-        :param Mapping[str, builtins.str] segments: `(map[string]string)` - Define the attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: `(map[string]string)` - Define the attributes for the topology request.
                
                In addition to the above arguments, the following attributes are exported and
                can be referenced:
@@ -827,9 +1143,9 @@ class CsiVolumeTopology(dict):
         if segments is not None:
             pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Optional[Mapping[str, builtins.str]]:
+    def segments(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         `(map[string]string)` - Define the attributes for the topology request.
 
@@ -853,7 +1169,7 @@ class CsiVolumeTopologyRequest(dict):
         if required is not None:
             pulumi.set(__self__, "required", required)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def preferred(self) -> Optional['outputs.CsiVolumeTopologyRequestPreferred']:
         """
@@ -861,7 +1177,7 @@ class CsiVolumeTopologyRequest(dict):
         """
         return pulumi.get(self, "preferred")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def required(self) -> Optional['outputs.CsiVolumeTopologyRequestRequired']:
         """
@@ -879,7 +1195,7 @@ class CsiVolumeTopologyRequestPreferred(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.CsiVolumeTopologyRequestPreferredTopology']:
         """
@@ -891,15 +1207,15 @@ class CsiVolumeTopologyRequestPreferred(dict):
 @pulumi.output_type
 class CsiVolumeTopologyRequestPreferredTopology(dict):
     def __init__(__self__, *,
-                 segments: Mapping[str, builtins.str]):
+                 segments: Mapping[str, _builtins.str]):
         """
-        :param Mapping[str, builtins.str] segments: Define the attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: Define the attributes for the topology request.
         """
         pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Mapping[str, builtins.str]:
+    def segments(self) -> Mapping[str, _builtins.str]:
         """
         Define the attributes for the topology request.
         """
@@ -915,7 +1231,7 @@ class CsiVolumeTopologyRequestRequired(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.CsiVolumeTopologyRequestRequiredTopology']:
         """
@@ -927,21 +1243,209 @@ class CsiVolumeTopologyRequestRequired(dict):
 @pulumi.output_type
 class CsiVolumeTopologyRequestRequiredTopology(dict):
     def __init__(__self__, *,
-                 segments: Mapping[str, builtins.str]):
+                 segments: Mapping[str, _builtins.str]):
         """
-        :param Mapping[str, builtins.str] segments: Define the attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: Define the attributes for the topology request.
         """
         pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Mapping[str, builtins.str]:
+    def segments(self) -> Mapping[str, _builtins.str]:
         """
         Define the attributes for the topology request.
         """
         return pulumi.get(self, "segments")
 
 
+@pulumi.output_type
+class DynamicHostVolumeCapability(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accessMode":
+            suggest = "access_mode"
+        elif key == "attachmentMode":
+            suggest = "attachment_mode"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DynamicHostVolumeCapability. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DynamicHostVolumeCapability.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DynamicHostVolumeCapability.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 access_mode: _builtins.str,
+                 attachment_mode: _builtins.str):
+        """
+        :param _builtins.str access_mode: `(string)` - How the volume can be mounted by
+               allocations. Refer to the [`access_mode`][] documentation for details.
+        :param _builtins.str attachment_mode: `(string)` - The storage API that will be used by the
+               volume. Refer to the [`attachment_mode`][] documentation.
+        """
+        pulumi.set(__self__, "access_mode", access_mode)
+        pulumi.set(__self__, "attachment_mode", attachment_mode)
+
+    @_builtins.property
+    @pulumi.getter(name="accessMode")
+    def access_mode(self) -> _builtins.str:
+        """
+        `(string)` - How the volume can be mounted by
+        allocations. Refer to the [`access_mode`][] documentation for details.
+        """
+        return pulumi.get(self, "access_mode")
+
+    @_builtins.property
+    @pulumi.getter(name="attachmentMode")
+    def attachment_mode(self) -> _builtins.str:
+        """
+        `(string)` - The storage API that will be used by the
+        volume. Refer to the [`attachment_mode`][] documentation.
+        """
+        return pulumi.get(self, "attachment_mode")
+
+
+@pulumi.output_type
+class DynamicHostVolumeConstraint(dict):
+    def __init__(__self__, *,
+                 attribute: _builtins.str,
+                 operator: Optional[_builtins.str] = None,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str attribute: `(string)` - The [node attribute][] to check for the constraint.
+        :param _builtins.str operator: `(string)`- The operator to use in the comparison.
+        :param _builtins.str value: `(string)` - The value of the attribute to compare against.
+        """
+        pulumi.set(__self__, "attribute", attribute)
+        if operator is not None:
+            pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def attribute(self) -> _builtins.str:
+        """
+        `(string)` - The [node attribute][] to check for the constraint.
+        """
+        return pulumi.get(self, "attribute")
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> Optional[_builtins.str]:
+        """
+        `(string)`- The operator to use in the comparison.
+        """
+        return pulumi.get(self, "operator")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        `(string)` - The value of the attribute to compare against.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class DynamicHostVolumeRegistrationCapability(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accessMode":
+            suggest = "access_mode"
+        elif key == "attachmentMode":
+            suggest = "attachment_mode"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DynamicHostVolumeRegistrationCapability. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DynamicHostVolumeRegistrationCapability.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DynamicHostVolumeRegistrationCapability.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 access_mode: _builtins.str,
+                 attachment_mode: _builtins.str):
+        """
+        :param _builtins.str access_mode: `(string)` - How the volume can be mounted by
+               allocations. Refer to the [`access_mode`][] documentation for details.
+        :param _builtins.str attachment_mode: `(string)` - The storage API that will be used by the
+               volume. Refer to the [`attachment_mode`][] documentation.
+        """
+        pulumi.set(__self__, "access_mode", access_mode)
+        pulumi.set(__self__, "attachment_mode", attachment_mode)
+
+    @_builtins.property
+    @pulumi.getter(name="accessMode")
+    def access_mode(self) -> _builtins.str:
+        """
+        `(string)` - How the volume can be mounted by
+        allocations. Refer to the [`access_mode`][] documentation for details.
+        """
+        return pulumi.get(self, "access_mode")
+
+    @_builtins.property
+    @pulumi.getter(name="attachmentMode")
+    def attachment_mode(self) -> _builtins.str:
+        """
+        `(string)` - The storage API that will be used by the
+        volume. Refer to the [`attachment_mode`][] documentation.
+        """
+        return pulumi.get(self, "attachment_mode")
+
+
+@pulumi.output_type
+class DynamicHostVolumeRegistrationConstraint(dict):
+    def __init__(__self__, *,
+                 attribute: _builtins.str,
+                 operator: Optional[_builtins.str] = None,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str attribute: An attribute to check to constrain volume placement
+        :param _builtins.str operator: The operator to use for comparison
+        :param _builtins.str value: The requested value of the attribute
+        """
+        pulumi.set(__self__, "attribute", attribute)
+        if operator is not None:
+            pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def attribute(self) -> _builtins.str:
+        """
+        An attribute to check to constrain volume placement
+        """
+        return pulumi.get(self, "attribute")
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> Optional[_builtins.str]:
+        """
+        The operator to use for comparison
+        """
+        return pulumi.get(self, "operator")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        The requested value of the attribute
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class ExternalVolumeCapability(dict):
     @staticmethod
@@ -964,25 +1468,25 @@ class ExternalVolumeCapability(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 access_mode: builtins.str,
-                 attachment_mode: builtins.str):
+                 access_mode: _builtins.str,
+                 attachment_mode: _builtins.str):
         """
-        :param builtins.str access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
+        :param _builtins.str access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
                - `single-node-reader-only`
                - `single-node-writer`
                - `multi-node-reader-only`
                - `multi-node-single-writer`
                - `multi-node-multi-writer`
-        :param builtins.str attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
+        :param _builtins.str attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
                - `block-device`
                - `file-system`
         """
         pulumi.set(__self__, "access_mode", access_mode)
         pulumi.set(__self__, "attachment_mode", attachment_mode)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessMode")
-    def access_mode(self) -> builtins.str:
+    def access_mode(self) -> _builtins.str:
         """
         `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
         - `single-node-reader-only`
@@ -993,9 +1497,9 @@ class ExternalVolumeCapability(dict):
         """
         return pulumi.get(self, "access_mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="attachmentMode")
-    def attachment_mode(self) -> builtins.str:
+    def attachment_mode(self) -> _builtins.str:
         """
         `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
         - `block-device`
@@ -1026,28 +1530,28 @@ class ExternalVolumeMountOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 fs_type: Optional[builtins.str] = None,
-                 mount_flags: Optional[Sequence[builtins.str]] = None):
+                 fs_type: Optional[_builtins.str] = None,
+                 mount_flags: Optional[Sequence[_builtins.str]] = None):
         """
-        :param builtins.str fs_type: `(string: optional)` - The file system type.
-        :param Sequence[builtins.str] mount_flags: `[]string: optional` - The flags passed to `mount`.
+        :param _builtins.str fs_type: `(string: optional)` - The file system type.
+        :param Sequence[_builtins.str] mount_flags: `[]string: optional` - The flags passed to `mount`.
         """
         if fs_type is not None:
             pulumi.set(__self__, "fs_type", fs_type)
         if mount_flags is not None:
             pulumi.set(__self__, "mount_flags", mount_flags)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fsType")
-    def fs_type(self) -> Optional[builtins.str]:
+    def fs_type(self) -> Optional[_builtins.str]:
         """
         `(string: optional)` - The file system type.
         """
         return pulumi.get(self, "fs_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="mountFlags")
-    def mount_flags(self) -> Optional[Sequence[builtins.str]]:
+    def mount_flags(self) -> Optional[Sequence[_builtins.str]]:
         """
         `[]string: optional` - The flags passed to `mount`.
         """
@@ -1057,9 +1561,9 @@ class ExternalVolumeMountOptions(dict):
 @pulumi.output_type
 class ExternalVolumeTopology(dict):
     def __init__(__self__, *,
-                 segments: Optional[Mapping[str, builtins.str]] = None):
+                 segments: Optional[Mapping[str, _builtins.str]] = None):
         """
-        :param Mapping[str, builtins.str] segments: `(map[string]string)` - Define the attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: `(map[string]string)` - Define the attributes for the topology request.
                
                In addition to the above arguments, the following attributes are exported and
                can be referenced:
@@ -1067,9 +1571,9 @@ class ExternalVolumeTopology(dict):
         if segments is not None:
             pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Optional[Mapping[str, builtins.str]]:
+    def segments(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         `(map[string]string)` - Define the attributes for the topology request.
 
@@ -1093,7 +1597,7 @@ class ExternalVolumeTopologyRequest(dict):
         if required is not None:
             pulumi.set(__self__, "required", required)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def preferred(self) -> Optional['outputs.ExternalVolumeTopologyRequestPreferred']:
         """
@@ -1101,7 +1605,7 @@ class ExternalVolumeTopologyRequest(dict):
         """
         return pulumi.get(self, "preferred")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def required(self) -> Optional['outputs.ExternalVolumeTopologyRequestRequired']:
         """
@@ -1119,7 +1623,7 @@ class ExternalVolumeTopologyRequestPreferred(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.ExternalVolumeTopologyRequestPreferredTopology']:
         """
@@ -1131,15 +1635,15 @@ class ExternalVolumeTopologyRequestPreferred(dict):
 @pulumi.output_type
 class ExternalVolumeTopologyRequestPreferredTopology(dict):
     def __init__(__self__, *,
-                 segments: Mapping[str, builtins.str]):
+                 segments: Mapping[str, _builtins.str]):
         """
-        :param Mapping[str, builtins.str] segments: Define the attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: Define the attributes for the topology request.
         """
         pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Mapping[str, builtins.str]:
+    def segments(self) -> Mapping[str, _builtins.str]:
         """
         Define the attributes for the topology request.
         """
@@ -1155,7 +1659,7 @@ class ExternalVolumeTopologyRequestRequired(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.ExternalVolumeTopologyRequestRequiredTopology']:
         """
@@ -1167,15 +1671,15 @@ class ExternalVolumeTopologyRequestRequired(dict):
 @pulumi.output_type
 class ExternalVolumeTopologyRequestRequiredTopology(dict):
     def __init__(__self__, *,
-                 segments: Mapping[str, builtins.str]):
+                 segments: Mapping[str, _builtins.str]):
         """
-        :param Mapping[str, builtins.str] segments: Define the attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: Define the attributes for the topology request.
         """
         pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Mapping[str, builtins.str]:
+    def segments(self) -> Mapping[str, _builtins.str]:
         """
         Define the attributes for the topology request.
         """
@@ -1202,30 +1706,30 @@ class JobHcl2(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 allow_fs: Optional[builtins.bool] = None,
-                 vars: Optional[Mapping[str, builtins.str]] = None):
+                 allow_fs: Optional[_builtins.bool] = None,
+                 vars: Optional[Mapping[str, _builtins.str]] = None):
         """
-        :param builtins.bool allow_fs: `(boolean: false)` - Set this to `true` to be able to use
+        :param _builtins.bool allow_fs: `(boolean: false)` - Set this to `true` to be able to use
                HCL2 filesystem functions
-        :param Mapping[str, builtins.str] vars: Additional variables to use when templating the job with HCL2
+        :param Mapping[str, _builtins.str] vars: Additional variables to use when templating the job with HCL2
         """
         if allow_fs is not None:
             pulumi.set(__self__, "allow_fs", allow_fs)
         if vars is not None:
             pulumi.set(__self__, "vars", vars)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="allowFs")
-    def allow_fs(self) -> Optional[builtins.bool]:
+    def allow_fs(self) -> Optional[_builtins.bool]:
         """
         `(boolean: false)` - Set this to `true` to be able to use
         HCL2 filesystem functions
         """
         return pulumi.get(self, "allow_fs")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def vars(self) -> Optional[Mapping[str, builtins.str]]:
+    def vars(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         Additional variables to use when templating the job with HCL2
         """
@@ -1235,9 +1739,9 @@ class JobHcl2(dict):
 @pulumi.output_type
 class JobTaskGroup(dict):
     def __init__(__self__, *,
-                 count: Optional[builtins.int] = None,
-                 meta: Optional[Mapping[str, builtins.str]] = None,
-                 name: Optional[builtins.str] = None,
+                 count: Optional[_builtins.int] = None,
+                 meta: Optional[Mapping[str, _builtins.str]] = None,
+                 name: Optional[_builtins.str] = None,
                  tasks: Optional[Sequence['outputs.JobTaskGroupTask']] = None,
                  volumes: Optional[Sequence['outputs.JobTaskGroupVolume']] = None):
         if count is not None:
@@ -1251,27 +1755,27 @@ class JobTaskGroup(dict):
         if volumes is not None:
             pulumi.set(__self__, "volumes", volumes)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def count(self) -> Optional[builtins.int]:
+    def count(self) -> Optional[_builtins.int]:
         return pulumi.get(self, "count")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def meta(self) -> Optional[Mapping[str, builtins.str]]:
+    def meta(self) -> Optional[Mapping[str, _builtins.str]]:
         return pulumi.get(self, "meta")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> Optional[builtins.str]:
+    def name(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def tasks(self) -> Optional[Sequence['outputs.JobTaskGroupTask']]:
         return pulumi.get(self, "tasks")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def volumes(self) -> Optional[Sequence['outputs.JobTaskGroupVolume']]:
         return pulumi.get(self, "volumes")
@@ -1297,9 +1801,9 @@ class JobTaskGroupTask(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 driver: Optional[builtins.str] = None,
-                 meta: Optional[Mapping[str, builtins.str]] = None,
-                 name: Optional[builtins.str] = None,
+                 driver: Optional[_builtins.str] = None,
+                 meta: Optional[Mapping[str, _builtins.str]] = None,
+                 name: Optional[_builtins.str] = None,
                  volume_mounts: Optional[Sequence['outputs.JobTaskGroupTaskVolumeMount']] = None):
         if driver is not None:
             pulumi.set(__self__, "driver", driver)
@@ -1310,22 +1814,22 @@ class JobTaskGroupTask(dict):
         if volume_mounts is not None:
             pulumi.set(__self__, "volume_mounts", volume_mounts)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def driver(self) -> Optional[builtins.str]:
+    def driver(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "driver")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def meta(self) -> Optional[Mapping[str, builtins.str]]:
+    def meta(self) -> Optional[Mapping[str, _builtins.str]]:
         return pulumi.get(self, "meta")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> Optional[builtins.str]:
+    def name(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeMounts")
     def volume_mounts(self) -> Optional[Sequence['outputs.JobTaskGroupTaskVolumeMount']]:
         return pulumi.get(self, "volume_mounts")
@@ -1351,9 +1855,9 @@ class JobTaskGroupTaskVolumeMount(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 destination: Optional[builtins.str] = None,
-                 read_only: Optional[builtins.bool] = None,
-                 volume: Optional[builtins.str] = None):
+                 destination: Optional[_builtins.str] = None,
+                 read_only: Optional[_builtins.bool] = None,
+                 volume: Optional[_builtins.str] = None):
         if destination is not None:
             pulumi.set(__self__, "destination", destination)
         if read_only is not None:
@@ -1361,19 +1865,19 @@ class JobTaskGroupTaskVolumeMount(dict):
         if volume is not None:
             pulumi.set(__self__, "volume", volume)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def destination(self) -> Optional[builtins.str]:
+    def destination(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "destination")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[builtins.bool]:
+    def read_only(self) -> Optional[_builtins.bool]:
         return pulumi.get(self, "read_only")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def volume(self) -> Optional[builtins.str]:
+    def volume(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "volume")
 
 
@@ -1397,10 +1901,10 @@ class JobTaskGroupVolume(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 name: Optional[builtins.str] = None,
-                 read_only: Optional[builtins.bool] = None,
-                 source: Optional[builtins.str] = None,
-                 type: Optional[builtins.str] = None):
+                 name: Optional[_builtins.str] = None,
+                 read_only: Optional[_builtins.bool] = None,
+                 source: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None):
         if name is not None:
             pulumi.set(__self__, "name", name)
         if read_only is not None:
@@ -1410,24 +1914,24 @@ class JobTaskGroupVolume(dict):
         if type is not None:
             pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> Optional[builtins.str]:
+    def name(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[builtins.bool]:
+    def read_only(self) -> Optional[_builtins.bool]:
         return pulumi.get(self, "read_only")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def source(self) -> Optional[builtins.str]:
+    def source(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "source")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> Optional[builtins.str]:
+    def type(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "type")
 
 
@@ -1453,28 +1957,28 @@ class NamespaceCapabilities(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 disabled_task_drivers: Optional[Sequence[builtins.str]] = None,
-                 enabled_task_drivers: Optional[Sequence[builtins.str]] = None):
+                 disabled_task_drivers: Optional[Sequence[_builtins.str]] = None,
+                 enabled_task_drivers: Optional[Sequence[_builtins.str]] = None):
         """
-        :param Sequence[builtins.str] disabled_task_drivers: `([]string: <optional>)` - Task drivers disabled for the namespace.
-        :param Sequence[builtins.str] enabled_task_drivers: `([]string: <optional>)` - Task drivers enabled for the namespace.
+        :param Sequence[_builtins.str] disabled_task_drivers: `([]string: <optional>)` - Task drivers disabled for the namespace.
+        :param Sequence[_builtins.str] enabled_task_drivers: `([]string: <optional>)` - Task drivers enabled for the namespace.
         """
         if disabled_task_drivers is not None:
             pulumi.set(__self__, "disabled_task_drivers", disabled_task_drivers)
         if enabled_task_drivers is not None:
             pulumi.set(__self__, "enabled_task_drivers", enabled_task_drivers)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="disabledTaskDrivers")
-    def disabled_task_drivers(self) -> Optional[Sequence[builtins.str]]:
+    def disabled_task_drivers(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - Task drivers disabled for the namespace.
         """
         return pulumi.get(self, "disabled_task_drivers")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="enabledTaskDrivers")
-    def enabled_task_drivers(self) -> Optional[Sequence[builtins.str]]:
+    def enabled_task_drivers(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - Task drivers enabled for the namespace.
         """
@@ -1484,13 +1988,13 @@ class NamespaceCapabilities(dict):
 @pulumi.output_type
 class NamespaceNodePoolConfig(dict):
     def __init__(__self__, *,
-                 alloweds: Optional[Sequence[builtins.str]] = None,
-                 default: Optional[builtins.str] = None,
-                 denieds: Optional[Sequence[builtins.str]] = None):
+                 alloweds: Optional[Sequence[_builtins.str]] = None,
+                 default: Optional[_builtins.str] = None,
+                 denieds: Optional[Sequence[_builtins.str]] = None):
         """
-        :param Sequence[builtins.str] alloweds: `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
-        :param builtins.str default: `(string: <optional>)` - The default node pool for jobs that don't define one.
-        :param Sequence[builtins.str] denieds: `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
+        :param Sequence[_builtins.str] alloweds: `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
+        :param _builtins.str default: `(string: <optional>)` - The default node pool for jobs that don't define one.
+        :param Sequence[_builtins.str] denieds: `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
         """
         if alloweds is not None:
             pulumi.set(__self__, "alloweds", alloweds)
@@ -1499,25 +2003,25 @@ class NamespaceNodePoolConfig(dict):
         if denieds is not None:
             pulumi.set(__self__, "denieds", denieds)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def alloweds(self) -> Optional[Sequence[builtins.str]]:
+    def alloweds(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
         """
         return pulumi.get(self, "alloweds")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def default(self) -> Optional[builtins.str]:
+    def default(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - The default node pool for jobs that don't define one.
         """
         return pulumi.get(self, "default")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def denieds(self) -> Optional[Sequence[builtins.str]]:
+    def denieds(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
         """
@@ -1546,10 +2050,10 @@ class NodePoolSchedulerConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 memory_oversubscription: Optional[builtins.str] = None,
-                 scheduler_algorithm: Optional[builtins.str] = None):
+                 memory_oversubscription: Optional[_builtins.str] = None,
+                 scheduler_algorithm: Optional[_builtins.str] = None):
         """
-        :param builtins.str memory_oversubscription: `(string)` - Whether or not memory
+        :param _builtins.str memory_oversubscription: `(string)` - Whether or not memory
                oversubscription is enabled in the node pool. Possible values are
                `"enabled"` or `"disabled"`. If not defined the global cluster
                configuration is used.
@@ -1557,7 +2061,7 @@ class NodePoolSchedulerConfig(dict):
                > This option differs from Nomad, where it's represented as a boolean, to
                allow distinguishing between memory oversubscription being disabled in the
                node pool and this property not being set.
-        :param builtins.str scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
+        :param _builtins.str scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
                pool. Possible values are `binpack` or `spread`. If not defined the global
                cluster configuration is used.
         """
@@ -1566,9 +2070,9 @@ class NodePoolSchedulerConfig(dict):
         if scheduler_algorithm is not None:
             pulumi.set(__self__, "scheduler_algorithm", scheduler_algorithm)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memoryOversubscription")
-    def memory_oversubscription(self) -> Optional[builtins.str]:
+    def memory_oversubscription(self) -> Optional[_builtins.str]:
         """
         `(string)` - Whether or not memory
         oversubscription is enabled in the node pool. Possible values are
@@ -1581,9 +2085,9 @@ class NodePoolSchedulerConfig(dict):
         """
         return pulumi.get(self, "memory_oversubscription")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="schedulerAlgorithm")
-    def scheduler_algorithm(self) -> Optional[builtins.str]:
+    def scheduler_algorithm(self) -> Optional[_builtins.str]:
         """
         `(string)` - The scheduler algorithm used in the node
         pool. Possible values are `binpack` or `spread`. If not defined the global
@@ -1612,10 +2116,10 @@ class QuoteSpecificationLimit(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 region: builtins.str,
+                 region: _builtins.str,
                  region_limit: 'outputs.QuoteSpecificationLimitRegionLimit'):
         """
-        :param builtins.str region: `(string: <required>)` - The region these limits should apply to.
+        :param _builtins.str region: `(string: <required>)` - The region these limits should apply to.
         :param 'QuoteSpecificationLimitRegionLimitArgs' region_limit: `(block: <required>)` - The limits to enforce. This block
                may only be specified once in the `limits` block. Its structure is
                documented below.
@@ -1623,15 +2127,15 @@ class QuoteSpecificationLimit(dict):
         pulumi.set(__self__, "region", region)
         pulumi.set(__self__, "region_limit", region_limit)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def region(self) -> builtins.str:
+    def region(self) -> _builtins.str:
         """
         `(string: <required>)` - The region these limits should apply to.
         """
         return pulumi.get(self, "region")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="regionLimit")
     def region_limit(self) -> 'outputs.QuoteSpecificationLimitRegionLimit':
         """
@@ -1662,12 +2166,12 @@ class QuoteSpecificationLimitRegionLimit(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 cpu: Optional[builtins.int] = None,
-                 memory_mb: Optional[builtins.int] = None):
+                 cpu: Optional[_builtins.int] = None,
+                 memory_mb: Optional[_builtins.int] = None):
         """
-        :param builtins.int cpu: `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
+        :param _builtins.int cpu: `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
                is treated as unlimited, and a negative value is treated as fully disallowed.
-        :param builtins.int memory_mb: `(int: 0)` - The amount of memory (in megabytes) to limit
+        :param _builtins.int memory_mb: `(int: 0)` - The amount of memory (in megabytes) to limit
                allocations to. A value of zero is treated as unlimited, and a negative value
                is treated as fully disallowed.
         """
@@ -1676,18 +2180,18 @@ class QuoteSpecificationLimitRegionLimit(dict):
         if memory_mb is not None:
             pulumi.set(__self__, "memory_mb", memory_mb)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def cpu(self) -> Optional[builtins.int]:
+    def cpu(self) -> Optional[_builtins.int]:
         """
         `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
         is treated as unlimited, and a negative value is treated as fully disallowed.
         """
         return pulumi.get(self, "cpu")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memoryMb")
-    def memory_mb(self) -> Optional[builtins.int]:
+    def memory_mb(self) -> Optional[_builtins.int]:
         """
         `(int: 0)` - The amount of memory (in megabytes) to limit
         allocations to. A value of zero is treated as unlimited, and a negative value
@@ -1718,25 +2222,25 @@ class VolumeCapability(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 access_mode: builtins.str,
-                 attachment_mode: builtins.str):
+                 access_mode: _builtins.str,
+                 attachment_mode: _builtins.str):
         """
-        :param builtins.str access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
+        :param _builtins.str access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
                - `single-node-reader-only`
                - `single-node-writer`
                - `multi-node-reader-only`
                - `multi-node-single-writer`
                - `multi-node-multi-writer`
-        :param builtins.str attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
+        :param _builtins.str attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
                - `block-device`
                - `file-system`
         """
         pulumi.set(__self__, "access_mode", access_mode)
         pulumi.set(__self__, "attachment_mode", attachment_mode)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessMode")
-    def access_mode(self) -> builtins.str:
+    def access_mode(self) -> _builtins.str:
         """
         `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
         - `single-node-reader-only`
@@ -1747,9 +2251,9 @@ class VolumeCapability(dict):
         """
         return pulumi.get(self, "access_mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="attachmentMode")
-    def attachment_mode(self) -> builtins.str:
+    def attachment_mode(self) -> _builtins.str:
         """
         `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
         - `block-device`
@@ -1780,28 +2284,28 @@ class VolumeMountOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 fs_type: Optional[builtins.str] = None,
-                 mount_flags: Optional[Sequence[builtins.str]] = None):
+                 fs_type: Optional[_builtins.str] = None,
+                 mount_flags: Optional[Sequence[_builtins.str]] = None):
         """
-        :param builtins.str fs_type: `(string: <optional>)` - The file system type.
-        :param Sequence[builtins.str] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
+        :param _builtins.str fs_type: `(string: <optional>)` - The file system type.
+        :param Sequence[_builtins.str] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
         """
         if fs_type is not None:
             pulumi.set(__self__, "fs_type", fs_type)
         if mount_flags is not None:
             pulumi.set(__self__, "mount_flags", mount_flags)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fsType")
-    def fs_type(self) -> Optional[builtins.str]:
+    def fs_type(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` - The file system type.
         """
         return pulumi.get(self, "fs_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="mountFlags")
-    def mount_flags(self) -> Optional[Sequence[builtins.str]]:
+    def mount_flags(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string: <optional>)` - The flags passed to `mount`.
         """
@@ -1811,9 +2315,9 @@ class VolumeMountOptions(dict):
 @pulumi.output_type
 class VolumeTopology(dict):
     def __init__(__self__, *,
-                 segments: Optional[Mapping[str, builtins.str]] = None):
+                 segments: Optional[Mapping[str, _builtins.str]] = None):
         """
-        :param Mapping[str, builtins.str] segments: `(map[string]string)` - Define the attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: `(map[string]string)` - Define the attributes for the topology request.
                
                In addition to the above arguments, the following attributes are exported and
                can be referenced:
@@ -1821,9 +2325,9 @@ class VolumeTopology(dict):
         if segments is not None:
             pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Optional[Mapping[str, builtins.str]]:
+    def segments(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         `(map[string]string)` - Define the attributes for the topology request.
 
@@ -1843,7 +2347,7 @@ class VolumeTopologyRequest(dict):
         if required is not None:
             pulumi.set(__self__, "required", required)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def required(self) -> Optional['outputs.VolumeTopologyRequestRequired']:
         """
@@ -1861,7 +2365,7 @@ class VolumeTopologyRequestRequired(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.VolumeTopologyRequestRequiredTopology']:
         """
@@ -1873,15 +2377,15 @@ class VolumeTopologyRequestRequired(dict):
 @pulumi.output_type
 class VolumeTopologyRequestRequiredTopology(dict):
     def __init__(__self__, *,
-                 segments: Mapping[str, builtins.str]):
+                 segments: Mapping[str, _builtins.str]):
         """
-        :param Mapping[str, builtins.str] segments: Define attributes for the topology request.
+        :param Mapping[str, _builtins.str] segments: Define attributes for the topology request.
         """
         pulumi.set(__self__, "segments", segments)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def segments(self) -> Mapping[str, builtins.str]:
+    def segments(self) -> Mapping[str, _builtins.str]:
         """
         Define attributes for the topology request.
         """
@@ -1891,26 +2395,26 @@ class VolumeTopologyRequestRequiredTopology(dict):
 @pulumi.output_type
 class GetAclPoliciesPolicyResult(dict):
     def __init__(__self__, *,
-                 description: builtins.str,
-                 name: builtins.str):
+                 description: _builtins.str,
+                 name: _builtins.str):
         """
-        :param builtins.str description: `(string)` - the description of the ACL Policy.
-        :param builtins.str name: `(string)` - the name of the ACL Policy.
+        :param _builtins.str description: `(string)` - the description of the ACL Policy.
+        :param _builtins.str name: `(string)` - the name of the ACL Policy.
         """
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> builtins.str:
+    def description(self) -> _builtins.str:
         """
         `(string)` - the description of the ACL Policy.
         """
         return pulumi.get(self, "description")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` - the name of the ACL Policy.
         """
@@ -1920,15 +2424,15 @@ class GetAclPoliciesPolicyResult(dict):
 @pulumi.output_type
 class GetAclRolePolicyResult(dict):
     def __init__(__self__, *,
-                 name: builtins.str):
+                 name: _builtins.str):
         """
-        :param builtins.str name: `(string)` - Unique name of the ACL role.
+        :param _builtins.str name: `(string)` - Unique name of the ACL role.
         """
         pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` - Unique name of the ACL role.
         """
@@ -1938,14 +2442,14 @@ class GetAclRolePolicyResult(dict):
 @pulumi.output_type
 class GetAclRolesAclRoleResult(dict):
     def __init__(__self__, *,
-                 description: builtins.str,
-                 id: builtins.str,
-                 name: builtins.str,
+                 description: _builtins.str,
+                 id: _builtins.str,
+                 name: _builtins.str,
                  policies: Sequence['outputs.GetAclRolesAclRolePolicyResult']):
         """
-        :param builtins.str description: `(string)` - The description of the ACL Role.
-        :param builtins.str id: `(string)` - The ACL Role unique identifier.
-        :param builtins.str name: `(string)` - Unique name of the ACL role.
+        :param _builtins.str description: `(string)` - The description of the ACL Role.
+        :param _builtins.str id: `(string)` - The ACL Role unique identifier.
+        :param _builtins.str name: `(string)` - Unique name of the ACL role.
         :param Sequence['GetAclRolesAclRolePolicyArgs'] policies: `(set)` - The policies applied to the role.
         """
         pulumi.set(__self__, "description", description)
@@ -1953,31 +2457,31 @@ class GetAclRolesAclRoleResult(dict):
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "policies", policies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> builtins.str:
+    def description(self) -> _builtins.str:
         """
         `(string)` - The description of the ACL Role.
         """
         return pulumi.get(self, "description")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> builtins.str:
+    def id(self) -> _builtins.str:
         """
         `(string)` - The ACL Role unique identifier.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` - Unique name of the ACL role.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def policies(self) -> Sequence['outputs.GetAclRolesAclRolePolicyResult']:
         """
@@ -1989,15 +2493,15 @@ class GetAclRolesAclRoleResult(dict):
 @pulumi.output_type
 class GetAclRolesAclRolePolicyResult(dict):
     def __init__(__self__, *,
-                 name: builtins.str):
+                 name: _builtins.str):
         """
-        :param builtins.str name: `(string)` - Unique name of the ACL role.
+        :param _builtins.str name: `(string)` - Unique name of the ACL role.
         """
         pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` - Unique name of the ACL role.
         """
@@ -2007,26 +2511,26 @@ class GetAclRolesAclRolePolicyResult(dict):
 @pulumi.output_type
 class GetAclTokenRoleResult(dict):
     def __init__(__self__, *,
-                 id: builtins.str,
-                 name: builtins.str):
+                 id: _builtins.str,
+                 name: _builtins.str):
         """
-        :param builtins.str id: The ID of the ACL role.
-        :param builtins.str name: `(string)` Non-sensitive identifier for this token.
+        :param _builtins.str id: The ID of the ACL role.
+        :param _builtins.str name: `(string)` Non-sensitive identifier for this token.
         """
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> builtins.str:
+    def id(self) -> _builtins.str:
         """
         The ID of the ACL role.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` Non-sensitive identifier for this token.
         """
@@ -2036,25 +2540,25 @@ class GetAclTokenRoleResult(dict):
 @pulumi.output_type
 class GetAclTokensAclTokenResult(dict):
     def __init__(__self__, *,
-                 accessor_id: builtins.str,
-                 create_time: builtins.str,
-                 expiration_time: builtins.str,
-                 global_: builtins.bool,
-                 name: builtins.str,
-                 policies: Sequence[builtins.str],
+                 accessor_id: _builtins.str,
+                 create_time: _builtins.str,
+                 expiration_time: _builtins.str,
+                 global_: _builtins.bool,
+                 name: _builtins.str,
+                 policies: Sequence[_builtins.str],
                  roles: Sequence['outputs.GetAclTokensAclTokenRoleResult'],
-                 type: builtins.str):
+                 type: _builtins.str):
         """
-        :param builtins.str accessor_id: `(TypeString)` Non-sensitive identifier for the token.
-        :param builtins.str create_time: `(string)` Date and time the token was created at.
-        :param builtins.str expiration_time: `(string)` - The timestamp after which the token is
+        :param _builtins.str accessor_id: `(TypeString)` Non-sensitive identifier for the token.
+        :param _builtins.str create_time: `(string)` Date and time the token was created at.
+        :param _builtins.str expiration_time: `(string)` - The timestamp after which the token is
                considered expired and eligible for destruction.
-        :param builtins.bool global_: `(bool)` Whether the token is replicated to all regions.
-        :param builtins.str name: `(TypeString)` The name of the token.
-        :param Sequence[builtins.str] policies: `(list of strings)` The list of policies attached to the token.
+        :param _builtins.bool global_: `(bool)` Whether the token is replicated to all regions.
+        :param _builtins.str name: `(TypeString)` The name of the token.
+        :param Sequence[_builtins.str] policies: `(list of strings)` The list of policies attached to the token.
         :param Sequence['GetAclTokensAclTokenRoleArgs'] roles: `(set: [])` - The list of roles attached to the token. Each entry has
                `name` and `id` attributes.
-        :param builtins.str type: `(TypeString)` The type of the token.
+        :param _builtins.str type: `(TypeString)` The type of the token.
         """
         pulumi.set(__self__, "accessor_id", accessor_id)
         pulumi.set(__self__, "create_time", create_time)
@@ -2065,56 +2569,56 @@ class GetAclTokensAclTokenResult(dict):
         pulumi.set(__self__, "roles", roles)
         pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessorId")
-    def accessor_id(self) -> builtins.str:
+    def accessor_id(self) -> _builtins.str:
         """
         `(TypeString)` Non-sensitive identifier for the token.
         """
         return pulumi.get(self, "accessor_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createTime")
-    def create_time(self) -> builtins.str:
+    def create_time(self) -> _builtins.str:
         """
         `(string)` Date and time the token was created at.
         """
         return pulumi.get(self, "create_time")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="expirationTime")
-    def expiration_time(self) -> builtins.str:
+    def expiration_time(self) -> _builtins.str:
         """
         `(string)` - The timestamp after which the token is
         considered expired and eligible for destruction.
         """
         return pulumi.get(self, "expiration_time")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="global")
-    def global_(self) -> builtins.bool:
+    def global_(self) -> _builtins.bool:
         """
         `(bool)` Whether the token is replicated to all regions.
         """
         return pulumi.get(self, "global_")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(TypeString)` The name of the token.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def policies(self) -> Sequence[builtins.str]:
+    def policies(self) -> Sequence[_builtins.str]:
         """
         `(list of strings)` The list of policies attached to the token.
         """
         return pulumi.get(self, "policies")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def roles(self) -> Sequence['outputs.GetAclTokensAclTokenRoleResult']:
         """
@@ -2123,9 +2627,9 @@ class GetAclTokensAclTokenResult(dict):
         """
         return pulumi.get(self, "roles")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         `(TypeString)` The type of the token.
         """
@@ -2135,26 +2639,26 @@ class GetAclTokensAclTokenResult(dict):
 @pulumi.output_type
 class GetAclTokensAclTokenRoleResult(dict):
     def __init__(__self__, *,
-                 id: builtins.str,
-                 name: builtins.str):
+                 id: _builtins.str,
+                 name: _builtins.str):
         """
-        :param builtins.str id: The ID of the ACL role.
-        :param builtins.str name: `(TypeString)` The name of the token.
+        :param _builtins.str id: The ID of the ACL role.
+        :param _builtins.str name: `(TypeString)` The name of the token.
         """
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> builtins.str:
+    def id(self) -> _builtins.str:
         """
         The ID of the ACL role.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(TypeString)` The name of the token.
         """
@@ -2164,46 +2668,46 @@ class GetAclTokensAclTokenRoleResult(dict):
 @pulumi.output_type
 class GetAllocationsAllocationResult(dict):
     def __init__(__self__, *,
-                 client_status: builtins.str,
-                 create_index: builtins.int,
-                 create_time: builtins.int,
-                 desired_status: builtins.str,
-                 eval_id: builtins.str,
-                 followup_eval_id: builtins.str,
-                 id: builtins.str,
-                 job_id: builtins.str,
-                 job_type: builtins.str,
-                 job_version: builtins.int,
-                 modify_index: builtins.int,
-                 modify_time: builtins.int,
-                 name: builtins.str,
-                 namespace: builtins.str,
-                 next_allocation: builtins.str,
-                 node_id: builtins.str,
-                 node_name: builtins.str,
-                 preempted_by_allocation: builtins.str,
-                 task_group: builtins.str):
-        """
-        :param builtins.str client_status: `(string)` - The current client status of the allocation.
-        :param builtins.int create_index: `(int)` - The Raft index in which the allocation was created.
-        :param builtins.int create_time: `(int)` - The timestamp of when the allocation was created.
-        :param builtins.str desired_status: `(string)` - The current desired status of the allocation.
-        :param builtins.str eval_id: `(string)` - The ID of the evaluation that generated the allocation.
-        :param builtins.str followup_eval_id: `(string)` - The ID of the evaluation that succeeds the allocation evaluation.
-        :param builtins.str id: `(string)` - The ID of the allocation.
-        :param builtins.str job_id: `(string)` - The ID of the job related to the allocation.
-        :param builtins.str job_type: `(string)` - The type of the job related to the allocation.
-        :param builtins.int job_version: `(int)` - The version of the job that generated the allocation.
-        :param builtins.int modify_index: `(int)` - The Raft index in which the allocation was last modified.
-        :param builtins.int modify_time: `(int)` - The timestamp of when the allocation was last modified.
-        :param builtins.str name: `(string)` - The name of the allocation.
-        :param builtins.str namespace: `(string: <optional>)` - Specifies the namespace to search for
+                 client_status: _builtins.str,
+                 create_index: _builtins.int,
+                 create_time: _builtins.int,
+                 desired_status: _builtins.str,
+                 eval_id: _builtins.str,
+                 followup_eval_id: _builtins.str,
+                 id: _builtins.str,
+                 job_id: _builtins.str,
+                 job_type: _builtins.str,
+                 job_version: _builtins.int,
+                 modify_index: _builtins.int,
+                 modify_time: _builtins.int,
+                 name: _builtins.str,
+                 namespace: _builtins.str,
+                 next_allocation: _builtins.str,
+                 node_id: _builtins.str,
+                 node_name: _builtins.str,
+                 preempted_by_allocation: _builtins.str,
+                 task_group: _builtins.str):
+        """
+        :param _builtins.str client_status: `(string)` - The current client status of the allocation.
+        :param _builtins.int create_index: `(int)` - The Raft index in which the allocation was created.
+        :param _builtins.int create_time: `(int)` - The timestamp of when the allocation was created.
+        :param _builtins.str desired_status: `(string)` - The current desired status of the allocation.
+        :param _builtins.str eval_id: `(string)` - The ID of the evaluation that generated the allocation.
+        :param _builtins.str followup_eval_id: `(string)` - The ID of the evaluation that succeeds the allocation evaluation.
+        :param _builtins.str id: `(string)` - The ID of the allocation.
+        :param _builtins.str job_id: `(string)` - The ID of the job related to the allocation.
+        :param _builtins.str job_type: `(string)` - The type of the job related to the allocation.
+        :param _builtins.int job_version: `(int)` - The version of the job that generated the allocation.
+        :param _builtins.int modify_index: `(int)` - The Raft index in which the allocation was last modified.
+        :param _builtins.int modify_time: `(int)` - The timestamp of when the allocation was last modified.
+        :param _builtins.str name: `(string)` - The name of the allocation.
+        :param _builtins.str namespace: `(string: <optional>)` - Specifies the namespace to search for
                allocations in.
-        :param builtins.str next_allocation: `(string)` - The ID of the allocation that succeeds the allocation.
-        :param builtins.str node_id: `(string)` - The ID of the node to which the allocation was scheduled.
-        :param builtins.str node_name: `(string)` - The ID of the node to which the allocation was scheduled.
-        :param builtins.str preempted_by_allocation: `(string)` - The ID of the allocation that preempted the allocation.
-        :param builtins.str task_group: `(string)` - The job task group related to the allocation.
+        :param _builtins.str next_allocation: `(string)` - The ID of the allocation that succeeds the allocation.
+        :param _builtins.str node_id: `(string)` - The ID of the node to which the allocation was scheduled.
+        :param _builtins.str node_name: `(string)` - The ID of the node to which the allocation was scheduled.
+        :param _builtins.str preempted_by_allocation: `(string)` - The ID of the allocation that preempted the allocation.
+        :param _builtins.str task_group: `(string)` - The job task group related to the allocation.
         """
         pulumi.set(__self__, "client_status", client_status)
         pulumi.set(__self__, "create_index", create_index)
@@ -2225,194 +2729,267 @@ class GetAllocationsAllocationResult(dict):
         pulumi.set(__self__, "preempted_by_allocation", preempted_by_allocation)
         pulumi.set(__self__, "task_group", task_group)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="clientStatus")
-    def client_status(self) -> builtins.str:
+    def client_status(self) -> _builtins.str:
         """
         `(string)` - The current client status of the allocation.
         """
         return pulumi.get(self, "client_status")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createIndex")
-    def create_index(self) -> builtins.int:
+    def create_index(self) -> _builtins.int:
         """
         `(int)` - The Raft index in which the allocation was created.
         """
         return pulumi.get(self, "create_index")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createTime")
-    def create_time(self) -> builtins.int:
+    def create_time(self) -> _builtins.int:
         """
         `(int)` - The timestamp of when the allocation was created.
         """
         return pulumi.get(self, "create_time")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="desiredStatus")
-    def desired_status(self) -> builtins.str:
+    def desired_status(self) -> _builtins.str:
         """
         `(string)` - The current desired status of the allocation.
         """
         return pulumi.get(self, "desired_status")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="evalId")
-    def eval_id(self) -> builtins.str:
+    def eval_id(self) -> _builtins.str:
         """
         `(string)` - The ID of the evaluation that generated the allocation.
         """
         return pulumi.get(self, "eval_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="followupEvalId")
-    def followup_eval_id(self) -> builtins.str:
+    def followup_eval_id(self) -> _builtins.str:
         """
         `(string)` - The ID of the evaluation that succeeds the allocation evaluation.
         """
         return pulumi.get(self, "followup_eval_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> builtins.str:
+    def id(self) -> _builtins.str:
         """
         `(string)` - The ID of the allocation.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="jobId")
-    def job_id(self) -> builtins.str:
+    def job_id(self) -> _builtins.str:
         """
         `(string)` - The ID of the job related to the allocation.
         """
         return pulumi.get(self, "job_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="jobType")
-    def job_type(self) -> builtins.str:
+    def job_type(self) -> _builtins.str:
         """
         `(string)` - The type of the job related to the allocation.
         """
         return pulumi.get(self, "job_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="jobVersion")
-    def job_version(self) -> builtins.int:
+    def job_version(self) -> _builtins.int:
         """
         `(int)` - The version of the job that generated the allocation.
         """
         return pulumi.get(self, "job_version")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="modifyIndex")
-    def modify_index(self) -> builtins.int:
+    def modify_index(self) -> _builtins.int:
         """
         `(int)` - The Raft index in which the allocation was last modified.
         """
         return pulumi.get(self, "modify_index")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="modifyTime")
-    def modify_time(self) -> builtins.int:
+    def modify_time(self) -> _builtins.int:
         """
         `(int)` - The timestamp of when the allocation was last modified.
         """
         return pulumi.get(self, "modify_time")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` - The name of the allocation.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def namespace(self) -> builtins.str:
+    def namespace(self) -> _builtins.str:
         """
         `(string: <optional>)` - Specifies the namespace to search for
         allocations in.
         """
         return pulumi.get(self, "namespace")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="nextAllocation")
-    def next_allocation(self) -> builtins.str:
+    def next_allocation(self) -> _builtins.str:
         """
         `(string)` - The ID of the allocation that succeeds the allocation.
         """
         return pulumi.get(self, "next_allocation")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="nodeId")
-    def node_id(self) -> builtins.str:
+    def node_id(self) -> _builtins.str:
         """
         `(string)` - The ID of the node to which the allocation was scheduled.
         """
         return pulumi.get(self, "node_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="nodeName")
-    def node_name(self) -> builtins.str:
+    def node_name(self) -> _builtins.str:
         """
         `(string)` - The ID of the node to which the allocation was scheduled.
         """
         return pulumi.get(self, "node_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="preemptedByAllocation")
-    def preempted_by_allocation(self) -> builtins.str:
+    def preempted_by_allocation(self) -> _builtins.str:
         """
         `(string)` - The ID of the allocation that preempted the allocation.
         """
         return pulumi.get(self, "preempted_by_allocation")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="taskGroup")
-    def task_group(self) -> builtins.str:
+    def task_group(self) -> _builtins.str:
         """
         `(string)` - The job task group related to the allocation.
         """
         return pulumi.get(self, "task_group")
 
 
+@pulumi.output_type
+class GetDynamicHostVolumeCapabilityResult(dict):
+    def __init__(__self__, *,
+                 access_mode: _builtins.str,
+                 attachment_mode: _builtins.str):
+        """
+        :param _builtins.str access_mode: `(string)` - How the volume can be mounted by
+               allocations. Refer to the [`access_mode`][] documentation for details.
+        :param _builtins.str attachment_mode: `(string)` - The storage API that will be used by the
+               volume. Refer to the [`attachment_mode`][] documentation.
+        """
+        pulumi.set(__self__, "access_mode", access_mode)
+        pulumi.set(__self__, "attachment_mode", attachment_mode)
+
+    @_builtins.property
+    @pulumi.getter(name="accessMode")
+    def access_mode(self) -> _builtins.str:
+        """
+        `(string)` - How the volume can be mounted by
+        allocations. Refer to the [`access_mode`][] documentation for details.
+        """
+        return pulumi.get(self, "access_mode")
+
+    @_builtins.property
+    @pulumi.getter(name="attachmentMode")
+    def attachment_mode(self) -> _builtins.str:
+        """
+        `(string)` - The storage API that will be used by the
+        volume. Refer to the [`attachment_mode`][] documentation.
+        """
+        return pulumi.get(self, "attachment_mode")
+
+
+@pulumi.output_type
+class GetDynamicHostVolumeConstraintResult(dict):
+    def __init__(__self__, *,
+                 attribute: _builtins.str,
+                 operator: _builtins.str,
+                 value: _builtins.str):
+        """
+        :param _builtins.str attribute: `(string)` - The [node attribute][] to check for the constraint.
+        :param _builtins.str operator: `(string)`- The operator to use in the comparison.
+        :param _builtins.str value: `(string)` - The value of the attribute to compare against.
+        """
+        pulumi.set(__self__, "attribute", attribute)
+        pulumi.set(__self__, "operator", operator)
+        pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def attribute(self) -> _builtins.str:
+        """
+        `(string)` - The [node attribute][] to check for the constraint.
+        """
+        return pulumi.get(self, "attribute")
+
+    @_builtins.property
+    @pulumi.getter
+    def operator(self) -> _builtins.str:
+        """
+        `(string)`- The operator to use in the comparison.
+        """
+        return pulumi.get(self, "operator")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> _builtins.str:
+        """
+        `(string)` - The value of the attribute to compare against.
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class GetJobConstraintResult(dict):
     def __init__(__self__, *,
-                 ltarget: builtins.str,
-                 operand: builtins.str,
-                 rtarget: builtins.str):
+                 ltarget: _builtins.str,
+                 operand: _builtins.str,
+                 rtarget: _builtins.str):
         """
-        :param builtins.str ltarget: `(string)` Attribute being constrained.
-        :param builtins.str operand: `(string)` Operator used to compare the attribute to the constraint.
-        :param builtins.str rtarget: `(string)` Constraint value.
+        :param _builtins.str ltarget: `(string)` Attribute being constrained.
+        :param _builtins.str operand: `(string)` Operator used to compare the attribute to the constraint.
+        :param _builtins.str rtarget: `(string)` Constraint value.
         """
         pulumi.set(__self__, "ltarget", ltarget)
         pulumi.set(__self__, "operand", operand)
         pulumi.set(__self__, "rtarget", rtarget)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def ltarget(self) -> builtins.str:
+    def ltarget(self) -> _builtins.str:
         """
         `(string)` Attribute being constrained.
         """
         return pulumi.get(self, "ltarget")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def operand(self) -> builtins.str:
+    def operand(self) -> _builtins.str:
         """
         `(string)` Operator used to compare the attribute to the constraint.
         """
         return pulumi.get(self, "operand")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def rtarget(self) -> builtins.str:
+    def rtarget(self) -> _builtins.str:
         """
         `(string)` Constraint value.
         """
@@ -2422,17 +2999,17 @@ class GetJobConstraintResult(dict):
 @pulumi.output_type
 class GetJobPeriodicConfigResult(dict):
     def __init__(__self__, *,
-                 enabled: builtins.bool,
-                 prohibit_overlap: builtins.bool,
-                 spec: builtins.str,
-                 spec_type: builtins.str,
-                 timezone: builtins.str):
+                 enabled: _builtins.bool,
+                 prohibit_overlap: _builtins.bool,
+                 spec: _builtins.str,
+                 spec_type: _builtins.str,
+                 timezone: _builtins.str):
         """
-        :param builtins.bool enabled: `(boolean)` If periodic scheduling is enabled for the specified job.
-        :param builtins.bool prohibit_overlap: `(boolean)`  If the specified job should wait until previous instances of the job have completed.
-        :param builtins.str spec: `(string)`
-        :param builtins.str spec_type: `(string)`
-        :param builtins.str timezone: `(string)` Time zone to evaluate the next launch interval against.
+        :param _builtins.bool enabled: `(boolean)` If periodic scheduling is enabled for the specified job.
+        :param _builtins.bool prohibit_overlap: `(boolean)`  If the specified job should wait until previous instances of the job have completed.
+        :param _builtins.str spec: `(string)`
+        :param _builtins.str spec_type: `(string)`
+        :param _builtins.str timezone: `(string)` Time zone to evaluate the next launch interval against.
         """
         pulumi.set(__self__, "enabled", enabled)
         pulumi.set(__self__, "prohibit_overlap", prohibit_overlap)
@@ -2440,41 +3017,41 @@ class GetJobPeriodicConfigResult(dict):
         pulumi.set(__self__, "spec_type", spec_type)
         pulumi.set(__self__, "timezone", timezone)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def enabled(self) -> builtins.bool:
+    def enabled(self) -> _builtins.bool:
         """
         `(boolean)` If periodic scheduling is enabled for the specified job.
         """
         return pulumi.get(self, "enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="prohibitOverlap")
-    def prohibit_overlap(self) -> builtins.bool:
+    def prohibit_overlap(self) -> _builtins.bool:
         """
         `(boolean)`  If the specified job should wait until previous instances of the job have completed.
         """
         return pulumi.get(self, "prohibit_overlap")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def spec(self) -> builtins.str:
+    def spec(self) -> _builtins.str:
         """
         `(string)`
         """
         return pulumi.get(self, "spec")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="specType")
-    def spec_type(self) -> builtins.str:
+    def spec_type(self) -> _builtins.str:
         """
         `(string)`
         """
         return pulumi.get(self, "spec_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def timezone(self) -> builtins.str:
+    def timezone(self) -> _builtins.str:
         """
         `(string)` Time zone to evaluate the next launch interval against.
         """
@@ -2484,13 +3061,13 @@ class GetJobPeriodicConfigResult(dict):
 @pulumi.output_type
 class GetJobTaskGroupResult(dict):
     def __init__(__self__, *,
-                 count: builtins.int,
-                 meta: Mapping[str, builtins.str],
-                 name: builtins.str,
+                 count: _builtins.int,
+                 meta: Mapping[str, _builtins.str],
+                 name: _builtins.str,
                  tasks: Sequence['outputs.GetJobTaskGroupTaskResult'],
                  volumes: Sequence['outputs.GetJobTaskGroupVolumeResult']):
         """
-        :param builtins.str name: `(string)` Name of the job.
+        :param _builtins.str name: `(string)` Name of the job.
         """
         pulumi.set(__self__, "count", count)
         pulumi.set(__self__, "meta", meta)
@@ -2498,30 +3075,30 @@ class GetJobTaskGroupResult(dict):
         pulumi.set(__self__, "tasks", tasks)
         pulumi.set(__self__, "volumes", volumes)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def count(self) -> builtins.int:
+    def count(self) -> _builtins.int:
         return pulumi.get(self, "count")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def meta(self) -> Mapping[str, builtins.str]:
+    def meta(self) -> Mapping[str, _builtins.str]:
         return pulumi.get(self, "meta")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` Name of the job.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def tasks(self) -> Sequence['outputs.GetJobTaskGroupTaskResult']:
         return pulumi.get(self, "tasks")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def volumes(self) -> Sequence['outputs.GetJobTaskGroupVolumeResult']:
         return pulumi.get(self, "volumes")
@@ -2530,37 +3107,37 @@ class GetJobTaskGroupResult(dict):
 @pulumi.output_type
 class GetJobTaskGroupTaskResult(dict):
     def __init__(__self__, *,
-                 driver: builtins.str,
-                 meta: Mapping[str, builtins.str],
-                 name: builtins.str,
+                 driver: _builtins.str,
+                 meta: Mapping[str, _builtins.str],
+                 name: _builtins.str,
                  volume_mounts: Sequence['outputs.GetJobTaskGroupTaskVolumeMountResult']):
         """
-        :param builtins.str name: `(string)` Name of the job.
+        :param _builtins.str name: `(string)` Name of the job.
         """
         pulumi.set(__self__, "driver", driver)
         pulumi.set(__self__, "meta", meta)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "volume_mounts", volume_mounts)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def driver(self) -> builtins.str:
+    def driver(self) -> _builtins.str:
         return pulumi.get(self, "driver")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def meta(self) -> Mapping[str, builtins.str]:
+    def meta(self) -> Mapping[str, _builtins.str]:
         return pulumi.get(self, "meta")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` Name of the job.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeMounts")
     def volume_mounts(self) -> Sequence['outputs.GetJobTaskGroupTaskVolumeMountResult']:
         return pulumi.get(self, "volume_mounts")
@@ -2569,66 +3146,66 @@ class GetJobTaskGroupTaskResult(dict):
 @pulumi.output_type
 class GetJobTaskGroupTaskVolumeMountResult(dict):
     def __init__(__self__, *,
-                 destination: builtins.str,
-                 read_only: builtins.bool,
-                 volume: builtins.str):
+                 destination: _builtins.str,
+                 read_only: _builtins.bool,
+                 volume: _builtins.str):
         pulumi.set(__self__, "destination", destination)
         pulumi.set(__self__, "read_only", read_only)
         pulumi.set(__self__, "volume", volume)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def destination(self) -> builtins.str:
+    def destination(self) -> _builtins.str:
         return pulumi.get(self, "destination")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="readOnly")
-    def read_only(self) -> builtins.bool:
+    def read_only(self) -> _builtins.bool:
         return pulumi.get(self, "read_only")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def volume(self) -> builtins.str:
+    def volume(self) -> _builtins.str:
         return pulumi.get(self, "volume")
 
 
 @pulumi.output_type
 class GetJobTaskGroupVolumeResult(dict):
     def __init__(__self__, *,
-                 name: builtins.str,
-                 read_only: builtins.bool,
-                 source: builtins.str,
-                 type: builtins.str):
+                 name: _builtins.str,
+                 read_only: _builtins.bool,
+                 source: _builtins.str,
+                 type: _builtins.str):
         """
-        :param builtins.str name: `(string)` Name of the job.
-        :param builtins.str type: `(string)` Scheduler type used during job creation.
+        :param _builtins.str name: `(string)` Name of the job.
+        :param _builtins.str type: `(string)` Scheduler type used during job creation.
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "read_only", read_only)
         pulumi.set(__self__, "source", source)
         pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` Name of the job.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="readOnly")
-    def read_only(self) -> builtins.bool:
+    def read_only(self) -> _builtins.bool:
         return pulumi.get(self, "read_only")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def source(self) -> builtins.str:
+    def source(self) -> _builtins.str:
         return pulumi.get(self, "source")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         `(string)` Scheduler type used during job creation.
         """
@@ -2638,19 +3215,19 @@ class GetJobTaskGroupVolumeResult(dict):
 @pulumi.output_type
 class GetJwksKeyResult(dict):
     def __init__(__self__, *,
-                 algorithm: builtins.str,
-                 exponent: builtins.str,
-                 key_id: builtins.str,
-                 key_type: builtins.str,
-                 key_use: builtins.str,
-                 modulus: builtins.str):
+                 algorithm: _builtins.str,
+                 exponent: _builtins.str,
+                 key_id: _builtins.str,
+                 key_type: _builtins.str,
+                 key_use: _builtins.str,
+                 modulus: _builtins.str):
         """
-        :param builtins.str algorithm: `(string)` - JWK field `alg`
-        :param builtins.str exponent: `(string)` - JWK field `e`
-        :param builtins.str key_id: `(string)` - JWK field `kid`
-        :param builtins.str key_type: `(string)` - JWK field `kty`
-        :param builtins.str key_use: `(string)` - JWK field `use`
-        :param builtins.str modulus: `(string)` - JWK field `n`
+        :param _builtins.str algorithm: `(string)` - JWK field `alg`
+        :param _builtins.str exponent: `(string)` - JWK field `e`
+        :param _builtins.str key_id: `(string)` - JWK field `kid`
+        :param _builtins.str key_type: `(string)` - JWK field `kty`
+        :param _builtins.str key_use: `(string)` - JWK field `use`
+        :param _builtins.str modulus: `(string)` - JWK field `n`
         """
         pulumi.set(__self__, "algorithm", algorithm)
         pulumi.set(__self__, "exponent", exponent)
@@ -2659,49 +3236,49 @@ class GetJwksKeyResult(dict):
         pulumi.set(__self__, "key_use", key_use)
         pulumi.set(__self__, "modulus", modulus)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def algorithm(self) -> builtins.str:
+    def algorithm(self) -> _builtins.str:
         """
         `(string)` - JWK field `alg`
         """
         return pulumi.get(self, "algorithm")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def exponent(self) -> builtins.str:
+    def exponent(self) -> _builtins.str:
         """
         `(string)` - JWK field `e`
         """
         return pulumi.get(self, "exponent")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyId")
-    def key_id(self) -> builtins.str:
+    def key_id(self) -> _builtins.str:
         """
         `(string)` - JWK field `kid`
         """
         return pulumi.get(self, "key_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyType")
-    def key_type(self) -> builtins.str:
+    def key_type(self) -> _builtins.str:
         """
         `(string)` - JWK field `kty`
         """
         return pulumi.get(self, "key_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyUse")
-    def key_use(self) -> builtins.str:
+    def key_use(self) -> _builtins.str:
         """
         `(string)` - JWK field `use`
         """
         return pulumi.get(self, "key_use")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def modulus(self) -> builtins.str:
+    def modulus(self) -> _builtins.str:
         """
         `(string)` - JWK field `n`
         """
@@ -2711,28 +3288,28 @@ class GetJwksKeyResult(dict):
 @pulumi.output_type
 class GetNamespaceCapabilityResult(dict):
     def __init__(__self__, *,
-                 disabled_task_drivers: Optional[Sequence[builtins.str]] = None,
-                 enabled_task_drivers: Optional[Sequence[builtins.str]] = None):
+                 disabled_task_drivers: Optional[Sequence[_builtins.str]] = None,
+                 enabled_task_drivers: Optional[Sequence[_builtins.str]] = None):
         """
-        :param Sequence[builtins.str] disabled_task_drivers: `([]string)` - Task drivers disabled for the namespace.
-        :param Sequence[builtins.str] enabled_task_drivers: `([]string)` - Task drivers enabled for the namespace.
+        :param Sequence[_builtins.str] disabled_task_drivers: `([]string)` - Task drivers disabled for the namespace.
+        :param Sequence[_builtins.str] enabled_task_drivers: `([]string)` - Task drivers enabled for the namespace.
         """
         if disabled_task_drivers is not None:
             pulumi.set(__self__, "disabled_task_drivers", disabled_task_drivers)
         if enabled_task_drivers is not None:
             pulumi.set(__self__, "enabled_task_drivers", enabled_task_drivers)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="disabledTaskDrivers")
-    def disabled_task_drivers(self) -> Optional[Sequence[builtins.str]]:
+    def disabled_task_drivers(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string)` - Task drivers disabled for the namespace.
         """
         return pulumi.get(self, "disabled_task_drivers")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="enabledTaskDrivers")
-    def enabled_task_drivers(self) -> Optional[Sequence[builtins.str]]:
+    def enabled_task_drivers(self) -> Optional[Sequence[_builtins.str]]:
         """
         `([]string)` - Task drivers enabled for the namespace.
         """
@@ -2742,47 +3319,47 @@ class GetNamespaceCapabilityResult(dict):
 @pulumi.output_type
 class GetNamespaceNodePoolConfigResult(dict):
     def __init__(__self__, *,
-                 alloweds: Sequence[builtins.str],
-                 default: builtins.str,
-                 denieds: Sequence[builtins.str]):
+                 alloweds: Sequence[_builtins.str],
+                 default: _builtins.str,
+                 denieds: Sequence[_builtins.str]):
         pulumi.set(__self__, "alloweds", alloweds)
         pulumi.set(__self__, "default", default)
         pulumi.set(__self__, "denieds", denieds)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def alloweds(self) -> Sequence[builtins.str]:
+    def alloweds(self) -> Sequence[_builtins.str]:
         return pulumi.get(self, "alloweds")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def default(self) -> builtins.str:
+    def default(self) -> _builtins.str:
         return pulumi.get(self, "default")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def denieds(self) -> Sequence[builtins.str]:
+    def denieds(self) -> Sequence[_builtins.str]:
         return pulumi.get(self, "denieds")
 
 
 @pulumi.output_type
 class GetNodePoolSchedulerConfigResult(dict):
     def __init__(__self__, *,
-                 memory_oversubscription: builtins.str,
-                 scheduler_algorithm: builtins.str):
+                 memory_oversubscription: _builtins.str,
+                 scheduler_algorithm: _builtins.str):
         """
-        :param builtins.str memory_oversubscription: `(string)` - Whether or not memory
+        :param _builtins.str memory_oversubscription: `(string)` - Whether or not memory
                oversubscription is enabled in the node pool. If empty or not defined the
                global cluster configuration is used.
-        :param builtins.str scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
+        :param _builtins.str scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
                pool. If empty or not defined the global cluster configuration is used.
         """
         pulumi.set(__self__, "memory_oversubscription", memory_oversubscription)
         pulumi.set(__self__, "scheduler_algorithm", scheduler_algorithm)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memoryOversubscription")
-    def memory_oversubscription(self) -> builtins.str:
+    def memory_oversubscription(self) -> _builtins.str:
         """
         `(string)` - Whether or not memory
         oversubscription is enabled in the node pool. If empty or not defined the
@@ -2790,9 +3367,9 @@ class GetNodePoolSchedulerConfigResult(dict):
         """
         return pulumi.get(self, "memory_oversubscription")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="schedulerAlgorithm")
-    def scheduler_algorithm(self) -> builtins.str:
+    def scheduler_algorithm(self) -> _builtins.str:
         """
         `(string)` - The scheduler algorithm used in the node
         pool. If empty or not defined the global cluster configuration is used.
@@ -2803,15 +3380,15 @@ class GetNodePoolSchedulerConfigResult(dict):
 @pulumi.output_type
 class GetNodePoolsNodePoolResult(dict):
     def __init__(__self__, *,
-                 description: builtins.str,
-                 meta: Mapping[str, builtins.str],
-                 name: builtins.str,
+                 description: _builtins.str,
+                 meta: Mapping[str, _builtins.str],
+                 name: _builtins.str,
                  scheduler_configs: Sequence['outputs.GetNodePoolsNodePoolSchedulerConfigResult']):
         """
-        :param builtins.str description: `(string)` - The description of the node pool.
-        :param Mapping[str, builtins.str] meta: `(map[string]string)` - Arbitrary KV metadata associated with the
+        :param _builtins.str description: `(string)` - The description of the node pool.
+        :param Mapping[str, _builtins.str] meta: `(map[string]string)` - Arbitrary KV metadata associated with the
                node pool.
-        :param builtins.str name: `(string)` - The name of the node pool.
+        :param _builtins.str name: `(string)` - The name of the node pool.
         :param Sequence['GetNodePoolsNodePoolSchedulerConfigArgs'] scheduler_configs: `(block)` - Scheduler configuration for the node pool.
         """
         pulumi.set(__self__, "description", description)
@@ -2819,32 +3396,32 @@ class GetNodePoolsNodePoolResult(dict):
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "scheduler_configs", scheduler_configs)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> builtins.str:
+    def description(self) -> _builtins.str:
         """
         `(string)` - The description of the node pool.
         """
         return pulumi.get(self, "description")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def meta(self) -> Mapping[str, builtins.str]:
+    def meta(self) -> Mapping[str, _builtins.str]:
         """
         `(map[string]string)` - Arbitrary KV metadata associated with the
         node pool.
         """
         return pulumi.get(self, "meta")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         `(string)` - The name of the node pool.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="schedulerConfigs")
     def scheduler_configs(self) -> Sequence['outputs.GetNodePoolsNodePoolSchedulerConfigResult']:
         """
@@ -2856,21 +3433,21 @@ class GetNodePoolsNodePoolResult(dict):
 @pulumi.output_type
 class GetNodePoolsNodePoolSchedulerConfigResult(dict):
     def __init__(__self__, *,
-                 memory_oversubscription: builtins.str,
-                 scheduler_algorithm: builtins.str):
+                 memory_oversubscription: _builtins.str,
+                 scheduler_algorithm: _builtins.str):
         """
-        :param builtins.str memory_oversubscription: `(string)` - Whether or not memory
+        :param _builtins.str memory_oversubscription: `(string)` - Whether or not memory
                oversubscription is enabled in the node pool. If empty or not defined the
                global cluster configuration is used.
-        :param builtins.str scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
+        :param _builtins.str scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
                pool. If empty or not defined the global cluster configuration is used.
         """
         pulumi.set(__self__, "memory_oversubscription", memory_oversubscription)
         pulumi.set(__self__, "scheduler_algorithm", scheduler_algorithm)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memoryOversubscription")
-    def memory_oversubscription(self) -> builtins.str:
+    def memory_oversubscription(self) -> _builtins.str:
         """
         `(string)` - Whether or not memory
         oversubscription is enabled in the node pool. If empty or not defined the
@@ -2878,9 +3455,9 @@ class GetNodePoolsNodePoolSchedulerConfigResult(dict):
         """
         return pulumi.get(self, "memory_oversubscription")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="schedulerAlgorithm")
-    def scheduler_algorithm(self) -> builtins.str:
+    def scheduler_algorithm(self) -> _builtins.str:
         """
         `(string)` - The scheduler algorithm used in the node
         pool. If empty or not defined the global cluster configuration is used.
@@ -2891,74 +3468,74 @@ class GetNodePoolsNodePoolSchedulerConfigResult(dict):
 @pulumi.output_type
 class GetPluginNodeResult(dict):
     def __init__(__self__, *,
-                 healthy: builtins.bool,
-                 healthy_description: builtins.str,
-                 name: builtins.str):
+                 healthy: _builtins.bool,
+                 healthy_description: _builtins.str,
+                 name: _builtins.str):
         pulumi.set(__self__, "healthy", healthy)
         pulumi.set(__self__, "healthy_description", healthy_description)
         pulumi.set(__self__, "name", name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def healthy(self) -> builtins.bool:
+    def healthy(self) -> _builtins.bool:
         return pulumi.get(self, "healthy")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="healthyDescription")
-    def healthy_description(self) -> builtins.str:
+    def healthy_description(self) -> _builtins.str:
         return pulumi.get(self, "healthy_description")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         return pulumi.get(self, "name")
 
 
 @pulumi.output_type
 class GetScalingPoliciesPolicyResult(dict):
     def __init__(__self__, *,
-                 enabled: builtins.bool,
-                 id: builtins.str,
-                 target: Mapping[str, builtins.str],
-                 type: builtins.str):
+                 enabled: _builtins.bool,
+                 id: _builtins.str,
+                 target: Mapping[str, _builtins.str],
+                 type: _builtins.str):
         """
-        :param builtins.bool enabled: `(boolean)` - Whether or not the scaling policy is enabled.
-        :param builtins.str id: `(string)` - The scaling policy ID.
-        :param Mapping[str, builtins.str] target: `(map[string]string)` - The scaling policy target.
-        :param builtins.str type: `(string)` - An optional string to filter scaling policies based on policy type. If not provided, policies of all types are returned.
+        :param _builtins.bool enabled: `(boolean)` - Whether or not the scaling policy is enabled.
+        :param _builtins.str id: `(string)` - The scaling policy ID.
+        :param Mapping[str, _builtins.str] target: `(map[string]string)` - The scaling policy target.
+        :param _builtins.str type: `(string)` - An optional string to filter scaling policies based on policy type. If not provided, policies of all types are returned.
         """
         pulumi.set(__self__, "enabled", enabled)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "target", target)
         pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def enabled(self) -> builtins.bool:
+    def enabled(self) -> _builtins.bool:
         """
         `(boolean)` - Whether or not the scaling policy is enabled.
         """
         return pulumi.get(self, "enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> builtins.str:
+    def id(self) -> _builtins.str:
         """
         `(string)` - The scaling policy ID.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def target(self) -> Mapping[str, builtins.str]:
+    def target(self) -> Mapping[str, _builtins.str]:
         """
         `(map[string]string)` - The scaling policy target.
         """
         return pulumi.get(self, "target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         `(string)` - An optional string to filter scaling policies based on policy type. If not provided, policies of all types are returned.
         """