pulumi-nomad 2.6.0a1753337858__py3-none-any.whl → 2.6.0a1754461399__py3-none-any.whl

pulumi_nomad/outputs.py

@@ -2,8 +2,7 @@
 # *** WARNING: this file was generated by pulumi-language-python. ***
 # *** Do not edit by hand unless you're certain you know what you are doing! ***
 
-import builtins
-import copy
+import builtins as _builtins
 import warnings
 import sys
 import pulumi
@@ -151,71 +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,
+                 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
+                 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 '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
+        :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 builtins.bool oidc_enable_pkce: `(bool: false)` - When set to `true`, Nomad will include
+        :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
+        :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.
+        :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)
@@ -260,113 +259,113 @@ class AclAuthMethodConfig(dict):
         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']:
         """
@@ -377,27 +376,27 @@ class AclAuthMethodConfig(dict):
         """
         return pulumi.get(self, "oidc_client_assertion")
 
-    @property
+    @_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`.
@@ -406,18 +405,18 @@ 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]:
+    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,
@@ -425,26 +424,26 @@ class AclAuthMethodConfig(dict):
         """
         return pulumi.get(self, "oidc_enable_pkce")
 
-    @property
+    @_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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="verboseLogging")
-    def verbose_logging(self) -> Optional[builtins.bool]:
+    def verbose_logging(self) -> Optional[_builtins.bool]:
         """
         Enable OIDC verbose logging on the Nomad server.
         """
@@ -477,24 +476,24 @@ class AclAuthMethodConfigOidcClientAssertion(dict):
         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,
+                 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
+        :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.
+        :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,
+        :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.
+        :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
@@ -512,9 +511,9 @@ class AclAuthMethodConfigOidcClientAssertion(dict):
         if private_key is not None:
             pulumi.set(__self__, "private_key", private_key)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keySource")
-    def key_source(self) -> builtins.str:
+    def key_source(self) -> _builtins.str:
         """
         `(string: <required>)` - Specifies where to get the private
         key to sign the JWT.
@@ -525,18 +524,18 @@ class AclAuthMethodConfigOidcClientAssertion(dict):
         """
         return pulumi.get(self, "key_source")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def audiences(self) -> Optional[Sequence[builtins.str]]:
+    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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="extraHeaders")
-    def extra_headers(self) -> Optional[Mapping[str, builtins.str]]:
+    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;
@@ -544,9 +543,9 @@ class AclAuthMethodConfigOidcClientAssertion(dict):
         """
         return pulumi.get(self, "extra_headers")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyAlgorithm")
-    def key_algorithm(self) -> Optional[builtins.str]:
+    def key_algorithm(self) -> Optional[_builtins.str]:
         """
         `(string: <optional>)` is the key's algorithm.
         Its default values are based on the `key_source`:
@@ -556,7 +555,7 @@ class AclAuthMethodConfigOidcClientAssertion(dict):
         """
         return pulumi.get(self, "key_algorithm")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="privateKey")
     def private_key(self) -> Optional['outputs.AclAuthMethodConfigOidcClientAssertionPrivateKey']:
         """
@@ -596,35 +595,35 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKey(dict):
         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):
+                 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.
+        :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
+        :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
+        :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
+        :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.
+        :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
+        :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`.
         """
@@ -641,9 +640,9 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKey(dict):
         if pem_key_file is not None:
             pulumi.set(__self__, "pem_key_file", pem_key_file)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyId")
-    def key_id(self) -> Optional[builtins.str]:
+    def key_id(self) -> Optional[_builtins.str]:
         """
         `(string: optional)` - Becomes the JWT's "kid" header.
         Mutually exclusive with `pem_cert` and `pem_cert_file`.
@@ -651,9 +650,9 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKey(dict):
         """
         return pulumi.get(self, "key_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="keyIdHeader")
-    def key_id_header(self) -> Optional[builtins.str]:
+    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.
@@ -663,9 +662,9 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKey(dict):
         """
         return pulumi.get(self, "key_id_header")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="pemCert")
-    def pem_cert(self) -> Optional[builtins.str]:
+    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
@@ -675,9 +674,9 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKey(dict):
         """
         return pulumi.get(self, "pem_cert")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="pemCertFile")
-    def pem_cert_file(self) -> Optional[builtins.str]:
+    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,
@@ -688,18 +687,18 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKey(dict):
         """
         return pulumi.get(self, "pem_cert_file")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="pemKey")
-    def pem_key(self) -> Optional[builtins.str]:
+    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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="pemKeyFile")
-    def pem_key_file(self) -> Optional[builtins.str]:
+    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.
@@ -728,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:
@@ -746,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
         """
@@ -782,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.
         """
@@ -800,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.
         """
@@ -849,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`
@@ -878,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`
@@ -911,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`.
         """
@@ -961,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`
@@ -990,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`
@@ -1023,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`.
         """
@@ -1054,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:
@@ -1064,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.
 
@@ -1086,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']:
         """
@@ -1104,7 +1103,7 @@ class CsiVolumeRegistrationTopologyRequestRequired(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.CsiVolumeRegistrationTopologyRequestRequiredTopology']:
         """
@@ -1116,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.
         """
@@ -1134,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:
@@ -1144,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.
 
@@ -1170,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']:
         """
@@ -1178,7 +1177,7 @@ class CsiVolumeTopologyRequest(dict):
         """
         return pulumi.get(self, "preferred")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def required(self) -> Optional['outputs.CsiVolumeTopologyRequestRequired']:
         """
@@ -1196,7 +1195,7 @@ class CsiVolumeTopologyRequestPreferred(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.CsiVolumeTopologyRequestPreferredTopology']:
         """
@@ -1208,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.
         """
@@ -1232,7 +1231,7 @@ class CsiVolumeTopologyRequestRequired(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.CsiVolumeTopologyRequestRequiredTopology']:
         """
@@ -1244,15 +1243,15 @@ 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.
         """
@@ -1281,29 +1280,29 @@ class DynamicHostVolumeCapability(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)` - How the volume can be mounted by
+        :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
+        :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)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessMode")
-    def access_mode(self) -> builtins.str:
+    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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="attachmentMode")
-    def attachment_mode(self) -> builtins.str:
+    def attachment_mode(self) -> _builtins.str:
         """
         `(string)` - The storage API that will be used by the
         volume. Refer to the [`attachment_mode`][] documentation.
@@ -1314,13 +1313,13 @@ class DynamicHostVolumeCapability(dict):
 @pulumi.output_type
 class DynamicHostVolumeConstraint(dict):
     def __init__(__self__, *,
-                 attribute: builtins.str,
-                 operator: Optional[builtins.str] = None,
-                 value: Optional[builtins.str] = None):
+                 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.
+        :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:
@@ -1328,25 +1327,25 @@ class DynamicHostVolumeConstraint(dict):
         if value is not None:
             pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def attribute(self) -> builtins.str:
+    def attribute(self) -> _builtins.str:
         """
         `(string)` - The [node attribute][] to check for the constraint.
         """
         return pulumi.get(self, "attribute")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def operator(self) -> Optional[builtins.str]:
+    def operator(self) -> Optional[_builtins.str]:
         """
         `(string)`- The operator to use in the comparison.
         """
         return pulumi.get(self, "operator")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> Optional[builtins.str]:
+    def value(self) -> Optional[_builtins.str]:
         """
         `(string)` - The value of the attribute to compare against.
         """
@@ -1375,29 +1374,29 @@ class DynamicHostVolumeRegistrationCapability(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)` - How the volume can be mounted by
+        :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
+        :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)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessMode")
-    def access_mode(self) -> builtins.str:
+    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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="attachmentMode")
-    def attachment_mode(self) -> builtins.str:
+    def attachment_mode(self) -> _builtins.str:
         """
         `(string)` - The storage API that will be used by the
         volume. Refer to the [`attachment_mode`][] documentation.
@@ -1408,13 +1407,13 @@ class DynamicHostVolumeRegistrationCapability(dict):
 @pulumi.output_type
 class DynamicHostVolumeRegistrationConstraint(dict):
     def __init__(__self__, *,
-                 attribute: builtins.str,
-                 operator: Optional[builtins.str] = None,
-                 value: Optional[builtins.str] = None):
+                 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
+        :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:
@@ -1422,25 +1421,25 @@ class DynamicHostVolumeRegistrationConstraint(dict):
         if value is not None:
             pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def attribute(self) -> builtins.str:
+    def attribute(self) -> _builtins.str:
         """
         An attribute to check to constrain volume placement
         """
         return pulumi.get(self, "attribute")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def operator(self) -> Optional[builtins.str]:
+    def operator(self) -> Optional[_builtins.str]:
         """
         The operator to use for comparison
         """
         return pulumi.get(self, "operator")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> Optional[builtins.str]:
+    def value(self) -> Optional[_builtins.str]:
         """
         The requested value of the attribute
         """
@@ -1469,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`
@@ -1498,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`
@@ -1531,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`.
         """
@@ -1562,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:
@@ -1572,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.
 
@@ -1598,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']:
         """
@@ -1606,7 +1605,7 @@ class ExternalVolumeTopologyRequest(dict):
         """
         return pulumi.get(self, "preferred")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def required(self) -> Optional['outputs.ExternalVolumeTopologyRequestRequired']:
         """
@@ -1624,7 +1623,7 @@ class ExternalVolumeTopologyRequestPreferred(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.ExternalVolumeTopologyRequestPreferredTopology']:
         """
@@ -1636,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.
         """
@@ -1660,7 +1659,7 @@ class ExternalVolumeTopologyRequestRequired(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.ExternalVolumeTopologyRequestRequiredTopology']:
         """
@@ -1672,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.
         """
@@ -1707,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
         """
@@ -1740,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:
@@ -1756,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")
@@ -1802,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)
@@ -1815,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")
@@ -1856,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:
@@ -1866,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")
 
 
@@ -1902,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:
@@ -1915,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")
 
 
@@ -1958,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.
         """
@@ -1989,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)
@@ -2004,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.
         """
@@ -2051,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.
@@ -2062,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.
         """
@@ -2071,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
@@ -2086,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
@@ -2117,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.
@@ -2128,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':
         """
@@ -2167,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.
         """
@@ -2181,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
@@ -2223,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`
@@ -2252,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`
@@ -2285,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`.
         """
@@ -2316,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:
@@ -2326,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.
 
@@ -2348,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']:
         """
@@ -2366,7 +2365,7 @@ class VolumeTopologyRequestRequired(dict):
         """
         pulumi.set(__self__, "topologies", topologies)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def topologies(self) -> Sequence['outputs.VolumeTopologyRequestRequiredTopology']:
         """
@@ -2378,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.
         """
@@ -2396,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.
         """
@@ -2425,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.
         """
@@ -2443,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)
@@ -2458,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']:
         """
@@ -2494,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.
         """
@@ -2512,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.
         """
@@ -2541,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)
@@ -2570,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']:
         """
@@ -2628,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.
         """
@@ -2640,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.
         """
@@ -2669,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)
@@ -2730,154 +2729,154 @@ 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.
         """
@@ -2887,29 +2886,29 @@ class GetAllocationsAllocationResult(dict):
 @pulumi.output_type
 class GetDynamicHostVolumeCapabilityResult(dict):
     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)` - How the volume can be mounted by
+        :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
+        :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)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessMode")
-    def access_mode(self) -> builtins.str:
+    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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="attachmentMode")
-    def attachment_mode(self) -> builtins.str:
+    def attachment_mode(self) -> _builtins.str:
         """
         `(string)` - The storage API that will be used by the
         volume. Refer to the [`attachment_mode`][] documentation.
@@ -2920,37 +2919,37 @@ class GetDynamicHostVolumeCapabilityResult(dict):
 @pulumi.output_type
 class GetDynamicHostVolumeConstraintResult(dict):
     def __init__(__self__, *,
-                 attribute: builtins.str,
-                 operator: builtins.str,
-                 value: builtins.str):
+                 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.
+        :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)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def attribute(self) -> builtins.str:
+    def attribute(self) -> _builtins.str:
         """
         `(string)` - The [node attribute][] to check for the constraint.
         """
         return pulumi.get(self, "attribute")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def operator(self) -> builtins.str:
+    def operator(self) -> _builtins.str:
         """
         `(string)`- The operator to use in the comparison.
         """
         return pulumi.get(self, "operator")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         `(string)` - The value of the attribute to compare against.
         """
@@ -2960,37 +2959,37 @@ class GetDynamicHostVolumeConstraintResult(dict):
 @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.
         """
@@ -3000,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)
@@ -3018,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.
         """
@@ -3062,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)
@@ -3076,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")
@@ -3108,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")
@@ -3147,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.
         """
@@ -3216,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)
@@ -3237,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`
         """
@@ -3289,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.
         """
@@ -3320,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
@@ -3368,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.
@@ -3381,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)
@@ -3397,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']:
         """
@@ -3434,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
@@ -3456,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.
@@ -3469,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.
         """