pulumi-nomad 2.6.0a1752905825__py3-none-any.whl → 2.6.0a1753510487__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (57) hide show
  1. pulumi_nomad/__init__.py +1 -1
  2. pulumi_nomad/_inputs.py +608 -609
  3. pulumi_nomad/acl_auth_method.py +106 -107
  4. pulumi_nomad/acl_binding_rule.py +86 -87
  5. pulumi_nomad/acl_policy.py +55 -56
  6. pulumi_nomad/acl_role.py +38 -39
  7. pulumi_nomad/acl_token.py +125 -126
  8. pulumi_nomad/config/__init__.py +1 -1
  9. pulumi_nomad/config/__init__.pyi +1 -2
  10. pulumi_nomad/config/outputs.py +9 -10
  11. pulumi_nomad/config/vars.py +14 -15
  12. pulumi_nomad/csi_volume.py +277 -278
  13. pulumi_nomad/csi_volume_registration.py +276 -277
  14. pulumi_nomad/dynamic_host_volume.py +191 -192
  15. pulumi_nomad/dynamic_host_volume_registration.py +156 -157
  16. pulumi_nomad/external_volume.py +255 -256
  17. pulumi_nomad/get_acl_policies.py +10 -11
  18. pulumi_nomad/get_acl_policy.py +13 -14
  19. pulumi_nomad/get_acl_role.py +12 -13
  20. pulumi_nomad/get_acl_roles.py +10 -11
  21. pulumi_nomad/get_acl_token.py +26 -27
  22. pulumi_nomad/get_acl_tokens.py +10 -11
  23. pulumi_nomad/get_allocations.py +22 -23
  24. pulumi_nomad/get_datacenters.py +17 -18
  25. pulumi_nomad/get_deployments.py +5 -6
  26. pulumi_nomad/get_dynamic_host_volume.py +41 -42
  27. pulumi_nomad/get_job.py +50 -51
  28. pulumi_nomad/get_job_parser.py +17 -18
  29. pulumi_nomad/get_jwks.py +6 -7
  30. pulumi_nomad/get_namespace.py +17 -18
  31. pulumi_nomad/get_namespaces.py +5 -6
  32. pulumi_nomad/get_node_pool.py +14 -15
  33. pulumi_nomad/get_node_pools.py +16 -17
  34. pulumi_nomad/get_plugin.py +36 -37
  35. pulumi_nomad/get_plugins.py +9 -10
  36. pulumi_nomad/get_regions.py +5 -6
  37. pulumi_nomad/get_scaling_policies.py +16 -17
  38. pulumi_nomad/get_scaling_policy.py +19 -20
  39. pulumi_nomad/get_scheduler_policy.py +9 -10
  40. pulumi_nomad/get_variable.py +17 -18
  41. pulumi_nomad/get_volumes.py +29 -30
  42. pulumi_nomad/job.py +245 -246
  43. pulumi_nomad/namespace.py +75 -76
  44. pulumi_nomad/node_pool.py +55 -56
  45. pulumi_nomad/outputs.py +743 -744
  46. pulumi_nomad/provider.py +119 -120
  47. pulumi_nomad/pulumi-plugin.json +1 -1
  48. pulumi_nomad/quote_specification.py +38 -39
  49. pulumi_nomad/scheduler_config.py +52 -53
  50. pulumi_nomad/sentinel_policy.py +86 -87
  51. pulumi_nomad/variable.py +52 -53
  52. pulumi_nomad/volume.py +272 -273
  53. {pulumi_nomad-2.6.0a1752905825.dist-info → pulumi_nomad-2.6.0a1753510487.dist-info}/METADATA +1 -1
  54. pulumi_nomad-2.6.0a1753510487.dist-info/RECORD +58 -0
  55. pulumi_nomad-2.6.0a1752905825.dist-info/RECORD +0 -58
  56. {pulumi_nomad-2.6.0a1752905825.dist-info → pulumi_nomad-2.6.0a1753510487.dist-info}/WHEEL +0 -0
  57. {pulumi_nomad-2.6.0a1752905825.dist-info → pulumi_nomad-2.6.0a1753510487.dist-info}/top_level.txt +0 -0
pulumi_nomad/_inputs.py CHANGED
@@ -2,8 +2,7 @@
2
2
  # *** WARNING: this file was generated by pulumi-language-python. ***
3
3
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
4
4
 
5
- import builtins
6
- import copy
5
+ import builtins as _builtins
7
6
  import warnings
8
7
  import sys
9
8
  import pulumi
@@ -120,60 +119,60 @@ MYPY = False
120
119
 
121
120
  if not MYPY:
122
121
  class AclAuthMethodConfigArgsDict(TypedDict):
123
- allowed_redirect_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
122
+ allowed_redirect_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
124
123
  """
125
124
  `([]string: <optional>)` - A list of allowed values
126
125
  that can be used for the redirect URI.
127
126
  """
128
- bound_audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
127
+ bound_audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
129
128
  """
130
129
  `([]string: <optional>)` - List of auth claims that are
131
130
  valid for login.
132
131
  """
133
- bound_issuers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
132
+ bound_issuers: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
134
133
  """
135
134
  `([]string: <optional>)` - The value against which to match
136
135
  the iss claim in a JWT.
137
136
  """
138
- claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
137
+ claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
139
138
  """
140
139
  Mappings of claims (key) that will be copied to a metadata field (value).
141
140
  """
142
- clock_skew_leeway: NotRequired[pulumi.Input[builtins.str]]
141
+ clock_skew_leeway: NotRequired[pulumi.Input[_builtins.str]]
143
142
  """
144
143
  `(string: <optional>)` - Duration of leeway when validating
145
144
  all claims in the form of a time duration such as "5m" or "1h".
146
145
  """
147
- discovery_ca_pems: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
146
+ discovery_ca_pems: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
148
147
  """
149
148
  `([]string: <optional>)` - PEM encoded CA certs for use
150
149
  by the TLS client used to talk with the OIDC Discovery URL.
151
150
  """
152
- expiration_leeway: NotRequired[pulumi.Input[builtins.str]]
151
+ expiration_leeway: NotRequired[pulumi.Input[_builtins.str]]
153
152
  """
154
153
  `(string: <optional>)` - Duration of leeway when validating
155
154
  expiration of a JWT in the form of a time duration such as "5m" or "1h".
156
155
  """
157
- jwks_ca_cert: NotRequired[pulumi.Input[builtins.str]]
156
+ jwks_ca_cert: NotRequired[pulumi.Input[_builtins.str]]
158
157
  """
159
158
  `(string: <optional>)` - PEM encoded CA cert for use by the
160
159
  TLS client used to talk with the JWKS server.
161
160
  """
162
- jwks_url: NotRequired[pulumi.Input[builtins.str]]
161
+ jwks_url: NotRequired[pulumi.Input[_builtins.str]]
163
162
  """
164
163
  `(string: <optional>)` - JSON Web Key Sets url for authenticating
165
164
  signatures.
166
165
  """
167
- jwt_validation_pub_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
166
+ jwt_validation_pub_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
168
167
  """
169
168
  `([]string: <optional>)` - List of PEM-encoded
170
169
  public keys to use to authenticate signatures locally.
171
170
  """
172
- list_claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
171
+ list_claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
173
172
  """
174
173
  Mappings of list claims (key) that will be copied to a metadata field (value).
175
174
  """
176
- not_before_leeway: NotRequired[pulumi.Input[builtins.str]]
175
+ not_before_leeway: NotRequired[pulumi.Input[_builtins.str]]
177
176
  """
178
177
  `(string: <optional>)` - Duration of leeway when validating
179
178
  not before values of a token in the form of a time duration such as "5m" or "1h".
@@ -185,44 +184,44 @@ if not MYPY:
185
184
  provider. Browse to the [OIDC concepts][concepts-assertions] page to learn
186
185
  more.
187
186
  """
188
- oidc_client_id: NotRequired[pulumi.Input[builtins.str]]
187
+ oidc_client_id: NotRequired[pulumi.Input[_builtins.str]]
189
188
  """
190
189
  `(string: <optional>)` - The OAuth Client ID configured
191
190
  with the OIDC provider.
192
191
  """
193
- oidc_client_secret: NotRequired[pulumi.Input[builtins.str]]
192
+ oidc_client_secret: NotRequired[pulumi.Input[_builtins.str]]
194
193
  """
195
194
  `(string: <optional>)` - The OAuth Client Secret
196
195
  configured with the OIDC provider.
197
196
  """
198
- oidc_disable_userinfo: NotRequired[pulumi.Input[builtins.bool]]
197
+ oidc_disable_userinfo: NotRequired[pulumi.Input[_builtins.bool]]
199
198
  """
200
199
  `(bool: false)` - When set to `true`, Nomad will
201
200
  not make a request to the identity provider to get OIDC `UserInfo`.
202
201
  You may wish to set this if your identity provider doesn't send any
203
202
  additional claims from the `UserInfo` endpoint.
204
203
  """
205
- oidc_discovery_url: NotRequired[pulumi.Input[builtins.str]]
204
+ oidc_discovery_url: NotRequired[pulumi.Input[_builtins.str]]
206
205
  """
207
206
  `(string: <optional>)` - The OIDC Discovery URL,
208
207
  without any .well-known component (base path).
209
208
  """
210
- oidc_enable_pkce: NotRequired[pulumi.Input[builtins.bool]]
209
+ oidc_enable_pkce: NotRequired[pulumi.Input[_builtins.bool]]
211
210
  """
212
211
  `(bool: false)` - When set to `true`, Nomad will include
213
212
  [PKCE][] verification in the auth flow. Even with PKCE enabled in Nomad,
214
213
  you may still need to enable it in your OIDC provider.
215
214
  """
216
- oidc_scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
215
+ oidc_scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
217
216
  """
218
217
  `([]string: <optional>)` - List of OIDC scopes.
219
218
  """
220
- signing_algs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
219
+ signing_algs: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
221
220
  """
222
221
  `([]string: <optional>)` - A list of supported signing
223
222
  algorithms.
224
223
  """
225
- verbose_logging: NotRequired[pulumi.Input[builtins.bool]]
224
+ verbose_logging: NotRequired[pulumi.Input[_builtins.bool]]
226
225
  """
227
226
  Enable OIDC verbose logging on the Nomad server.
228
227
  """
@@ -232,71 +231,71 @@ elif False:
232
231
  @pulumi.input_type
233
232
  class AclAuthMethodConfigArgs:
234
233
  def __init__(__self__, *,
235
- allowed_redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
236
- bound_audiences: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
237
- bound_issuers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
238
- claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
239
- clock_skew_leeway: Optional[pulumi.Input[builtins.str]] = None,
240
- discovery_ca_pems: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
241
- expiration_leeway: Optional[pulumi.Input[builtins.str]] = None,
242
- jwks_ca_cert: Optional[pulumi.Input[builtins.str]] = None,
243
- jwks_url: Optional[pulumi.Input[builtins.str]] = None,
244
- jwt_validation_pub_keys: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
245
- list_claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
246
- not_before_leeway: Optional[pulumi.Input[builtins.str]] = None,
234
+ allowed_redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
235
+ bound_audiences: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
236
+ bound_issuers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
237
+ claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
238
+ clock_skew_leeway: Optional[pulumi.Input[_builtins.str]] = None,
239
+ discovery_ca_pems: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
240
+ expiration_leeway: Optional[pulumi.Input[_builtins.str]] = None,
241
+ jwks_ca_cert: Optional[pulumi.Input[_builtins.str]] = None,
242
+ jwks_url: Optional[pulumi.Input[_builtins.str]] = None,
243
+ jwt_validation_pub_keys: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
244
+ list_claim_mappings: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
245
+ not_before_leeway: Optional[pulumi.Input[_builtins.str]] = None,
247
246
  oidc_client_assertion: Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgs']] = None,
248
- oidc_client_id: Optional[pulumi.Input[builtins.str]] = None,
249
- oidc_client_secret: Optional[pulumi.Input[builtins.str]] = None,
250
- oidc_disable_userinfo: Optional[pulumi.Input[builtins.bool]] = None,
251
- oidc_discovery_url: Optional[pulumi.Input[builtins.str]] = None,
252
- oidc_enable_pkce: Optional[pulumi.Input[builtins.bool]] = None,
253
- oidc_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
254
- signing_algs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
255
- verbose_logging: Optional[pulumi.Input[builtins.bool]] = None):
256
- """
257
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allowed_redirect_uris: `([]string: <optional>)` - A list of allowed values
247
+ oidc_client_id: Optional[pulumi.Input[_builtins.str]] = None,
248
+ oidc_client_secret: Optional[pulumi.Input[_builtins.str]] = None,
249
+ oidc_disable_userinfo: Optional[pulumi.Input[_builtins.bool]] = None,
250
+ oidc_discovery_url: Optional[pulumi.Input[_builtins.str]] = None,
251
+ oidc_enable_pkce: Optional[pulumi.Input[_builtins.bool]] = None,
252
+ oidc_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
253
+ signing_algs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
254
+ verbose_logging: Optional[pulumi.Input[_builtins.bool]] = None):
255
+ """
256
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_redirect_uris: `([]string: <optional>)` - A list of allowed values
258
257
  that can be used for the redirect URI.
259
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] bound_audiences: `([]string: <optional>)` - List of auth claims that are
258
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] bound_audiences: `([]string: <optional>)` - List of auth claims that are
260
259
  valid for login.
261
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] bound_issuers: `([]string: <optional>)` - The value against which to match
260
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] bound_issuers: `([]string: <optional>)` - The value against which to match
262
261
  the iss claim in a JWT.
263
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] claim_mappings: Mappings of claims (key) that will be copied to a metadata field (value).
264
- :param pulumi.Input[builtins.str] clock_skew_leeway: `(string: <optional>)` - Duration of leeway when validating
262
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] claim_mappings: Mappings of claims (key) that will be copied to a metadata field (value).
263
+ :param pulumi.Input[_builtins.str] clock_skew_leeway: `(string: <optional>)` - Duration of leeway when validating
265
264
  all claims in the form of a time duration such as "5m" or "1h".
266
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] discovery_ca_pems: `([]string: <optional>)` - PEM encoded CA certs for use
265
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] discovery_ca_pems: `([]string: <optional>)` - PEM encoded CA certs for use
267
266
  by the TLS client used to talk with the OIDC Discovery URL.
268
- :param pulumi.Input[builtins.str] expiration_leeway: `(string: <optional>)` - Duration of leeway when validating
267
+ :param pulumi.Input[_builtins.str] expiration_leeway: `(string: <optional>)` - Duration of leeway when validating
269
268
  expiration of a JWT in the form of a time duration such as "5m" or "1h".
270
- :param pulumi.Input[builtins.str] jwks_ca_cert: `(string: <optional>)` - PEM encoded CA cert for use by the
269
+ :param pulumi.Input[_builtins.str] jwks_ca_cert: `(string: <optional>)` - PEM encoded CA cert for use by the
271
270
  TLS client used to talk with the JWKS server.
272
- :param pulumi.Input[builtins.str] jwks_url: `(string: <optional>)` - JSON Web Key Sets url for authenticating
271
+ :param pulumi.Input[_builtins.str] jwks_url: `(string: <optional>)` - JSON Web Key Sets url for authenticating
273
272
  signatures.
274
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] jwt_validation_pub_keys: `([]string: <optional>)` - List of PEM-encoded
273
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] jwt_validation_pub_keys: `([]string: <optional>)` - List of PEM-encoded
275
274
  public keys to use to authenticate signatures locally.
276
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] list_claim_mappings: Mappings of list claims (key) that will be copied to a metadata field (value).
277
- :param pulumi.Input[builtins.str] not_before_leeway: `(string: <optional>)` - Duration of leeway when validating
275
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] list_claim_mappings: Mappings of list claims (key) that will be copied to a metadata field (value).
276
+ :param pulumi.Input[_builtins.str] not_before_leeway: `(string: <optional>)` - Duration of leeway when validating
278
277
  not before values of a token in the form of a time duration such as "5m" or "1h".
279
278
  :param pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgs'] oidc_client_assertion: `(OIDCClientAssertion: <optional>)` - Optionally
280
279
  send a signed JWT ("[private key jwt][]") as a client assertion to the OIDC
281
280
  provider. Browse to the [OIDC concepts][concepts-assertions] page to learn
282
281
  more.
283
- :param pulumi.Input[builtins.str] oidc_client_id: `(string: <optional>)` - The OAuth Client ID configured
282
+ :param pulumi.Input[_builtins.str] oidc_client_id: `(string: <optional>)` - The OAuth Client ID configured
284
283
  with the OIDC provider.
285
- :param pulumi.Input[builtins.str] oidc_client_secret: `(string: <optional>)` - The OAuth Client Secret
284
+ :param pulumi.Input[_builtins.str] oidc_client_secret: `(string: <optional>)` - The OAuth Client Secret
286
285
  configured with the OIDC provider.
287
- :param pulumi.Input[builtins.bool] oidc_disable_userinfo: `(bool: false)` - When set to `true`, Nomad will
286
+ :param pulumi.Input[_builtins.bool] oidc_disable_userinfo: `(bool: false)` - When set to `true`, Nomad will
288
287
  not make a request to the identity provider to get OIDC `UserInfo`.
289
288
  You may wish to set this if your identity provider doesn't send any
290
289
  additional claims from the `UserInfo` endpoint.
291
- :param pulumi.Input[builtins.str] oidc_discovery_url: `(string: <optional>)` - The OIDC Discovery URL,
290
+ :param pulumi.Input[_builtins.str] oidc_discovery_url: `(string: <optional>)` - The OIDC Discovery URL,
292
291
  without any .well-known component (base path).
293
- :param pulumi.Input[builtins.bool] oidc_enable_pkce: `(bool: false)` - When set to `true`, Nomad will include
292
+ :param pulumi.Input[_builtins.bool] oidc_enable_pkce: `(bool: false)` - When set to `true`, Nomad will include
294
293
  [PKCE][] verification in the auth flow. Even with PKCE enabled in Nomad,
295
294
  you may still need to enable it in your OIDC provider.
296
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] oidc_scopes: `([]string: <optional>)` - List of OIDC scopes.
297
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] signing_algs: `([]string: <optional>)` - A list of supported signing
295
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] oidc_scopes: `([]string: <optional>)` - List of OIDC scopes.
296
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] signing_algs: `([]string: <optional>)` - A list of supported signing
298
297
  algorithms.
299
- :param pulumi.Input[builtins.bool] verbose_logging: Enable OIDC verbose logging on the Nomad server.
298
+ :param pulumi.Input[_builtins.bool] verbose_logging: Enable OIDC verbose logging on the Nomad server.
300
299
  """
301
300
  if allowed_redirect_uris is not None:
302
301
  pulumi.set(__self__, "allowed_redirect_uris", allowed_redirect_uris)
@@ -341,9 +340,9 @@ class AclAuthMethodConfigArgs:
341
340
  if verbose_logging is not None:
342
341
  pulumi.set(__self__, "verbose_logging", verbose_logging)
343
342
 
344
- @property
343
+ @_builtins.property
345
344
  @pulumi.getter(name="allowedRedirectUris")
346
- def allowed_redirect_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
345
+ def allowed_redirect_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
347
346
  """
348
347
  `([]string: <optional>)` - A list of allowed values
349
348
  that can be used for the redirect URI.
@@ -351,12 +350,12 @@ class AclAuthMethodConfigArgs:
351
350
  return pulumi.get(self, "allowed_redirect_uris")
352
351
 
353
352
  @allowed_redirect_uris.setter
354
- def allowed_redirect_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
353
+ def allowed_redirect_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
355
354
  pulumi.set(self, "allowed_redirect_uris", value)
356
355
 
357
- @property
356
+ @_builtins.property
358
357
  @pulumi.getter(name="boundAudiences")
359
- def bound_audiences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
358
+ def bound_audiences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
360
359
  """
361
360
  `([]string: <optional>)` - List of auth claims that are
362
361
  valid for login.
@@ -364,12 +363,12 @@ class AclAuthMethodConfigArgs:
364
363
  return pulumi.get(self, "bound_audiences")
365
364
 
366
365
  @bound_audiences.setter
367
- def bound_audiences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
366
+ def bound_audiences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
368
367
  pulumi.set(self, "bound_audiences", value)
369
368
 
370
- @property
369
+ @_builtins.property
371
370
  @pulumi.getter(name="boundIssuers")
372
- def bound_issuers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
371
+ def bound_issuers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
373
372
  """
374
373
  `([]string: <optional>)` - The value against which to match
375
374
  the iss claim in a JWT.
@@ -377,24 +376,24 @@ class AclAuthMethodConfigArgs:
377
376
  return pulumi.get(self, "bound_issuers")
378
377
 
379
378
  @bound_issuers.setter
380
- def bound_issuers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
379
+ def bound_issuers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
381
380
  pulumi.set(self, "bound_issuers", value)
382
381
 
383
- @property
382
+ @_builtins.property
384
383
  @pulumi.getter(name="claimMappings")
385
- def claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
384
+ def claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
386
385
  """
387
386
  Mappings of claims (key) that will be copied to a metadata field (value).
388
387
  """
389
388
  return pulumi.get(self, "claim_mappings")
390
389
 
391
390
  @claim_mappings.setter
392
- def claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
391
+ def claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
393
392
  pulumi.set(self, "claim_mappings", value)
394
393
 
395
- @property
394
+ @_builtins.property
396
395
  @pulumi.getter(name="clockSkewLeeway")
397
- def clock_skew_leeway(self) -> Optional[pulumi.Input[builtins.str]]:
396
+ def clock_skew_leeway(self) -> Optional[pulumi.Input[_builtins.str]]:
398
397
  """
399
398
  `(string: <optional>)` - Duration of leeway when validating
400
399
  all claims in the form of a time duration such as "5m" or "1h".
@@ -402,12 +401,12 @@ class AclAuthMethodConfigArgs:
402
401
  return pulumi.get(self, "clock_skew_leeway")
403
402
 
404
403
  @clock_skew_leeway.setter
405
- def clock_skew_leeway(self, value: Optional[pulumi.Input[builtins.str]]):
404
+ def clock_skew_leeway(self, value: Optional[pulumi.Input[_builtins.str]]):
406
405
  pulumi.set(self, "clock_skew_leeway", value)
407
406
 
408
- @property
407
+ @_builtins.property
409
408
  @pulumi.getter(name="discoveryCaPems")
410
- def discovery_ca_pems(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
409
+ def discovery_ca_pems(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
411
410
  """
412
411
  `([]string: <optional>)` - PEM encoded CA certs for use
413
412
  by the TLS client used to talk with the OIDC Discovery URL.
@@ -415,12 +414,12 @@ class AclAuthMethodConfigArgs:
415
414
  return pulumi.get(self, "discovery_ca_pems")
416
415
 
417
416
  @discovery_ca_pems.setter
418
- def discovery_ca_pems(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
417
+ def discovery_ca_pems(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
419
418
  pulumi.set(self, "discovery_ca_pems", value)
420
419
 
421
- @property
420
+ @_builtins.property
422
421
  @pulumi.getter(name="expirationLeeway")
423
- def expiration_leeway(self) -> Optional[pulumi.Input[builtins.str]]:
422
+ def expiration_leeway(self) -> Optional[pulumi.Input[_builtins.str]]:
424
423
  """
425
424
  `(string: <optional>)` - Duration of leeway when validating
426
425
  expiration of a JWT in the form of a time duration such as "5m" or "1h".
@@ -428,12 +427,12 @@ class AclAuthMethodConfigArgs:
428
427
  return pulumi.get(self, "expiration_leeway")
429
428
 
430
429
  @expiration_leeway.setter
431
- def expiration_leeway(self, value: Optional[pulumi.Input[builtins.str]]):
430
+ def expiration_leeway(self, value: Optional[pulumi.Input[_builtins.str]]):
432
431
  pulumi.set(self, "expiration_leeway", value)
433
432
 
434
- @property
433
+ @_builtins.property
435
434
  @pulumi.getter(name="jwksCaCert")
436
- def jwks_ca_cert(self) -> Optional[pulumi.Input[builtins.str]]:
435
+ def jwks_ca_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
437
436
  """
438
437
  `(string: <optional>)` - PEM encoded CA cert for use by the
439
438
  TLS client used to talk with the JWKS server.
@@ -441,12 +440,12 @@ class AclAuthMethodConfigArgs:
441
440
  return pulumi.get(self, "jwks_ca_cert")
442
441
 
443
442
  @jwks_ca_cert.setter
444
- def jwks_ca_cert(self, value: Optional[pulumi.Input[builtins.str]]):
443
+ def jwks_ca_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
445
444
  pulumi.set(self, "jwks_ca_cert", value)
446
445
 
447
- @property
446
+ @_builtins.property
448
447
  @pulumi.getter(name="jwksUrl")
449
- def jwks_url(self) -> Optional[pulumi.Input[builtins.str]]:
448
+ def jwks_url(self) -> Optional[pulumi.Input[_builtins.str]]:
450
449
  """
451
450
  `(string: <optional>)` - JSON Web Key Sets url for authenticating
452
451
  signatures.
@@ -454,12 +453,12 @@ class AclAuthMethodConfigArgs:
454
453
  return pulumi.get(self, "jwks_url")
455
454
 
456
455
  @jwks_url.setter
457
- def jwks_url(self, value: Optional[pulumi.Input[builtins.str]]):
456
+ def jwks_url(self, value: Optional[pulumi.Input[_builtins.str]]):
458
457
  pulumi.set(self, "jwks_url", value)
459
458
 
460
- @property
459
+ @_builtins.property
461
460
  @pulumi.getter(name="jwtValidationPubKeys")
462
- def jwt_validation_pub_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
461
+ def jwt_validation_pub_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
463
462
  """
464
463
  `([]string: <optional>)` - List of PEM-encoded
465
464
  public keys to use to authenticate signatures locally.
@@ -467,24 +466,24 @@ class AclAuthMethodConfigArgs:
467
466
  return pulumi.get(self, "jwt_validation_pub_keys")
468
467
 
469
468
  @jwt_validation_pub_keys.setter
470
- def jwt_validation_pub_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
469
+ def jwt_validation_pub_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
471
470
  pulumi.set(self, "jwt_validation_pub_keys", value)
472
471
 
473
- @property
472
+ @_builtins.property
474
473
  @pulumi.getter(name="listClaimMappings")
475
- def list_claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
474
+ def list_claim_mappings(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
476
475
  """
477
476
  Mappings of list claims (key) that will be copied to a metadata field (value).
478
477
  """
479
478
  return pulumi.get(self, "list_claim_mappings")
480
479
 
481
480
  @list_claim_mappings.setter
482
- def list_claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
481
+ def list_claim_mappings(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
483
482
  pulumi.set(self, "list_claim_mappings", value)
484
483
 
485
- @property
484
+ @_builtins.property
486
485
  @pulumi.getter(name="notBeforeLeeway")
487
- def not_before_leeway(self) -> Optional[pulumi.Input[builtins.str]]:
486
+ def not_before_leeway(self) -> Optional[pulumi.Input[_builtins.str]]:
488
487
  """
489
488
  `(string: <optional>)` - Duration of leeway when validating
490
489
  not before values of a token in the form of a time duration such as "5m" or "1h".
@@ -492,10 +491,10 @@ class AclAuthMethodConfigArgs:
492
491
  return pulumi.get(self, "not_before_leeway")
493
492
 
494
493
  @not_before_leeway.setter
495
- def not_before_leeway(self, value: Optional[pulumi.Input[builtins.str]]):
494
+ def not_before_leeway(self, value: Optional[pulumi.Input[_builtins.str]]):
496
495
  pulumi.set(self, "not_before_leeway", value)
497
496
 
498
- @property
497
+ @_builtins.property
499
498
  @pulumi.getter(name="oidcClientAssertion")
500
499
  def oidc_client_assertion(self) -> Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgs']]:
501
500
  """
@@ -510,9 +509,9 @@ class AclAuthMethodConfigArgs:
510
509
  def oidc_client_assertion(self, value: Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionArgs']]):
511
510
  pulumi.set(self, "oidc_client_assertion", value)
512
511
 
513
- @property
512
+ @_builtins.property
514
513
  @pulumi.getter(name="oidcClientId")
515
- def oidc_client_id(self) -> Optional[pulumi.Input[builtins.str]]:
514
+ def oidc_client_id(self) -> Optional[pulumi.Input[_builtins.str]]:
516
515
  """
517
516
  `(string: <optional>)` - The OAuth Client ID configured
518
517
  with the OIDC provider.
@@ -520,12 +519,12 @@ class AclAuthMethodConfigArgs:
520
519
  return pulumi.get(self, "oidc_client_id")
521
520
 
522
521
  @oidc_client_id.setter
523
- def oidc_client_id(self, value: Optional[pulumi.Input[builtins.str]]):
522
+ def oidc_client_id(self, value: Optional[pulumi.Input[_builtins.str]]):
524
523
  pulumi.set(self, "oidc_client_id", value)
525
524
 
526
- @property
525
+ @_builtins.property
527
526
  @pulumi.getter(name="oidcClientSecret")
528
- def oidc_client_secret(self) -> Optional[pulumi.Input[builtins.str]]:
527
+ def oidc_client_secret(self) -> Optional[pulumi.Input[_builtins.str]]:
529
528
  """
530
529
  `(string: <optional>)` - The OAuth Client Secret
531
530
  configured with the OIDC provider.
@@ -533,12 +532,12 @@ class AclAuthMethodConfigArgs:
533
532
  return pulumi.get(self, "oidc_client_secret")
534
533
 
535
534
  @oidc_client_secret.setter
536
- def oidc_client_secret(self, value: Optional[pulumi.Input[builtins.str]]):
535
+ def oidc_client_secret(self, value: Optional[pulumi.Input[_builtins.str]]):
537
536
  pulumi.set(self, "oidc_client_secret", value)
538
537
 
539
- @property
538
+ @_builtins.property
540
539
  @pulumi.getter(name="oidcDisableUserinfo")
541
- def oidc_disable_userinfo(self) -> Optional[pulumi.Input[builtins.bool]]:
540
+ def oidc_disable_userinfo(self) -> Optional[pulumi.Input[_builtins.bool]]:
542
541
  """
543
542
  `(bool: false)` - When set to `true`, Nomad will
544
543
  not make a request to the identity provider to get OIDC `UserInfo`.
@@ -548,12 +547,12 @@ class AclAuthMethodConfigArgs:
548
547
  return pulumi.get(self, "oidc_disable_userinfo")
549
548
 
550
549
  @oidc_disable_userinfo.setter
551
- def oidc_disable_userinfo(self, value: Optional[pulumi.Input[builtins.bool]]):
550
+ def oidc_disable_userinfo(self, value: Optional[pulumi.Input[_builtins.bool]]):
552
551
  pulumi.set(self, "oidc_disable_userinfo", value)
553
552
 
554
- @property
553
+ @_builtins.property
555
554
  @pulumi.getter(name="oidcDiscoveryUrl")
556
- def oidc_discovery_url(self) -> Optional[pulumi.Input[builtins.str]]:
555
+ def oidc_discovery_url(self) -> Optional[pulumi.Input[_builtins.str]]:
557
556
  """
558
557
  `(string: <optional>)` - The OIDC Discovery URL,
559
558
  without any .well-known component (base path).
@@ -561,12 +560,12 @@ class AclAuthMethodConfigArgs:
561
560
  return pulumi.get(self, "oidc_discovery_url")
562
561
 
563
562
  @oidc_discovery_url.setter
564
- def oidc_discovery_url(self, value: Optional[pulumi.Input[builtins.str]]):
563
+ def oidc_discovery_url(self, value: Optional[pulumi.Input[_builtins.str]]):
565
564
  pulumi.set(self, "oidc_discovery_url", value)
566
565
 
567
- @property
566
+ @_builtins.property
568
567
  @pulumi.getter(name="oidcEnablePkce")
569
- def oidc_enable_pkce(self) -> Optional[pulumi.Input[builtins.bool]]:
568
+ def oidc_enable_pkce(self) -> Optional[pulumi.Input[_builtins.bool]]:
570
569
  """
571
570
  `(bool: false)` - When set to `true`, Nomad will include
572
571
  [PKCE][] verification in the auth flow. Even with PKCE enabled in Nomad,
@@ -575,24 +574,24 @@ class AclAuthMethodConfigArgs:
575
574
  return pulumi.get(self, "oidc_enable_pkce")
576
575
 
577
576
  @oidc_enable_pkce.setter
578
- def oidc_enable_pkce(self, value: Optional[pulumi.Input[builtins.bool]]):
577
+ def oidc_enable_pkce(self, value: Optional[pulumi.Input[_builtins.bool]]):
579
578
  pulumi.set(self, "oidc_enable_pkce", value)
580
579
 
581
- @property
580
+ @_builtins.property
582
581
  @pulumi.getter(name="oidcScopes")
583
- def oidc_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
582
+ def oidc_scopes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
584
583
  """
585
584
  `([]string: <optional>)` - List of OIDC scopes.
586
585
  """
587
586
  return pulumi.get(self, "oidc_scopes")
588
587
 
589
588
  @oidc_scopes.setter
590
- def oidc_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
589
+ def oidc_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
591
590
  pulumi.set(self, "oidc_scopes", value)
592
591
 
593
- @property
592
+ @_builtins.property
594
593
  @pulumi.getter(name="signingAlgs")
595
- def signing_algs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
594
+ def signing_algs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
596
595
  """
597
596
  `([]string: <optional>)` - A list of supported signing
598
597
  algorithms.
@@ -600,25 +599,25 @@ class AclAuthMethodConfigArgs:
600
599
  return pulumi.get(self, "signing_algs")
601
600
 
602
601
  @signing_algs.setter
603
- def signing_algs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
602
+ def signing_algs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
604
603
  pulumi.set(self, "signing_algs", value)
605
604
 
606
- @property
605
+ @_builtins.property
607
606
  @pulumi.getter(name="verboseLogging")
608
- def verbose_logging(self) -> Optional[pulumi.Input[builtins.bool]]:
607
+ def verbose_logging(self) -> Optional[pulumi.Input[_builtins.bool]]:
609
608
  """
610
609
  Enable OIDC verbose logging on the Nomad server.
611
610
  """
612
611
  return pulumi.get(self, "verbose_logging")
613
612
 
614
613
  @verbose_logging.setter
615
- def verbose_logging(self, value: Optional[pulumi.Input[builtins.bool]]):
614
+ def verbose_logging(self, value: Optional[pulumi.Input[_builtins.bool]]):
616
615
  pulumi.set(self, "verbose_logging", value)
617
616
 
618
617
 
619
618
  if not MYPY:
620
619
  class AclAuthMethodConfigOidcClientAssertionArgsDict(TypedDict):
621
- key_source: pulumi.Input[builtins.str]
620
+ key_source: pulumi.Input[_builtins.str]
622
621
  """
623
622
  `(string: <required>)` - Specifies where to get the private
624
623
  key to sign the JWT.
@@ -627,18 +626,18 @@ if not MYPY:
627
626
  - "private_key": Use key material in the `private_key` field
628
627
  - "client_secret": Use the `oidc_client_secret` as an HMAC key
629
628
  """
630
- audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
629
+ audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
631
630
  """
632
631
  `([]string: optional)` - Who processes the assertion.
633
632
  Defaults to the auth method's `oidc_discovery_url`.
634
633
  """
635
- extra_headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
634
+ extra_headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
636
635
  """
637
636
  `(map[string]string: optional)` - Add to the JWT headers,
638
637
  alongside "kid" and "type". Setting the "kid" header here is not allowed;
639
638
  use `private_key.key_id`.
640
639
  """
641
- key_algorithm: NotRequired[pulumi.Input[builtins.str]]
640
+ key_algorithm: NotRequired[pulumi.Input[_builtins.str]]
642
641
  """
643
642
  `(string: <optional>)` is the key's algorithm.
644
643
  Its default values are based on the `key_source`:
@@ -657,24 +656,24 @@ elif False:
657
656
  @pulumi.input_type
658
657
  class AclAuthMethodConfigOidcClientAssertionArgs:
659
658
  def __init__(__self__, *,
660
- key_source: pulumi.Input[builtins.str],
661
- audiences: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
662
- extra_headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
663
- key_algorithm: Optional[pulumi.Input[builtins.str]] = None,
659
+ key_source: pulumi.Input[_builtins.str],
660
+ audiences: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
661
+ extra_headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
662
+ key_algorithm: Optional[pulumi.Input[_builtins.str]] = None,
664
663
  private_key: Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs']] = None):
665
664
  """
666
- :param pulumi.Input[builtins.str] key_source: `(string: <required>)` - Specifies where to get the private
665
+ :param pulumi.Input[_builtins.str] key_source: `(string: <required>)` - Specifies where to get the private
667
666
  key to sign the JWT.
668
667
  Available sources:
669
668
  - "nomad": Use current active key in Nomad's keyring
670
669
  - "private_key": Use key material in the `private_key` field
671
670
  - "client_secret": Use the `oidc_client_secret` as an HMAC key
672
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] audiences: `([]string: optional)` - Who processes the assertion.
671
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] audiences: `([]string: optional)` - Who processes the assertion.
673
672
  Defaults to the auth method's `oidc_discovery_url`.
674
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] extra_headers: `(map[string]string: optional)` - Add to the JWT headers,
673
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] extra_headers: `(map[string]string: optional)` - Add to the JWT headers,
675
674
  alongside "kid" and "type". Setting the "kid" header here is not allowed;
676
675
  use `private_key.key_id`.
677
- :param pulumi.Input[builtins.str] key_algorithm: `(string: <optional>)` is the key's algorithm.
676
+ :param pulumi.Input[_builtins.str] key_algorithm: `(string: <optional>)` is the key's algorithm.
678
677
  Its default values are based on the `key_source`:
679
678
  - "nomad": "RS256"; this is from Nomad's keyring and must not be changed
680
679
  - "private_key": "RS256"; must be RS256, RS384, or RS512
@@ -692,9 +691,9 @@ class AclAuthMethodConfigOidcClientAssertionArgs:
692
691
  if private_key is not None:
693
692
  pulumi.set(__self__, "private_key", private_key)
694
693
 
695
- @property
694
+ @_builtins.property
696
695
  @pulumi.getter(name="keySource")
697
- def key_source(self) -> pulumi.Input[builtins.str]:
696
+ def key_source(self) -> pulumi.Input[_builtins.str]:
698
697
  """
699
698
  `(string: <required>)` - Specifies where to get the private
700
699
  key to sign the JWT.
@@ -706,12 +705,12 @@ class AclAuthMethodConfigOidcClientAssertionArgs:
706
705
  return pulumi.get(self, "key_source")
707
706
 
708
707
  @key_source.setter
709
- def key_source(self, value: pulumi.Input[builtins.str]):
708
+ def key_source(self, value: pulumi.Input[_builtins.str]):
710
709
  pulumi.set(self, "key_source", value)
711
710
 
712
- @property
711
+ @_builtins.property
713
712
  @pulumi.getter
714
- def audiences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
713
+ def audiences(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
715
714
  """
716
715
  `([]string: optional)` - Who processes the assertion.
717
716
  Defaults to the auth method's `oidc_discovery_url`.
@@ -719,12 +718,12 @@ class AclAuthMethodConfigOidcClientAssertionArgs:
719
718
  return pulumi.get(self, "audiences")
720
719
 
721
720
  @audiences.setter
722
- def audiences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
721
+ def audiences(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
723
722
  pulumi.set(self, "audiences", value)
724
723
 
725
- @property
724
+ @_builtins.property
726
725
  @pulumi.getter(name="extraHeaders")
727
- def extra_headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
726
+ def extra_headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
728
727
  """
729
728
  `(map[string]string: optional)` - Add to the JWT headers,
730
729
  alongside "kid" and "type". Setting the "kid" header here is not allowed;
@@ -733,12 +732,12 @@ class AclAuthMethodConfigOidcClientAssertionArgs:
733
732
  return pulumi.get(self, "extra_headers")
734
733
 
735
734
  @extra_headers.setter
736
- def extra_headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
735
+ def extra_headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
737
736
  pulumi.set(self, "extra_headers", value)
738
737
 
739
- @property
738
+ @_builtins.property
740
739
  @pulumi.getter(name="keyAlgorithm")
741
- def key_algorithm(self) -> Optional[pulumi.Input[builtins.str]]:
740
+ def key_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
742
741
  """
743
742
  `(string: <optional>)` is the key's algorithm.
744
743
  Its default values are based on the `key_source`:
@@ -749,10 +748,10 @@ class AclAuthMethodConfigOidcClientAssertionArgs:
749
748
  return pulumi.get(self, "key_algorithm")
750
749
 
751
750
  @key_algorithm.setter
752
- def key_algorithm(self, value: Optional[pulumi.Input[builtins.str]]):
751
+ def key_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
753
752
  pulumi.set(self, "key_algorithm", value)
754
753
 
755
- @property
754
+ @_builtins.property
756
755
  @pulumi.getter(name="privateKey")
757
756
  def private_key(self) -> Optional[pulumi.Input['AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs']]:
758
757
  """
@@ -768,13 +767,13 @@ class AclAuthMethodConfigOidcClientAssertionArgs:
768
767
 
769
768
  if not MYPY:
770
769
  class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgsDict(TypedDict):
771
- key_id: NotRequired[pulumi.Input[builtins.str]]
770
+ key_id: NotRequired[pulumi.Input[_builtins.str]]
772
771
  """
773
772
  `(string: optional)` - Becomes the JWT's "kid" header.
774
773
  Mutually exclusive with `pem_cert` and `pem_cert_file`.
775
774
  Allowed `key_id_header` values: "kid" (the default)
776
775
  """
777
- key_id_header: NotRequired[pulumi.Input[builtins.str]]
776
+ key_id_header: NotRequired[pulumi.Input[_builtins.str]]
778
777
  """
779
778
  `(string: optional)` - Which header the provider uses
780
779
  to find the public key to verify the signed JWT.
@@ -782,7 +781,7 @@ if not MYPY:
782
781
  `pem_cert`, or `pem_cert_file`. You must set exactly one of those
783
782
  options, so refer to them for their requirements.
784
783
  """
785
- pem_cert: NotRequired[pulumi.Input[builtins.str]]
784
+ pem_cert: NotRequired[pulumi.Input[_builtins.str]]
786
785
  """
787
786
  `(string: optional)` - An x509 certificate, signed by the
788
787
  private key or a CA, in pem format. Nomad uses this certificate to
@@ -790,7 +789,7 @@ if not MYPY:
790
789
  Mutually exclusive with `pem_cert_file` and `key_id`.
791
790
  Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
792
791
  """
793
- pem_cert_file: NotRequired[pulumi.Input[builtins.str]]
792
+ pem_cert_file: NotRequired[pulumi.Input[_builtins.str]]
794
793
  """
795
794
  `(string: optional)` - An absolute path to an x509
796
795
  certificate on Nomad servers' disk, signed by the private key or a CA,
@@ -799,12 +798,12 @@ if not MYPY:
799
798
  header. Mutually exclusive with `pem_cert` and key_id.
800
799
  Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
801
800
  """
802
- pem_key: NotRequired[pulumi.Input[builtins.str]]
801
+ pem_key: NotRequired[pulumi.Input[_builtins.str]]
803
802
  """
804
803
  `(string: <optional>)` - An RSA private key, in pem format.
805
804
  It is used to sign the JWT. Mutually exclusive with `pem_key`.
806
805
  """
807
- pem_key_file: NotRequired[pulumi.Input[builtins.str]]
806
+ pem_key_file: NotRequired[pulumi.Input[_builtins.str]]
808
807
  """
809
808
  `(string: optional)` - An absolute path to a private key
810
809
  on Nomad servers' disk, in pem format. It is used to sign the JWT.
@@ -816,35 +815,35 @@ elif False:
816
815
  @pulumi.input_type
817
816
  class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
818
817
  def __init__(__self__, *,
819
- key_id: Optional[pulumi.Input[builtins.str]] = None,
820
- key_id_header: Optional[pulumi.Input[builtins.str]] = None,
821
- pem_cert: Optional[pulumi.Input[builtins.str]] = None,
822
- pem_cert_file: Optional[pulumi.Input[builtins.str]] = None,
823
- pem_key: Optional[pulumi.Input[builtins.str]] = None,
824
- pem_key_file: Optional[pulumi.Input[builtins.str]] = None):
825
- """
826
- :param pulumi.Input[builtins.str] key_id: `(string: optional)` - Becomes the JWT's "kid" header.
818
+ key_id: Optional[pulumi.Input[_builtins.str]] = None,
819
+ key_id_header: Optional[pulumi.Input[_builtins.str]] = None,
820
+ pem_cert: Optional[pulumi.Input[_builtins.str]] = None,
821
+ pem_cert_file: Optional[pulumi.Input[_builtins.str]] = None,
822
+ pem_key: Optional[pulumi.Input[_builtins.str]] = None,
823
+ pem_key_file: Optional[pulumi.Input[_builtins.str]] = None):
824
+ """
825
+ :param pulumi.Input[_builtins.str] key_id: `(string: optional)` - Becomes the JWT's "kid" header.
827
826
  Mutually exclusive with `pem_cert` and `pem_cert_file`.
828
827
  Allowed `key_id_header` values: "kid" (the default)
829
- :param pulumi.Input[builtins.str] key_id_header: `(string: optional)` - Which header the provider uses
828
+ :param pulumi.Input[_builtins.str] key_id_header: `(string: optional)` - Which header the provider uses
830
829
  to find the public key to verify the signed JWT.
831
830
  The default and allowed values depend on whether you set `key_id`,
832
831
  `pem_cert`, or `pem_cert_file`. You must set exactly one of those
833
832
  options, so refer to them for their requirements.
834
- :param pulumi.Input[builtins.str] pem_cert: `(string: optional)` - An x509 certificate, signed by the
833
+ :param pulumi.Input[_builtins.str] pem_cert: `(string: optional)` - An x509 certificate, signed by the
835
834
  private key or a CA, in pem format. Nomad uses this certificate to
836
835
  derive an [x5t#S256][] (or [x5t][]) key_id.
837
836
  Mutually exclusive with `pem_cert_file` and `key_id`.
838
837
  Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
839
- :param pulumi.Input[builtins.str] pem_cert_file: `(string: optional)` - An absolute path to an x509
838
+ :param pulumi.Input[_builtins.str] pem_cert_file: `(string: optional)` - An absolute path to an x509
840
839
  certificate on Nomad servers' disk, signed by the private key or a CA,
841
840
  in pem format.
842
841
  Nomad uses this certificate to derive an [x5t#S256][] (or [x5t][])
843
842
  header. Mutually exclusive with `pem_cert` and key_id.
844
843
  Allowed `key_id_header` values: "x5t", "x5t#S256" (default "x5t#S256")
845
- :param pulumi.Input[builtins.str] pem_key: `(string: <optional>)` - An RSA private key, in pem format.
844
+ :param pulumi.Input[_builtins.str] pem_key: `(string: <optional>)` - An RSA private key, in pem format.
846
845
  It is used to sign the JWT. Mutually exclusive with `pem_key`.
847
- :param pulumi.Input[builtins.str] pem_key_file: `(string: optional)` - An absolute path to a private key
846
+ :param pulumi.Input[_builtins.str] pem_key_file: `(string: optional)` - An absolute path to a private key
848
847
  on Nomad servers' disk, in pem format. It is used to sign the JWT.
849
848
  Mutually exclusive with `pem_key_file`.
850
849
  """
@@ -861,9 +860,9 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
861
860
  if pem_key_file is not None:
862
861
  pulumi.set(__self__, "pem_key_file", pem_key_file)
863
862
 
864
- @property
863
+ @_builtins.property
865
864
  @pulumi.getter(name="keyId")
866
- def key_id(self) -> Optional[pulumi.Input[builtins.str]]:
865
+ def key_id(self) -> Optional[pulumi.Input[_builtins.str]]:
867
866
  """
868
867
  `(string: optional)` - Becomes the JWT's "kid" header.
869
868
  Mutually exclusive with `pem_cert` and `pem_cert_file`.
@@ -872,12 +871,12 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
872
871
  return pulumi.get(self, "key_id")
873
872
 
874
873
  @key_id.setter
875
- def key_id(self, value: Optional[pulumi.Input[builtins.str]]):
874
+ def key_id(self, value: Optional[pulumi.Input[_builtins.str]]):
876
875
  pulumi.set(self, "key_id", value)
877
876
 
878
- @property
877
+ @_builtins.property
879
878
  @pulumi.getter(name="keyIdHeader")
880
- def key_id_header(self) -> Optional[pulumi.Input[builtins.str]]:
879
+ def key_id_header(self) -> Optional[pulumi.Input[_builtins.str]]:
881
880
  """
882
881
  `(string: optional)` - Which header the provider uses
883
882
  to find the public key to verify the signed JWT.
@@ -888,12 +887,12 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
888
887
  return pulumi.get(self, "key_id_header")
889
888
 
890
889
  @key_id_header.setter
891
- def key_id_header(self, value: Optional[pulumi.Input[builtins.str]]):
890
+ def key_id_header(self, value: Optional[pulumi.Input[_builtins.str]]):
892
891
  pulumi.set(self, "key_id_header", value)
893
892
 
894
- @property
893
+ @_builtins.property
895
894
  @pulumi.getter(name="pemCert")
896
- def pem_cert(self) -> Optional[pulumi.Input[builtins.str]]:
895
+ def pem_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
897
896
  """
898
897
  `(string: optional)` - An x509 certificate, signed by the
899
898
  private key or a CA, in pem format. Nomad uses this certificate to
@@ -904,12 +903,12 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
904
903
  return pulumi.get(self, "pem_cert")
905
904
 
906
905
  @pem_cert.setter
907
- def pem_cert(self, value: Optional[pulumi.Input[builtins.str]]):
906
+ def pem_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
908
907
  pulumi.set(self, "pem_cert", value)
909
908
 
910
- @property
909
+ @_builtins.property
911
910
  @pulumi.getter(name="pemCertFile")
912
- def pem_cert_file(self) -> Optional[pulumi.Input[builtins.str]]:
911
+ def pem_cert_file(self) -> Optional[pulumi.Input[_builtins.str]]:
913
912
  """
914
913
  `(string: optional)` - An absolute path to an x509
915
914
  certificate on Nomad servers' disk, signed by the private key or a CA,
@@ -921,12 +920,12 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
921
920
  return pulumi.get(self, "pem_cert_file")
922
921
 
923
922
  @pem_cert_file.setter
924
- def pem_cert_file(self, value: Optional[pulumi.Input[builtins.str]]):
923
+ def pem_cert_file(self, value: Optional[pulumi.Input[_builtins.str]]):
925
924
  pulumi.set(self, "pem_cert_file", value)
926
925
 
927
- @property
926
+ @_builtins.property
928
927
  @pulumi.getter(name="pemKey")
929
- def pem_key(self) -> Optional[pulumi.Input[builtins.str]]:
928
+ def pem_key(self) -> Optional[pulumi.Input[_builtins.str]]:
930
929
  """
931
930
  `(string: <optional>)` - An RSA private key, in pem format.
932
931
  It is used to sign the JWT. Mutually exclusive with `pem_key`.
@@ -934,12 +933,12 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
934
933
  return pulumi.get(self, "pem_key")
935
934
 
936
935
  @pem_key.setter
937
- def pem_key(self, value: Optional[pulumi.Input[builtins.str]]):
936
+ def pem_key(self, value: Optional[pulumi.Input[_builtins.str]]):
938
937
  pulumi.set(self, "pem_key", value)
939
938
 
940
- @property
939
+ @_builtins.property
941
940
  @pulumi.getter(name="pemKeyFile")
942
- def pem_key_file(self) -> Optional[pulumi.Input[builtins.str]]:
941
+ def pem_key_file(self) -> Optional[pulumi.Input[_builtins.str]]:
943
942
  """
944
943
  `(string: optional)` - An absolute path to a private key
945
944
  on Nomad servers' disk, in pem format. It is used to sign the JWT.
@@ -948,25 +947,25 @@ class AclAuthMethodConfigOidcClientAssertionPrivateKeyArgs:
948
947
  return pulumi.get(self, "pem_key_file")
949
948
 
950
949
  @pem_key_file.setter
951
- def pem_key_file(self, value: Optional[pulumi.Input[builtins.str]]):
950
+ def pem_key_file(self, value: Optional[pulumi.Input[_builtins.str]]):
952
951
  pulumi.set(self, "pem_key_file", value)
953
952
 
954
953
 
955
954
  if not MYPY:
956
955
  class AclPolicyJobAclArgsDict(TypedDict):
957
- job_id: pulumi.Input[builtins.str]
956
+ job_id: pulumi.Input[_builtins.str]
958
957
  """
959
958
  Job
960
959
  """
961
- group: NotRequired[pulumi.Input[builtins.str]]
960
+ group: NotRequired[pulumi.Input[_builtins.str]]
962
961
  """
963
962
  Group
964
963
  """
965
- namespace: NotRequired[pulumi.Input[builtins.str]]
964
+ namespace: NotRequired[pulumi.Input[_builtins.str]]
966
965
  """
967
966
  Namespace
968
967
  """
969
- task: NotRequired[pulumi.Input[builtins.str]]
968
+ task: NotRequired[pulumi.Input[_builtins.str]]
970
969
  """
971
970
  Task
972
971
  """
@@ -976,15 +975,15 @@ elif False:
976
975
  @pulumi.input_type
977
976
  class AclPolicyJobAclArgs:
978
977
  def __init__(__self__, *,
979
- job_id: pulumi.Input[builtins.str],
980
- group: Optional[pulumi.Input[builtins.str]] = None,
981
- namespace: Optional[pulumi.Input[builtins.str]] = None,
982
- task: Optional[pulumi.Input[builtins.str]] = None):
978
+ job_id: pulumi.Input[_builtins.str],
979
+ group: Optional[pulumi.Input[_builtins.str]] = None,
980
+ namespace: Optional[pulumi.Input[_builtins.str]] = None,
981
+ task: Optional[pulumi.Input[_builtins.str]] = None):
983
982
  """
984
- :param pulumi.Input[builtins.str] job_id: Job
985
- :param pulumi.Input[builtins.str] group: Group
986
- :param pulumi.Input[builtins.str] namespace: Namespace
987
- :param pulumi.Input[builtins.str] task: Task
983
+ :param pulumi.Input[_builtins.str] job_id: Job
984
+ :param pulumi.Input[_builtins.str] group: Group
985
+ :param pulumi.Input[_builtins.str] namespace: Namespace
986
+ :param pulumi.Input[_builtins.str] task: Task
988
987
  """
989
988
  pulumi.set(__self__, "job_id", job_id)
990
989
  if group is not None:
@@ -994,58 +993,58 @@ class AclPolicyJobAclArgs:
994
993
  if task is not None:
995
994
  pulumi.set(__self__, "task", task)
996
995
 
997
- @property
996
+ @_builtins.property
998
997
  @pulumi.getter(name="jobId")
999
- def job_id(self) -> pulumi.Input[builtins.str]:
998
+ def job_id(self) -> pulumi.Input[_builtins.str]:
1000
999
  """
1001
1000
  Job
1002
1001
  """
1003
1002
  return pulumi.get(self, "job_id")
1004
1003
 
1005
1004
  @job_id.setter
1006
- def job_id(self, value: pulumi.Input[builtins.str]):
1005
+ def job_id(self, value: pulumi.Input[_builtins.str]):
1007
1006
  pulumi.set(self, "job_id", value)
1008
1007
 
1009
- @property
1008
+ @_builtins.property
1010
1009
  @pulumi.getter
1011
- def group(self) -> Optional[pulumi.Input[builtins.str]]:
1010
+ def group(self) -> Optional[pulumi.Input[_builtins.str]]:
1012
1011
  """
1013
1012
  Group
1014
1013
  """
1015
1014
  return pulumi.get(self, "group")
1016
1015
 
1017
1016
  @group.setter
1018
- def group(self, value: Optional[pulumi.Input[builtins.str]]):
1017
+ def group(self, value: Optional[pulumi.Input[_builtins.str]]):
1019
1018
  pulumi.set(self, "group", value)
1020
1019
 
1021
- @property
1020
+ @_builtins.property
1022
1021
  @pulumi.getter
1023
- def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
1022
+ def namespace(self) -> Optional[pulumi.Input[_builtins.str]]:
1024
1023
  """
1025
1024
  Namespace
1026
1025
  """
1027
1026
  return pulumi.get(self, "namespace")
1028
1027
 
1029
1028
  @namespace.setter
1030
- def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
1029
+ def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
1031
1030
  pulumi.set(self, "namespace", value)
1032
1031
 
1033
- @property
1032
+ @_builtins.property
1034
1033
  @pulumi.getter
1035
- def task(self) -> Optional[pulumi.Input[builtins.str]]:
1034
+ def task(self) -> Optional[pulumi.Input[_builtins.str]]:
1036
1035
  """
1037
1036
  Task
1038
1037
  """
1039
1038
  return pulumi.get(self, "task")
1040
1039
 
1041
1040
  @task.setter
1042
- def task(self, value: Optional[pulumi.Input[builtins.str]]):
1041
+ def task(self, value: Optional[pulumi.Input[_builtins.str]]):
1043
1042
  pulumi.set(self, "task", value)
1044
1043
 
1045
1044
 
1046
1045
  if not MYPY:
1047
1046
  class AclRolePolicyArgsDict(TypedDict):
1048
- name: pulumi.Input[builtins.str]
1047
+ name: pulumi.Input[_builtins.str]
1049
1048
  """
1050
1049
  `(string: <required>)` - A human-friendly name for this ACL Role.
1051
1050
  """
@@ -1055,32 +1054,32 @@ elif False:
1055
1054
  @pulumi.input_type
1056
1055
  class AclRolePolicyArgs:
1057
1056
  def __init__(__self__, *,
1058
- name: pulumi.Input[builtins.str]):
1057
+ name: pulumi.Input[_builtins.str]):
1059
1058
  """
1060
- :param pulumi.Input[builtins.str] name: `(string: <required>)` - A human-friendly name for this ACL Role.
1059
+ :param pulumi.Input[_builtins.str] name: `(string: <required>)` - A human-friendly name for this ACL Role.
1061
1060
  """
1062
1061
  pulumi.set(__self__, "name", name)
1063
1062
 
1064
- @property
1063
+ @_builtins.property
1065
1064
  @pulumi.getter
1066
- def name(self) -> pulumi.Input[builtins.str]:
1065
+ def name(self) -> pulumi.Input[_builtins.str]:
1067
1066
  """
1068
1067
  `(string: <required>)` - A human-friendly name for this ACL Role.
1069
1068
  """
1070
1069
  return pulumi.get(self, "name")
1071
1070
 
1072
1071
  @name.setter
1073
- def name(self, value: pulumi.Input[builtins.str]):
1072
+ def name(self, value: pulumi.Input[_builtins.str]):
1074
1073
  pulumi.set(self, "name", value)
1075
1074
 
1076
1075
 
1077
1076
  if not MYPY:
1078
1077
  class AclTokenRoleArgsDict(TypedDict):
1079
- id: pulumi.Input[builtins.str]
1078
+ id: pulumi.Input[_builtins.str]
1080
1079
  """
1081
1080
  The ID of the ACL role to link.
1082
1081
  """
1083
- name: NotRequired[pulumi.Input[builtins.str]]
1082
+ name: NotRequired[pulumi.Input[_builtins.str]]
1084
1083
  """
1085
1084
  `(string: "")` - A human-friendly name for this token.
1086
1085
  """
@@ -1090,44 +1089,44 @@ elif False:
1090
1089
  @pulumi.input_type
1091
1090
  class AclTokenRoleArgs:
1092
1091
  def __init__(__self__, *,
1093
- id: pulumi.Input[builtins.str],
1094
- name: Optional[pulumi.Input[builtins.str]] = None):
1092
+ id: pulumi.Input[_builtins.str],
1093
+ name: Optional[pulumi.Input[_builtins.str]] = None):
1095
1094
  """
1096
- :param pulumi.Input[builtins.str] id: The ID of the ACL role to link.
1097
- :param pulumi.Input[builtins.str] name: `(string: "")` - A human-friendly name for this token.
1095
+ :param pulumi.Input[_builtins.str] id: The ID of the ACL role to link.
1096
+ :param pulumi.Input[_builtins.str] name: `(string: "")` - A human-friendly name for this token.
1098
1097
  """
1099
1098
  pulumi.set(__self__, "id", id)
1100
1099
  if name is not None:
1101
1100
  pulumi.set(__self__, "name", name)
1102
1101
 
1103
- @property
1102
+ @_builtins.property
1104
1103
  @pulumi.getter
1105
- def id(self) -> pulumi.Input[builtins.str]:
1104
+ def id(self) -> pulumi.Input[_builtins.str]:
1106
1105
  """
1107
1106
  The ID of the ACL role to link.
1108
1107
  """
1109
1108
  return pulumi.get(self, "id")
1110
1109
 
1111
1110
  @id.setter
1112
- def id(self, value: pulumi.Input[builtins.str]):
1111
+ def id(self, value: pulumi.Input[_builtins.str]):
1113
1112
  pulumi.set(self, "id", value)
1114
1113
 
1115
- @property
1114
+ @_builtins.property
1116
1115
  @pulumi.getter
1117
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
1116
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
1118
1117
  """
1119
1118
  `(string: "")` - A human-friendly name for this token.
1120
1119
  """
1121
1120
  return pulumi.get(self, "name")
1122
1121
 
1123
1122
  @name.setter
1124
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
1123
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
1125
1124
  pulumi.set(self, "name", value)
1126
1125
 
1127
1126
 
1128
1127
  if not MYPY:
1129
1128
  class CsiVolumeCapabilityArgsDict(TypedDict):
1130
- access_mode: pulumi.Input[builtins.str]
1129
+ access_mode: pulumi.Input[_builtins.str]
1131
1130
  """
1132
1131
  `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1133
1132
  - `single-node-reader-only`
@@ -1136,7 +1135,7 @@ if not MYPY:
1136
1135
  - `multi-node-single-writer`
1137
1136
  - `multi-node-multi-writer`
1138
1137
  """
1139
- attachment_mode: pulumi.Input[builtins.str]
1138
+ attachment_mode: pulumi.Input[_builtins.str]
1140
1139
  """
1141
1140
  `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1142
1141
  - `block-device`
@@ -1148,25 +1147,25 @@ elif False:
1148
1147
  @pulumi.input_type
1149
1148
  class CsiVolumeCapabilityArgs:
1150
1149
  def __init__(__self__, *,
1151
- access_mode: pulumi.Input[builtins.str],
1152
- attachment_mode: pulumi.Input[builtins.str]):
1150
+ access_mode: pulumi.Input[_builtins.str],
1151
+ attachment_mode: pulumi.Input[_builtins.str]):
1153
1152
  """
1154
- :param pulumi.Input[builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1153
+ :param pulumi.Input[_builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1155
1154
  - `single-node-reader-only`
1156
1155
  - `single-node-writer`
1157
1156
  - `multi-node-reader-only`
1158
1157
  - `multi-node-single-writer`
1159
1158
  - `multi-node-multi-writer`
1160
- :param pulumi.Input[builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1159
+ :param pulumi.Input[_builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1161
1160
  - `block-device`
1162
1161
  - `file-system`
1163
1162
  """
1164
1163
  pulumi.set(__self__, "access_mode", access_mode)
1165
1164
  pulumi.set(__self__, "attachment_mode", attachment_mode)
1166
1165
 
1167
- @property
1166
+ @_builtins.property
1168
1167
  @pulumi.getter(name="accessMode")
1169
- def access_mode(self) -> pulumi.Input[builtins.str]:
1168
+ def access_mode(self) -> pulumi.Input[_builtins.str]:
1170
1169
  """
1171
1170
  `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1172
1171
  - `single-node-reader-only`
@@ -1178,12 +1177,12 @@ class CsiVolumeCapabilityArgs:
1178
1177
  return pulumi.get(self, "access_mode")
1179
1178
 
1180
1179
  @access_mode.setter
1181
- def access_mode(self, value: pulumi.Input[builtins.str]):
1180
+ def access_mode(self, value: pulumi.Input[_builtins.str]):
1182
1181
  pulumi.set(self, "access_mode", value)
1183
1182
 
1184
- @property
1183
+ @_builtins.property
1185
1184
  @pulumi.getter(name="attachmentMode")
1186
- def attachment_mode(self) -> pulumi.Input[builtins.str]:
1185
+ def attachment_mode(self) -> pulumi.Input[_builtins.str]:
1187
1186
  """
1188
1187
  `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1189
1188
  - `block-device`
@@ -1192,17 +1191,17 @@ class CsiVolumeCapabilityArgs:
1192
1191
  return pulumi.get(self, "attachment_mode")
1193
1192
 
1194
1193
  @attachment_mode.setter
1195
- def attachment_mode(self, value: pulumi.Input[builtins.str]):
1194
+ def attachment_mode(self, value: pulumi.Input[_builtins.str]):
1196
1195
  pulumi.set(self, "attachment_mode", value)
1197
1196
 
1198
1197
 
1199
1198
  if not MYPY:
1200
1199
  class CsiVolumeMountOptionsArgsDict(TypedDict):
1201
- fs_type: NotRequired[pulumi.Input[builtins.str]]
1200
+ fs_type: NotRequired[pulumi.Input[_builtins.str]]
1202
1201
  """
1203
1202
  `(string: optional)` - The file system type.
1204
1203
  """
1205
- mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1204
+ mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
1206
1205
  """
1207
1206
  `[]string: optional` - The flags passed to `mount`.
1208
1207
  """
@@ -1212,45 +1211,45 @@ elif False:
1212
1211
  @pulumi.input_type
1213
1212
  class CsiVolumeMountOptionsArgs:
1214
1213
  def __init__(__self__, *,
1215
- fs_type: Optional[pulumi.Input[builtins.str]] = None,
1216
- mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
1214
+ fs_type: Optional[pulumi.Input[_builtins.str]] = None,
1215
+ mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
1217
1216
  """
1218
- :param pulumi.Input[builtins.str] fs_type: `(string: optional)` - The file system type.
1219
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mount_flags: `[]string: optional` - The flags passed to `mount`.
1217
+ :param pulumi.Input[_builtins.str] fs_type: `(string: optional)` - The file system type.
1218
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] mount_flags: `[]string: optional` - The flags passed to `mount`.
1220
1219
  """
1221
1220
  if fs_type is not None:
1222
1221
  pulumi.set(__self__, "fs_type", fs_type)
1223
1222
  if mount_flags is not None:
1224
1223
  pulumi.set(__self__, "mount_flags", mount_flags)
1225
1224
 
1226
- @property
1225
+ @_builtins.property
1227
1226
  @pulumi.getter(name="fsType")
1228
- def fs_type(self) -> Optional[pulumi.Input[builtins.str]]:
1227
+ def fs_type(self) -> Optional[pulumi.Input[_builtins.str]]:
1229
1228
  """
1230
1229
  `(string: optional)` - The file system type.
1231
1230
  """
1232
1231
  return pulumi.get(self, "fs_type")
1233
1232
 
1234
1233
  @fs_type.setter
1235
- def fs_type(self, value: Optional[pulumi.Input[builtins.str]]):
1234
+ def fs_type(self, value: Optional[pulumi.Input[_builtins.str]]):
1236
1235
  pulumi.set(self, "fs_type", value)
1237
1236
 
1238
- @property
1237
+ @_builtins.property
1239
1238
  @pulumi.getter(name="mountFlags")
1240
- def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1239
+ def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
1241
1240
  """
1242
1241
  `[]string: optional` - The flags passed to `mount`.
1243
1242
  """
1244
1243
  return pulumi.get(self, "mount_flags")
1245
1244
 
1246
1245
  @mount_flags.setter
1247
- def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1246
+ def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
1248
1247
  pulumi.set(self, "mount_flags", value)
1249
1248
 
1250
1249
 
1251
1250
  if not MYPY:
1252
1251
  class CsiVolumeRegistrationCapabilityArgsDict(TypedDict):
1253
- access_mode: pulumi.Input[builtins.str]
1252
+ access_mode: pulumi.Input[_builtins.str]
1254
1253
  """
1255
1254
  `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1256
1255
  - `single-node-reader-only`
@@ -1259,7 +1258,7 @@ if not MYPY:
1259
1258
  - `multi-node-single-writer`
1260
1259
  - `multi-node-multi-writer`
1261
1260
  """
1262
- attachment_mode: pulumi.Input[builtins.str]
1261
+ attachment_mode: pulumi.Input[_builtins.str]
1263
1262
  """
1264
1263
  `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1265
1264
  - `block-device`
@@ -1271,25 +1270,25 @@ elif False:
1271
1270
  @pulumi.input_type
1272
1271
  class CsiVolumeRegistrationCapabilityArgs:
1273
1272
  def __init__(__self__, *,
1274
- access_mode: pulumi.Input[builtins.str],
1275
- attachment_mode: pulumi.Input[builtins.str]):
1273
+ access_mode: pulumi.Input[_builtins.str],
1274
+ attachment_mode: pulumi.Input[_builtins.str]):
1276
1275
  """
1277
- :param pulumi.Input[builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1276
+ :param pulumi.Input[_builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1278
1277
  - `single-node-reader-only`
1279
1278
  - `single-node-writer`
1280
1279
  - `multi-node-reader-only`
1281
1280
  - `multi-node-single-writer`
1282
1281
  - `multi-node-multi-writer`
1283
- :param pulumi.Input[builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1282
+ :param pulumi.Input[_builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1284
1283
  - `block-device`
1285
1284
  - `file-system`
1286
1285
  """
1287
1286
  pulumi.set(__self__, "access_mode", access_mode)
1288
1287
  pulumi.set(__self__, "attachment_mode", attachment_mode)
1289
1288
 
1290
- @property
1289
+ @_builtins.property
1291
1290
  @pulumi.getter(name="accessMode")
1292
- def access_mode(self) -> pulumi.Input[builtins.str]:
1291
+ def access_mode(self) -> pulumi.Input[_builtins.str]:
1293
1292
  """
1294
1293
  `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1295
1294
  - `single-node-reader-only`
@@ -1301,12 +1300,12 @@ class CsiVolumeRegistrationCapabilityArgs:
1301
1300
  return pulumi.get(self, "access_mode")
1302
1301
 
1303
1302
  @access_mode.setter
1304
- def access_mode(self, value: pulumi.Input[builtins.str]):
1303
+ def access_mode(self, value: pulumi.Input[_builtins.str]):
1305
1304
  pulumi.set(self, "access_mode", value)
1306
1305
 
1307
- @property
1306
+ @_builtins.property
1308
1307
  @pulumi.getter(name="attachmentMode")
1309
- def attachment_mode(self) -> pulumi.Input[builtins.str]:
1308
+ def attachment_mode(self) -> pulumi.Input[_builtins.str]:
1310
1309
  """
1311
1310
  `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1312
1311
  - `block-device`
@@ -1315,17 +1314,17 @@ class CsiVolumeRegistrationCapabilityArgs:
1315
1314
  return pulumi.get(self, "attachment_mode")
1316
1315
 
1317
1316
  @attachment_mode.setter
1318
- def attachment_mode(self, value: pulumi.Input[builtins.str]):
1317
+ def attachment_mode(self, value: pulumi.Input[_builtins.str]):
1319
1318
  pulumi.set(self, "attachment_mode", value)
1320
1319
 
1321
1320
 
1322
1321
  if not MYPY:
1323
1322
  class CsiVolumeRegistrationMountOptionsArgsDict(TypedDict):
1324
- fs_type: NotRequired[pulumi.Input[builtins.str]]
1323
+ fs_type: NotRequired[pulumi.Input[_builtins.str]]
1325
1324
  """
1326
1325
  `(string: <optional>)` - The file system type.
1327
1326
  """
1328
- mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1327
+ mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
1329
1328
  """
1330
1329
  `([]string: <optional>)` - The flags passed to `mount`.
1331
1330
  """
@@ -1335,45 +1334,45 @@ elif False:
1335
1334
  @pulumi.input_type
1336
1335
  class CsiVolumeRegistrationMountOptionsArgs:
1337
1336
  def __init__(__self__, *,
1338
- fs_type: Optional[pulumi.Input[builtins.str]] = None,
1339
- mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
1337
+ fs_type: Optional[pulumi.Input[_builtins.str]] = None,
1338
+ mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
1340
1339
  """
1341
- :param pulumi.Input[builtins.str] fs_type: `(string: <optional>)` - The file system type.
1342
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
1340
+ :param pulumi.Input[_builtins.str] fs_type: `(string: <optional>)` - The file system type.
1341
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
1343
1342
  """
1344
1343
  if fs_type is not None:
1345
1344
  pulumi.set(__self__, "fs_type", fs_type)
1346
1345
  if mount_flags is not None:
1347
1346
  pulumi.set(__self__, "mount_flags", mount_flags)
1348
1347
 
1349
- @property
1348
+ @_builtins.property
1350
1349
  @pulumi.getter(name="fsType")
1351
- def fs_type(self) -> Optional[pulumi.Input[builtins.str]]:
1350
+ def fs_type(self) -> Optional[pulumi.Input[_builtins.str]]:
1352
1351
  """
1353
1352
  `(string: <optional>)` - The file system type.
1354
1353
  """
1355
1354
  return pulumi.get(self, "fs_type")
1356
1355
 
1357
1356
  @fs_type.setter
1358
- def fs_type(self, value: Optional[pulumi.Input[builtins.str]]):
1357
+ def fs_type(self, value: Optional[pulumi.Input[_builtins.str]]):
1359
1358
  pulumi.set(self, "fs_type", value)
1360
1359
 
1361
- @property
1360
+ @_builtins.property
1362
1361
  @pulumi.getter(name="mountFlags")
1363
- def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1362
+ def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
1364
1363
  """
1365
1364
  `([]string: <optional>)` - The flags passed to `mount`.
1366
1365
  """
1367
1366
  return pulumi.get(self, "mount_flags")
1368
1367
 
1369
1368
  @mount_flags.setter
1370
- def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1369
+ def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
1371
1370
  pulumi.set(self, "mount_flags", value)
1372
1371
 
1373
1372
 
1374
1373
  if not MYPY:
1375
1374
  class CsiVolumeRegistrationTopologyArgsDict(TypedDict):
1376
- segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
1375
+ segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
1377
1376
  """
1378
1377
  `(map[string]string)` - Define the attributes for the topology request.
1379
1378
 
@@ -1386,9 +1385,9 @@ elif False:
1386
1385
  @pulumi.input_type
1387
1386
  class CsiVolumeRegistrationTopologyArgs:
1388
1387
  def __init__(__self__, *,
1389
- segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
1388
+ segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
1390
1389
  """
1391
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
1390
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
1392
1391
 
1393
1392
  In addition to the above arguments, the following attributes are exported and
1394
1393
  can be referenced:
@@ -1396,9 +1395,9 @@ class CsiVolumeRegistrationTopologyArgs:
1396
1395
  if segments is not None:
1397
1396
  pulumi.set(__self__, "segments", segments)
1398
1397
 
1399
- @property
1398
+ @_builtins.property
1400
1399
  @pulumi.getter
1401
- def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
1400
+ def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
1402
1401
  """
1403
1402
  `(map[string]string)` - Define the attributes for the topology request.
1404
1403
 
@@ -1408,7 +1407,7 @@ class CsiVolumeRegistrationTopologyArgs:
1408
1407
  return pulumi.get(self, "segments")
1409
1408
 
1410
1409
  @segments.setter
1411
- def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
1410
+ def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
1412
1411
  pulumi.set(self, "segments", value)
1413
1412
 
1414
1413
 
@@ -1431,7 +1430,7 @@ class CsiVolumeRegistrationTopologyRequestArgs:
1431
1430
  if required is not None:
1432
1431
  pulumi.set(__self__, "required", required)
1433
1432
 
1434
- @property
1433
+ @_builtins.property
1435
1434
  @pulumi.getter
1436
1435
  def required(self) -> Optional[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredArgs']]:
1437
1436
  """
@@ -1462,7 +1461,7 @@ class CsiVolumeRegistrationTopologyRequestRequiredArgs:
1462
1461
  """
1463
1462
  pulumi.set(__self__, "topologies", topologies)
1464
1463
 
1465
- @property
1464
+ @_builtins.property
1466
1465
  @pulumi.getter
1467
1466
  def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs']]]:
1468
1467
  """
@@ -1477,7 +1476,7 @@ class CsiVolumeRegistrationTopologyRequestRequiredArgs:
1477
1476
 
1478
1477
  if not MYPY:
1479
1478
  class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict(TypedDict):
1480
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
1479
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]
1481
1480
  """
1482
1481
  Define attributes for the topology request.
1483
1482
  """
@@ -1487,28 +1486,28 @@ elif False:
1487
1486
  @pulumi.input_type
1488
1487
  class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
1489
1488
  def __init__(__self__, *,
1490
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
1489
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
1491
1490
  """
1492
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define attributes for the topology request.
1491
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: Define attributes for the topology request.
1493
1492
  """
1494
1493
  pulumi.set(__self__, "segments", segments)
1495
1494
 
1496
- @property
1495
+ @_builtins.property
1497
1496
  @pulumi.getter
1498
- def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
1497
+ def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]:
1499
1498
  """
1500
1499
  Define attributes for the topology request.
1501
1500
  """
1502
1501
  return pulumi.get(self, "segments")
1503
1502
 
1504
1503
  @segments.setter
1505
- def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
1504
+ def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
1506
1505
  pulumi.set(self, "segments", value)
1507
1506
 
1508
1507
 
1509
1508
  if not MYPY:
1510
1509
  class CsiVolumeTopologyArgsDict(TypedDict):
1511
- segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
1510
+ segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
1512
1511
  """
1513
1512
  `(map[string]string)` - Define the attributes for the topology request.
1514
1513
 
@@ -1521,9 +1520,9 @@ elif False:
1521
1520
  @pulumi.input_type
1522
1521
  class CsiVolumeTopologyArgs:
1523
1522
  def __init__(__self__, *,
1524
- segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
1523
+ segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
1525
1524
  """
1526
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
1525
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
1527
1526
 
1528
1527
  In addition to the above arguments, the following attributes are exported and
1529
1528
  can be referenced:
@@ -1531,9 +1530,9 @@ class CsiVolumeTopologyArgs:
1531
1530
  if segments is not None:
1532
1531
  pulumi.set(__self__, "segments", segments)
1533
1532
 
1534
- @property
1533
+ @_builtins.property
1535
1534
  @pulumi.getter
1536
- def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
1535
+ def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
1537
1536
  """
1538
1537
  `(map[string]string)` - Define the attributes for the topology request.
1539
1538
 
@@ -1543,7 +1542,7 @@ class CsiVolumeTopologyArgs:
1543
1542
  return pulumi.get(self, "segments")
1544
1543
 
1545
1544
  @segments.setter
1546
- def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
1545
+ def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
1547
1546
  pulumi.set(self, "segments", value)
1548
1547
 
1549
1548
 
@@ -1574,7 +1573,7 @@ class CsiVolumeTopologyRequestArgs:
1574
1573
  if required is not None:
1575
1574
  pulumi.set(__self__, "required", required)
1576
1575
 
1577
- @property
1576
+ @_builtins.property
1578
1577
  @pulumi.getter
1579
1578
  def preferred(self) -> Optional[pulumi.Input['CsiVolumeTopologyRequestPreferredArgs']]:
1580
1579
  """
@@ -1586,7 +1585,7 @@ class CsiVolumeTopologyRequestArgs:
1586
1585
  def preferred(self, value: Optional[pulumi.Input['CsiVolumeTopologyRequestPreferredArgs']]):
1587
1586
  pulumi.set(self, "preferred", value)
1588
1587
 
1589
- @property
1588
+ @_builtins.property
1590
1589
  @pulumi.getter
1591
1590
  def required(self) -> Optional[pulumi.Input['CsiVolumeTopologyRequestRequiredArgs']]:
1592
1591
  """
@@ -1617,7 +1616,7 @@ class CsiVolumeTopologyRequestPreferredArgs:
1617
1616
  """
1618
1617
  pulumi.set(__self__, "topologies", topologies)
1619
1618
 
1620
- @property
1619
+ @_builtins.property
1621
1620
  @pulumi.getter
1622
1621
  def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestPreferredTopologyArgs']]]:
1623
1622
  """
@@ -1632,7 +1631,7 @@ class CsiVolumeTopologyRequestPreferredArgs:
1632
1631
 
1633
1632
  if not MYPY:
1634
1633
  class CsiVolumeTopologyRequestPreferredTopologyArgsDict(TypedDict):
1635
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
1634
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]
1636
1635
  """
1637
1636
  Define the attributes for the topology request.
1638
1637
  """
@@ -1642,22 +1641,22 @@ elif False:
1642
1641
  @pulumi.input_type
1643
1642
  class CsiVolumeTopologyRequestPreferredTopologyArgs:
1644
1643
  def __init__(__self__, *,
1645
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
1644
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
1646
1645
  """
1647
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define the attributes for the topology request.
1646
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: Define the attributes for the topology request.
1648
1647
  """
1649
1648
  pulumi.set(__self__, "segments", segments)
1650
1649
 
1651
- @property
1650
+ @_builtins.property
1652
1651
  @pulumi.getter
1653
- def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
1652
+ def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]:
1654
1653
  """
1655
1654
  Define the attributes for the topology request.
1656
1655
  """
1657
1656
  return pulumi.get(self, "segments")
1658
1657
 
1659
1658
  @segments.setter
1660
- def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
1659
+ def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
1661
1660
  pulumi.set(self, "segments", value)
1662
1661
 
1663
1662
 
@@ -1679,7 +1678,7 @@ class CsiVolumeTopologyRequestRequiredArgs:
1679
1678
  """
1680
1679
  pulumi.set(__self__, "topologies", topologies)
1681
1680
 
1682
- @property
1681
+ @_builtins.property
1683
1682
  @pulumi.getter
1684
1683
  def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestRequiredTopologyArgs']]]:
1685
1684
  """
@@ -1694,7 +1693,7 @@ class CsiVolumeTopologyRequestRequiredArgs:
1694
1693
 
1695
1694
  if not MYPY:
1696
1695
  class CsiVolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
1697
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
1696
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]
1698
1697
  """
1699
1698
  Define the attributes for the topology request.
1700
1699
  """
@@ -1704,33 +1703,33 @@ elif False:
1704
1703
  @pulumi.input_type
1705
1704
  class CsiVolumeTopologyRequestRequiredTopologyArgs:
1706
1705
  def __init__(__self__, *,
1707
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
1706
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
1708
1707
  """
1709
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define the attributes for the topology request.
1708
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: Define the attributes for the topology request.
1710
1709
  """
1711
1710
  pulumi.set(__self__, "segments", segments)
1712
1711
 
1713
- @property
1712
+ @_builtins.property
1714
1713
  @pulumi.getter
1715
- def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
1714
+ def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]:
1716
1715
  """
1717
1716
  Define the attributes for the topology request.
1718
1717
  """
1719
1718
  return pulumi.get(self, "segments")
1720
1719
 
1721
1720
  @segments.setter
1722
- def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
1721
+ def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
1723
1722
  pulumi.set(self, "segments", value)
1724
1723
 
1725
1724
 
1726
1725
  if not MYPY:
1727
1726
  class DynamicHostVolumeCapabilityArgsDict(TypedDict):
1728
- access_mode: pulumi.Input[builtins.str]
1727
+ access_mode: pulumi.Input[_builtins.str]
1729
1728
  """
1730
1729
  `(string)` - How the volume can be mounted by
1731
1730
  allocations. Refer to the [`access_mode`][] documentation for details.
1732
1731
  """
1733
- attachment_mode: pulumi.Input[builtins.str]
1732
+ attachment_mode: pulumi.Input[_builtins.str]
1734
1733
  """
1735
1734
  `(string)` - The storage API that will be used by the
1736
1735
  volume. Refer to the [`attachment_mode`][] documentation.
@@ -1741,20 +1740,20 @@ elif False:
1741
1740
  @pulumi.input_type
1742
1741
  class DynamicHostVolumeCapabilityArgs:
1743
1742
  def __init__(__self__, *,
1744
- access_mode: pulumi.Input[builtins.str],
1745
- attachment_mode: pulumi.Input[builtins.str]):
1743
+ access_mode: pulumi.Input[_builtins.str],
1744
+ attachment_mode: pulumi.Input[_builtins.str]):
1746
1745
  """
1747
- :param pulumi.Input[builtins.str] access_mode: `(string)` - How the volume can be mounted by
1746
+ :param pulumi.Input[_builtins.str] access_mode: `(string)` - How the volume can be mounted by
1748
1747
  allocations. Refer to the [`access_mode`][] documentation for details.
1749
- :param pulumi.Input[builtins.str] attachment_mode: `(string)` - The storage API that will be used by the
1748
+ :param pulumi.Input[_builtins.str] attachment_mode: `(string)` - The storage API that will be used by the
1750
1749
  volume. Refer to the [`attachment_mode`][] documentation.
1751
1750
  """
1752
1751
  pulumi.set(__self__, "access_mode", access_mode)
1753
1752
  pulumi.set(__self__, "attachment_mode", attachment_mode)
1754
1753
 
1755
- @property
1754
+ @_builtins.property
1756
1755
  @pulumi.getter(name="accessMode")
1757
- def access_mode(self) -> pulumi.Input[builtins.str]:
1756
+ def access_mode(self) -> pulumi.Input[_builtins.str]:
1758
1757
  """
1759
1758
  `(string)` - How the volume can be mounted by
1760
1759
  allocations. Refer to the [`access_mode`][] documentation for details.
@@ -1762,12 +1761,12 @@ class DynamicHostVolumeCapabilityArgs:
1762
1761
  return pulumi.get(self, "access_mode")
1763
1762
 
1764
1763
  @access_mode.setter
1765
- def access_mode(self, value: pulumi.Input[builtins.str]):
1764
+ def access_mode(self, value: pulumi.Input[_builtins.str]):
1766
1765
  pulumi.set(self, "access_mode", value)
1767
1766
 
1768
- @property
1767
+ @_builtins.property
1769
1768
  @pulumi.getter(name="attachmentMode")
1770
- def attachment_mode(self) -> pulumi.Input[builtins.str]:
1769
+ def attachment_mode(self) -> pulumi.Input[_builtins.str]:
1771
1770
  """
1772
1771
  `(string)` - The storage API that will be used by the
1773
1772
  volume. Refer to the [`attachment_mode`][] documentation.
@@ -1775,21 +1774,21 @@ class DynamicHostVolumeCapabilityArgs:
1775
1774
  return pulumi.get(self, "attachment_mode")
1776
1775
 
1777
1776
  @attachment_mode.setter
1778
- def attachment_mode(self, value: pulumi.Input[builtins.str]):
1777
+ def attachment_mode(self, value: pulumi.Input[_builtins.str]):
1779
1778
  pulumi.set(self, "attachment_mode", value)
1780
1779
 
1781
1780
 
1782
1781
  if not MYPY:
1783
1782
  class DynamicHostVolumeConstraintArgsDict(TypedDict):
1784
- attribute: pulumi.Input[builtins.str]
1783
+ attribute: pulumi.Input[_builtins.str]
1785
1784
  """
1786
1785
  `(string)` - The [node attribute][] to check for the constraint.
1787
1786
  """
1788
- operator: NotRequired[pulumi.Input[builtins.str]]
1787
+ operator: NotRequired[pulumi.Input[_builtins.str]]
1789
1788
  """
1790
1789
  `(string)`- The operator to use in the comparison.
1791
1790
  """
1792
- value: NotRequired[pulumi.Input[builtins.str]]
1791
+ value: NotRequired[pulumi.Input[_builtins.str]]
1793
1792
  """
1794
1793
  `(string)` - The value of the attribute to compare against.
1795
1794
  """
@@ -1799,13 +1798,13 @@ elif False:
1799
1798
  @pulumi.input_type
1800
1799
  class DynamicHostVolumeConstraintArgs:
1801
1800
  def __init__(__self__, *,
1802
- attribute: pulumi.Input[builtins.str],
1803
- operator: Optional[pulumi.Input[builtins.str]] = None,
1804
- value: Optional[pulumi.Input[builtins.str]] = None):
1801
+ attribute: pulumi.Input[_builtins.str],
1802
+ operator: Optional[pulumi.Input[_builtins.str]] = None,
1803
+ value: Optional[pulumi.Input[_builtins.str]] = None):
1805
1804
  """
1806
- :param pulumi.Input[builtins.str] attribute: `(string)` - The [node attribute][] to check for the constraint.
1807
- :param pulumi.Input[builtins.str] operator: `(string)`- The operator to use in the comparison.
1808
- :param pulumi.Input[builtins.str] value: `(string)` - The value of the attribute to compare against.
1805
+ :param pulumi.Input[_builtins.str] attribute: `(string)` - The [node attribute][] to check for the constraint.
1806
+ :param pulumi.Input[_builtins.str] operator: `(string)`- The operator to use in the comparison.
1807
+ :param pulumi.Input[_builtins.str] value: `(string)` - The value of the attribute to compare against.
1809
1808
  """
1810
1809
  pulumi.set(__self__, "attribute", attribute)
1811
1810
  if operator is not None:
@@ -1813,51 +1812,51 @@ class DynamicHostVolumeConstraintArgs:
1813
1812
  if value is not None:
1814
1813
  pulumi.set(__self__, "value", value)
1815
1814
 
1816
- @property
1815
+ @_builtins.property
1817
1816
  @pulumi.getter
1818
- def attribute(self) -> pulumi.Input[builtins.str]:
1817
+ def attribute(self) -> pulumi.Input[_builtins.str]:
1819
1818
  """
1820
1819
  `(string)` - The [node attribute][] to check for the constraint.
1821
1820
  """
1822
1821
  return pulumi.get(self, "attribute")
1823
1822
 
1824
1823
  @attribute.setter
1825
- def attribute(self, value: pulumi.Input[builtins.str]):
1824
+ def attribute(self, value: pulumi.Input[_builtins.str]):
1826
1825
  pulumi.set(self, "attribute", value)
1827
1826
 
1828
- @property
1827
+ @_builtins.property
1829
1828
  @pulumi.getter
1830
- def operator(self) -> Optional[pulumi.Input[builtins.str]]:
1829
+ def operator(self) -> Optional[pulumi.Input[_builtins.str]]:
1831
1830
  """
1832
1831
  `(string)`- The operator to use in the comparison.
1833
1832
  """
1834
1833
  return pulumi.get(self, "operator")
1835
1834
 
1836
1835
  @operator.setter
1837
- def operator(self, value: Optional[pulumi.Input[builtins.str]]):
1836
+ def operator(self, value: Optional[pulumi.Input[_builtins.str]]):
1838
1837
  pulumi.set(self, "operator", value)
1839
1838
 
1840
- @property
1839
+ @_builtins.property
1841
1840
  @pulumi.getter
1842
- def value(self) -> Optional[pulumi.Input[builtins.str]]:
1841
+ def value(self) -> Optional[pulumi.Input[_builtins.str]]:
1843
1842
  """
1844
1843
  `(string)` - The value of the attribute to compare against.
1845
1844
  """
1846
1845
  return pulumi.get(self, "value")
1847
1846
 
1848
1847
  @value.setter
1849
- def value(self, value: Optional[pulumi.Input[builtins.str]]):
1848
+ def value(self, value: Optional[pulumi.Input[_builtins.str]]):
1850
1849
  pulumi.set(self, "value", value)
1851
1850
 
1852
1851
 
1853
1852
  if not MYPY:
1854
1853
  class DynamicHostVolumeRegistrationCapabilityArgsDict(TypedDict):
1855
- access_mode: pulumi.Input[builtins.str]
1854
+ access_mode: pulumi.Input[_builtins.str]
1856
1855
  """
1857
1856
  `(string)` - How the volume can be mounted by
1858
1857
  allocations. Refer to the [`access_mode`][] documentation for details.
1859
1858
  """
1860
- attachment_mode: pulumi.Input[builtins.str]
1859
+ attachment_mode: pulumi.Input[_builtins.str]
1861
1860
  """
1862
1861
  `(string)` - The storage API that will be used by the
1863
1862
  volume. Refer to the [`attachment_mode`][] documentation.
@@ -1868,20 +1867,20 @@ elif False:
1868
1867
  @pulumi.input_type
1869
1868
  class DynamicHostVolumeRegistrationCapabilityArgs:
1870
1869
  def __init__(__self__, *,
1871
- access_mode: pulumi.Input[builtins.str],
1872
- attachment_mode: pulumi.Input[builtins.str]):
1870
+ access_mode: pulumi.Input[_builtins.str],
1871
+ attachment_mode: pulumi.Input[_builtins.str]):
1873
1872
  """
1874
- :param pulumi.Input[builtins.str] access_mode: `(string)` - How the volume can be mounted by
1873
+ :param pulumi.Input[_builtins.str] access_mode: `(string)` - How the volume can be mounted by
1875
1874
  allocations. Refer to the [`access_mode`][] documentation for details.
1876
- :param pulumi.Input[builtins.str] attachment_mode: `(string)` - The storage API that will be used by the
1875
+ :param pulumi.Input[_builtins.str] attachment_mode: `(string)` - The storage API that will be used by the
1877
1876
  volume. Refer to the [`attachment_mode`][] documentation.
1878
1877
  """
1879
1878
  pulumi.set(__self__, "access_mode", access_mode)
1880
1879
  pulumi.set(__self__, "attachment_mode", attachment_mode)
1881
1880
 
1882
- @property
1881
+ @_builtins.property
1883
1882
  @pulumi.getter(name="accessMode")
1884
- def access_mode(self) -> pulumi.Input[builtins.str]:
1883
+ def access_mode(self) -> pulumi.Input[_builtins.str]:
1885
1884
  """
1886
1885
  `(string)` - How the volume can be mounted by
1887
1886
  allocations. Refer to the [`access_mode`][] documentation for details.
@@ -1889,12 +1888,12 @@ class DynamicHostVolumeRegistrationCapabilityArgs:
1889
1888
  return pulumi.get(self, "access_mode")
1890
1889
 
1891
1890
  @access_mode.setter
1892
- def access_mode(self, value: pulumi.Input[builtins.str]):
1891
+ def access_mode(self, value: pulumi.Input[_builtins.str]):
1893
1892
  pulumi.set(self, "access_mode", value)
1894
1893
 
1895
- @property
1894
+ @_builtins.property
1896
1895
  @pulumi.getter(name="attachmentMode")
1897
- def attachment_mode(self) -> pulumi.Input[builtins.str]:
1896
+ def attachment_mode(self) -> pulumi.Input[_builtins.str]:
1898
1897
  """
1899
1898
  `(string)` - The storage API that will be used by the
1900
1899
  volume. Refer to the [`attachment_mode`][] documentation.
@@ -1902,21 +1901,21 @@ class DynamicHostVolumeRegistrationCapabilityArgs:
1902
1901
  return pulumi.get(self, "attachment_mode")
1903
1902
 
1904
1903
  @attachment_mode.setter
1905
- def attachment_mode(self, value: pulumi.Input[builtins.str]):
1904
+ def attachment_mode(self, value: pulumi.Input[_builtins.str]):
1906
1905
  pulumi.set(self, "attachment_mode", value)
1907
1906
 
1908
1907
 
1909
1908
  if not MYPY:
1910
1909
  class DynamicHostVolumeRegistrationConstraintArgsDict(TypedDict):
1911
- attribute: pulumi.Input[builtins.str]
1910
+ attribute: pulumi.Input[_builtins.str]
1912
1911
  """
1913
1912
  An attribute to check to constrain volume placement
1914
1913
  """
1915
- operator: NotRequired[pulumi.Input[builtins.str]]
1914
+ operator: NotRequired[pulumi.Input[_builtins.str]]
1916
1915
  """
1917
1916
  The operator to use for comparison
1918
1917
  """
1919
- value: NotRequired[pulumi.Input[builtins.str]]
1918
+ value: NotRequired[pulumi.Input[_builtins.str]]
1920
1919
  """
1921
1920
  The requested value of the attribute
1922
1921
  """
@@ -1926,13 +1925,13 @@ elif False:
1926
1925
  @pulumi.input_type
1927
1926
  class DynamicHostVolumeRegistrationConstraintArgs:
1928
1927
  def __init__(__self__, *,
1929
- attribute: pulumi.Input[builtins.str],
1930
- operator: Optional[pulumi.Input[builtins.str]] = None,
1931
- value: Optional[pulumi.Input[builtins.str]] = None):
1928
+ attribute: pulumi.Input[_builtins.str],
1929
+ operator: Optional[pulumi.Input[_builtins.str]] = None,
1930
+ value: Optional[pulumi.Input[_builtins.str]] = None):
1932
1931
  """
1933
- :param pulumi.Input[builtins.str] attribute: An attribute to check to constrain volume placement
1934
- :param pulumi.Input[builtins.str] operator: The operator to use for comparison
1935
- :param pulumi.Input[builtins.str] value: The requested value of the attribute
1932
+ :param pulumi.Input[_builtins.str] attribute: An attribute to check to constrain volume placement
1933
+ :param pulumi.Input[_builtins.str] operator: The operator to use for comparison
1934
+ :param pulumi.Input[_builtins.str] value: The requested value of the attribute
1936
1935
  """
1937
1936
  pulumi.set(__self__, "attribute", attribute)
1938
1937
  if operator is not None:
@@ -1940,46 +1939,46 @@ class DynamicHostVolumeRegistrationConstraintArgs:
1940
1939
  if value is not None:
1941
1940
  pulumi.set(__self__, "value", value)
1942
1941
 
1943
- @property
1942
+ @_builtins.property
1944
1943
  @pulumi.getter
1945
- def attribute(self) -> pulumi.Input[builtins.str]:
1944
+ def attribute(self) -> pulumi.Input[_builtins.str]:
1946
1945
  """
1947
1946
  An attribute to check to constrain volume placement
1948
1947
  """
1949
1948
  return pulumi.get(self, "attribute")
1950
1949
 
1951
1950
  @attribute.setter
1952
- def attribute(self, value: pulumi.Input[builtins.str]):
1951
+ def attribute(self, value: pulumi.Input[_builtins.str]):
1953
1952
  pulumi.set(self, "attribute", value)
1954
1953
 
1955
- @property
1954
+ @_builtins.property
1956
1955
  @pulumi.getter
1957
- def operator(self) -> Optional[pulumi.Input[builtins.str]]:
1956
+ def operator(self) -> Optional[pulumi.Input[_builtins.str]]:
1958
1957
  """
1959
1958
  The operator to use for comparison
1960
1959
  """
1961
1960
  return pulumi.get(self, "operator")
1962
1961
 
1963
1962
  @operator.setter
1964
- def operator(self, value: Optional[pulumi.Input[builtins.str]]):
1963
+ def operator(self, value: Optional[pulumi.Input[_builtins.str]]):
1965
1964
  pulumi.set(self, "operator", value)
1966
1965
 
1967
- @property
1966
+ @_builtins.property
1968
1967
  @pulumi.getter
1969
- def value(self) -> Optional[pulumi.Input[builtins.str]]:
1968
+ def value(self) -> Optional[pulumi.Input[_builtins.str]]:
1970
1969
  """
1971
1970
  The requested value of the attribute
1972
1971
  """
1973
1972
  return pulumi.get(self, "value")
1974
1973
 
1975
1974
  @value.setter
1976
- def value(self, value: Optional[pulumi.Input[builtins.str]]):
1975
+ def value(self, value: Optional[pulumi.Input[_builtins.str]]):
1977
1976
  pulumi.set(self, "value", value)
1978
1977
 
1979
1978
 
1980
1979
  if not MYPY:
1981
1980
  class ExternalVolumeCapabilityArgsDict(TypedDict):
1982
- access_mode: pulumi.Input[builtins.str]
1981
+ access_mode: pulumi.Input[_builtins.str]
1983
1982
  """
1984
1983
  `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1985
1984
  - `single-node-reader-only`
@@ -1988,7 +1987,7 @@ if not MYPY:
1988
1987
  - `multi-node-single-writer`
1989
1988
  - `multi-node-multi-writer`
1990
1989
  """
1991
- attachment_mode: pulumi.Input[builtins.str]
1990
+ attachment_mode: pulumi.Input[_builtins.str]
1992
1991
  """
1993
1992
  `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1994
1993
  - `block-device`
@@ -2000,25 +1999,25 @@ elif False:
2000
1999
  @pulumi.input_type
2001
2000
  class ExternalVolumeCapabilityArgs:
2002
2001
  def __init__(__self__, *,
2003
- access_mode: pulumi.Input[builtins.str],
2004
- attachment_mode: pulumi.Input[builtins.str]):
2002
+ access_mode: pulumi.Input[_builtins.str],
2003
+ attachment_mode: pulumi.Input[_builtins.str]):
2005
2004
  """
2006
- :param pulumi.Input[builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
2005
+ :param pulumi.Input[_builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
2007
2006
  - `single-node-reader-only`
2008
2007
  - `single-node-writer`
2009
2008
  - `multi-node-reader-only`
2010
2009
  - `multi-node-single-writer`
2011
2010
  - `multi-node-multi-writer`
2012
- :param pulumi.Input[builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
2011
+ :param pulumi.Input[_builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
2013
2012
  - `block-device`
2014
2013
  - `file-system`
2015
2014
  """
2016
2015
  pulumi.set(__self__, "access_mode", access_mode)
2017
2016
  pulumi.set(__self__, "attachment_mode", attachment_mode)
2018
2017
 
2019
- @property
2018
+ @_builtins.property
2020
2019
  @pulumi.getter(name="accessMode")
2021
- def access_mode(self) -> pulumi.Input[builtins.str]:
2020
+ def access_mode(self) -> pulumi.Input[_builtins.str]:
2022
2021
  """
2023
2022
  `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
2024
2023
  - `single-node-reader-only`
@@ -2030,12 +2029,12 @@ class ExternalVolumeCapabilityArgs:
2030
2029
  return pulumi.get(self, "access_mode")
2031
2030
 
2032
2031
  @access_mode.setter
2033
- def access_mode(self, value: pulumi.Input[builtins.str]):
2032
+ def access_mode(self, value: pulumi.Input[_builtins.str]):
2034
2033
  pulumi.set(self, "access_mode", value)
2035
2034
 
2036
- @property
2035
+ @_builtins.property
2037
2036
  @pulumi.getter(name="attachmentMode")
2038
- def attachment_mode(self) -> pulumi.Input[builtins.str]:
2037
+ def attachment_mode(self) -> pulumi.Input[_builtins.str]:
2039
2038
  """
2040
2039
  `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
2041
2040
  - `block-device`
@@ -2044,17 +2043,17 @@ class ExternalVolumeCapabilityArgs:
2044
2043
  return pulumi.get(self, "attachment_mode")
2045
2044
 
2046
2045
  @attachment_mode.setter
2047
- def attachment_mode(self, value: pulumi.Input[builtins.str]):
2046
+ def attachment_mode(self, value: pulumi.Input[_builtins.str]):
2048
2047
  pulumi.set(self, "attachment_mode", value)
2049
2048
 
2050
2049
 
2051
2050
  if not MYPY:
2052
2051
  class ExternalVolumeMountOptionsArgsDict(TypedDict):
2053
- fs_type: NotRequired[pulumi.Input[builtins.str]]
2052
+ fs_type: NotRequired[pulumi.Input[_builtins.str]]
2054
2053
  """
2055
2054
  `(string: optional)` - The file system type.
2056
2055
  """
2057
- mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2056
+ mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
2058
2057
  """
2059
2058
  `[]string: optional` - The flags passed to `mount`.
2060
2059
  """
@@ -2064,45 +2063,45 @@ elif False:
2064
2063
  @pulumi.input_type
2065
2064
  class ExternalVolumeMountOptionsArgs:
2066
2065
  def __init__(__self__, *,
2067
- fs_type: Optional[pulumi.Input[builtins.str]] = None,
2068
- mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
2066
+ fs_type: Optional[pulumi.Input[_builtins.str]] = None,
2067
+ mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
2069
2068
  """
2070
- :param pulumi.Input[builtins.str] fs_type: `(string: optional)` - The file system type.
2071
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mount_flags: `[]string: optional` - The flags passed to `mount`.
2069
+ :param pulumi.Input[_builtins.str] fs_type: `(string: optional)` - The file system type.
2070
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] mount_flags: `[]string: optional` - The flags passed to `mount`.
2072
2071
  """
2073
2072
  if fs_type is not None:
2074
2073
  pulumi.set(__self__, "fs_type", fs_type)
2075
2074
  if mount_flags is not None:
2076
2075
  pulumi.set(__self__, "mount_flags", mount_flags)
2077
2076
 
2078
- @property
2077
+ @_builtins.property
2079
2078
  @pulumi.getter(name="fsType")
2080
- def fs_type(self) -> Optional[pulumi.Input[builtins.str]]:
2079
+ def fs_type(self) -> Optional[pulumi.Input[_builtins.str]]:
2081
2080
  """
2082
2081
  `(string: optional)` - The file system type.
2083
2082
  """
2084
2083
  return pulumi.get(self, "fs_type")
2085
2084
 
2086
2085
  @fs_type.setter
2087
- def fs_type(self, value: Optional[pulumi.Input[builtins.str]]):
2086
+ def fs_type(self, value: Optional[pulumi.Input[_builtins.str]]):
2088
2087
  pulumi.set(self, "fs_type", value)
2089
2088
 
2090
- @property
2089
+ @_builtins.property
2091
2090
  @pulumi.getter(name="mountFlags")
2092
- def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2091
+ def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
2093
2092
  """
2094
2093
  `[]string: optional` - The flags passed to `mount`.
2095
2094
  """
2096
2095
  return pulumi.get(self, "mount_flags")
2097
2096
 
2098
2097
  @mount_flags.setter
2099
- def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2098
+ def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
2100
2099
  pulumi.set(self, "mount_flags", value)
2101
2100
 
2102
2101
 
2103
2102
  if not MYPY:
2104
2103
  class ExternalVolumeTopologyArgsDict(TypedDict):
2105
- segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
2104
+ segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
2106
2105
  """
2107
2106
  `(map[string]string)` - Define the attributes for the topology request.
2108
2107
 
@@ -2115,9 +2114,9 @@ elif False:
2115
2114
  @pulumi.input_type
2116
2115
  class ExternalVolumeTopologyArgs:
2117
2116
  def __init__(__self__, *,
2118
- segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
2117
+ segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
2119
2118
  """
2120
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
2119
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
2121
2120
 
2122
2121
  In addition to the above arguments, the following attributes are exported and
2123
2122
  can be referenced:
@@ -2125,9 +2124,9 @@ class ExternalVolumeTopologyArgs:
2125
2124
  if segments is not None:
2126
2125
  pulumi.set(__self__, "segments", segments)
2127
2126
 
2128
- @property
2127
+ @_builtins.property
2129
2128
  @pulumi.getter
2130
- def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
2129
+ def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
2131
2130
  """
2132
2131
  `(map[string]string)` - Define the attributes for the topology request.
2133
2132
 
@@ -2137,7 +2136,7 @@ class ExternalVolumeTopologyArgs:
2137
2136
  return pulumi.get(self, "segments")
2138
2137
 
2139
2138
  @segments.setter
2140
- def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
2139
+ def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
2141
2140
  pulumi.set(self, "segments", value)
2142
2141
 
2143
2142
 
@@ -2168,7 +2167,7 @@ class ExternalVolumeTopologyRequestArgs:
2168
2167
  if required is not None:
2169
2168
  pulumi.set(__self__, "required", required)
2170
2169
 
2171
- @property
2170
+ @_builtins.property
2172
2171
  @pulumi.getter
2173
2172
  def preferred(self) -> Optional[pulumi.Input['ExternalVolumeTopologyRequestPreferredArgs']]:
2174
2173
  """
@@ -2180,7 +2179,7 @@ class ExternalVolumeTopologyRequestArgs:
2180
2179
  def preferred(self, value: Optional[pulumi.Input['ExternalVolumeTopologyRequestPreferredArgs']]):
2181
2180
  pulumi.set(self, "preferred", value)
2182
2181
 
2183
- @property
2182
+ @_builtins.property
2184
2183
  @pulumi.getter
2185
2184
  def required(self) -> Optional[pulumi.Input['ExternalVolumeTopologyRequestRequiredArgs']]:
2186
2185
  """
@@ -2211,7 +2210,7 @@ class ExternalVolumeTopologyRequestPreferredArgs:
2211
2210
  """
2212
2211
  pulumi.set(__self__, "topologies", topologies)
2213
2212
 
2214
- @property
2213
+ @_builtins.property
2215
2214
  @pulumi.getter
2216
2215
  def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestPreferredTopologyArgs']]]:
2217
2216
  """
@@ -2226,7 +2225,7 @@ class ExternalVolumeTopologyRequestPreferredArgs:
2226
2225
 
2227
2226
  if not MYPY:
2228
2227
  class ExternalVolumeTopologyRequestPreferredTopologyArgsDict(TypedDict):
2229
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
2228
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]
2230
2229
  """
2231
2230
  Define the attributes for the topology request.
2232
2231
  """
@@ -2236,22 +2235,22 @@ elif False:
2236
2235
  @pulumi.input_type
2237
2236
  class ExternalVolumeTopologyRequestPreferredTopologyArgs:
2238
2237
  def __init__(__self__, *,
2239
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
2238
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
2240
2239
  """
2241
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define the attributes for the topology request.
2240
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: Define the attributes for the topology request.
2242
2241
  """
2243
2242
  pulumi.set(__self__, "segments", segments)
2244
2243
 
2245
- @property
2244
+ @_builtins.property
2246
2245
  @pulumi.getter
2247
- def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
2246
+ def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]:
2248
2247
  """
2249
2248
  Define the attributes for the topology request.
2250
2249
  """
2251
2250
  return pulumi.get(self, "segments")
2252
2251
 
2253
2252
  @segments.setter
2254
- def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
2253
+ def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
2255
2254
  pulumi.set(self, "segments", value)
2256
2255
 
2257
2256
 
@@ -2273,7 +2272,7 @@ class ExternalVolumeTopologyRequestRequiredArgs:
2273
2272
  """
2274
2273
  pulumi.set(__self__, "topologies", topologies)
2275
2274
 
2276
- @property
2275
+ @_builtins.property
2277
2276
  @pulumi.getter
2278
2277
  def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestRequiredTopologyArgs']]]:
2279
2278
  """
@@ -2288,7 +2287,7 @@ class ExternalVolumeTopologyRequestRequiredArgs:
2288
2287
 
2289
2288
  if not MYPY:
2290
2289
  class ExternalVolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
2291
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
2290
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]
2292
2291
  """
2293
2292
  Define the attributes for the topology request.
2294
2293
  """
@@ -2298,33 +2297,33 @@ elif False:
2298
2297
  @pulumi.input_type
2299
2298
  class ExternalVolumeTopologyRequestRequiredTopologyArgs:
2300
2299
  def __init__(__self__, *,
2301
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
2300
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
2302
2301
  """
2303
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define the attributes for the topology request.
2302
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: Define the attributes for the topology request.
2304
2303
  """
2305
2304
  pulumi.set(__self__, "segments", segments)
2306
2305
 
2307
- @property
2306
+ @_builtins.property
2308
2307
  @pulumi.getter
2309
- def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
2308
+ def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]:
2310
2309
  """
2311
2310
  Define the attributes for the topology request.
2312
2311
  """
2313
2312
  return pulumi.get(self, "segments")
2314
2313
 
2315
2314
  @segments.setter
2316
- def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
2315
+ def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
2317
2316
  pulumi.set(self, "segments", value)
2318
2317
 
2319
2318
 
2320
2319
  if not MYPY:
2321
2320
  class JobHcl2ArgsDict(TypedDict):
2322
- allow_fs: NotRequired[pulumi.Input[builtins.bool]]
2321
+ allow_fs: NotRequired[pulumi.Input[_builtins.bool]]
2323
2322
  """
2324
2323
  `(boolean: false)` - Set this to `true` to be able to use
2325
2324
  HCL2 filesystem functions
2326
2325
  """
2327
- vars: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
2326
+ vars: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
2328
2327
  """
2329
2328
  Additional variables to use when templating the job with HCL2
2330
2329
  """
@@ -2334,21 +2333,21 @@ elif False:
2334
2333
  @pulumi.input_type
2335
2334
  class JobHcl2Args:
2336
2335
  def __init__(__self__, *,
2337
- allow_fs: Optional[pulumi.Input[builtins.bool]] = None,
2338
- vars: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
2336
+ allow_fs: Optional[pulumi.Input[_builtins.bool]] = None,
2337
+ vars: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
2339
2338
  """
2340
- :param pulumi.Input[builtins.bool] allow_fs: `(boolean: false)` - Set this to `true` to be able to use
2339
+ :param pulumi.Input[_builtins.bool] allow_fs: `(boolean: false)` - Set this to `true` to be able to use
2341
2340
  HCL2 filesystem functions
2342
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] vars: Additional variables to use when templating the job with HCL2
2341
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] vars: Additional variables to use when templating the job with HCL2
2343
2342
  """
2344
2343
  if allow_fs is not None:
2345
2344
  pulumi.set(__self__, "allow_fs", allow_fs)
2346
2345
  if vars is not None:
2347
2346
  pulumi.set(__self__, "vars", vars)
2348
2347
 
2349
- @property
2348
+ @_builtins.property
2350
2349
  @pulumi.getter(name="allowFs")
2351
- def allow_fs(self) -> Optional[pulumi.Input[builtins.bool]]:
2350
+ def allow_fs(self) -> Optional[pulumi.Input[_builtins.bool]]:
2352
2351
  """
2353
2352
  `(boolean: false)` - Set this to `true` to be able to use
2354
2353
  HCL2 filesystem functions
@@ -2356,27 +2355,27 @@ class JobHcl2Args:
2356
2355
  return pulumi.get(self, "allow_fs")
2357
2356
 
2358
2357
  @allow_fs.setter
2359
- def allow_fs(self, value: Optional[pulumi.Input[builtins.bool]]):
2358
+ def allow_fs(self, value: Optional[pulumi.Input[_builtins.bool]]):
2360
2359
  pulumi.set(self, "allow_fs", value)
2361
2360
 
2362
- @property
2361
+ @_builtins.property
2363
2362
  @pulumi.getter
2364
- def vars(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
2363
+ def vars(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
2365
2364
  """
2366
2365
  Additional variables to use when templating the job with HCL2
2367
2366
  """
2368
2367
  return pulumi.get(self, "vars")
2369
2368
 
2370
2369
  @vars.setter
2371
- def vars(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
2370
+ def vars(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
2372
2371
  pulumi.set(self, "vars", value)
2373
2372
 
2374
2373
 
2375
2374
  if not MYPY:
2376
2375
  class JobTaskGroupArgsDict(TypedDict):
2377
- count: NotRequired[pulumi.Input[builtins.int]]
2378
- meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
2379
- name: NotRequired[pulumi.Input[builtins.str]]
2376
+ count: NotRequired[pulumi.Input[_builtins.int]]
2377
+ meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
2378
+ name: NotRequired[pulumi.Input[_builtins.str]]
2380
2379
  tasks: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgsDict']]]]
2381
2380
  volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgsDict']]]]
2382
2381
  elif False:
@@ -2385,9 +2384,9 @@ elif False:
2385
2384
  @pulumi.input_type
2386
2385
  class JobTaskGroupArgs:
2387
2386
  def __init__(__self__, *,
2388
- count: Optional[pulumi.Input[builtins.int]] = None,
2389
- meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
2390
- name: Optional[pulumi.Input[builtins.str]] = None,
2387
+ count: Optional[pulumi.Input[_builtins.int]] = None,
2388
+ meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
2389
+ name: Optional[pulumi.Input[_builtins.str]] = None,
2391
2390
  tasks: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgs']]]] = None,
2392
2391
  volumes: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgs']]]] = None):
2393
2392
  if count is not None:
@@ -2401,34 +2400,34 @@ class JobTaskGroupArgs:
2401
2400
  if volumes is not None:
2402
2401
  pulumi.set(__self__, "volumes", volumes)
2403
2402
 
2404
- @property
2403
+ @_builtins.property
2405
2404
  @pulumi.getter
2406
- def count(self) -> Optional[pulumi.Input[builtins.int]]:
2405
+ def count(self) -> Optional[pulumi.Input[_builtins.int]]:
2407
2406
  return pulumi.get(self, "count")
2408
2407
 
2409
2408
  @count.setter
2410
- def count(self, value: Optional[pulumi.Input[builtins.int]]):
2409
+ def count(self, value: Optional[pulumi.Input[_builtins.int]]):
2411
2410
  pulumi.set(self, "count", value)
2412
2411
 
2413
- @property
2412
+ @_builtins.property
2414
2413
  @pulumi.getter
2415
- def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
2414
+ def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
2416
2415
  return pulumi.get(self, "meta")
2417
2416
 
2418
2417
  @meta.setter
2419
- def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
2418
+ def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
2420
2419
  pulumi.set(self, "meta", value)
2421
2420
 
2422
- @property
2421
+ @_builtins.property
2423
2422
  @pulumi.getter
2424
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
2423
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
2425
2424
  return pulumi.get(self, "name")
2426
2425
 
2427
2426
  @name.setter
2428
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
2427
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
2429
2428
  pulumi.set(self, "name", value)
2430
2429
 
2431
- @property
2430
+ @_builtins.property
2432
2431
  @pulumi.getter
2433
2432
  def tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgs']]]]:
2434
2433
  return pulumi.get(self, "tasks")
@@ -2437,7 +2436,7 @@ class JobTaskGroupArgs:
2437
2436
  def tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgs']]]]):
2438
2437
  pulumi.set(self, "tasks", value)
2439
2438
 
2440
- @property
2439
+ @_builtins.property
2441
2440
  @pulumi.getter
2442
2441
  def volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgs']]]]:
2443
2442
  return pulumi.get(self, "volumes")
@@ -2449,9 +2448,9 @@ class JobTaskGroupArgs:
2449
2448
 
2450
2449
  if not MYPY:
2451
2450
  class JobTaskGroupTaskArgsDict(TypedDict):
2452
- driver: NotRequired[pulumi.Input[builtins.str]]
2453
- meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
2454
- name: NotRequired[pulumi.Input[builtins.str]]
2451
+ driver: NotRequired[pulumi.Input[_builtins.str]]
2452
+ meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
2453
+ name: NotRequired[pulumi.Input[_builtins.str]]
2455
2454
  volume_mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgsDict']]]]
2456
2455
  elif False:
2457
2456
  JobTaskGroupTaskArgsDict: TypeAlias = Mapping[str, Any]
@@ -2459,9 +2458,9 @@ elif False:
2459
2458
  @pulumi.input_type
2460
2459
  class JobTaskGroupTaskArgs:
2461
2460
  def __init__(__self__, *,
2462
- driver: Optional[pulumi.Input[builtins.str]] = None,
2463
- meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
2464
- name: Optional[pulumi.Input[builtins.str]] = None,
2461
+ driver: Optional[pulumi.Input[_builtins.str]] = None,
2462
+ meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
2463
+ name: Optional[pulumi.Input[_builtins.str]] = None,
2465
2464
  volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgs']]]] = None):
2466
2465
  if driver is not None:
2467
2466
  pulumi.set(__self__, "driver", driver)
@@ -2472,34 +2471,34 @@ class JobTaskGroupTaskArgs:
2472
2471
  if volume_mounts is not None:
2473
2472
  pulumi.set(__self__, "volume_mounts", volume_mounts)
2474
2473
 
2475
- @property
2474
+ @_builtins.property
2476
2475
  @pulumi.getter
2477
- def driver(self) -> Optional[pulumi.Input[builtins.str]]:
2476
+ def driver(self) -> Optional[pulumi.Input[_builtins.str]]:
2478
2477
  return pulumi.get(self, "driver")
2479
2478
 
2480
2479
  @driver.setter
2481
- def driver(self, value: Optional[pulumi.Input[builtins.str]]):
2480
+ def driver(self, value: Optional[pulumi.Input[_builtins.str]]):
2482
2481
  pulumi.set(self, "driver", value)
2483
2482
 
2484
- @property
2483
+ @_builtins.property
2485
2484
  @pulumi.getter
2486
- def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
2485
+ def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
2487
2486
  return pulumi.get(self, "meta")
2488
2487
 
2489
2488
  @meta.setter
2490
- def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
2489
+ def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
2491
2490
  pulumi.set(self, "meta", value)
2492
2491
 
2493
- @property
2492
+ @_builtins.property
2494
2493
  @pulumi.getter
2495
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
2494
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
2496
2495
  return pulumi.get(self, "name")
2497
2496
 
2498
2497
  @name.setter
2499
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
2498
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
2500
2499
  pulumi.set(self, "name", value)
2501
2500
 
2502
- @property
2501
+ @_builtins.property
2503
2502
  @pulumi.getter(name="volumeMounts")
2504
2503
  def volume_mounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgs']]]]:
2505
2504
  return pulumi.get(self, "volume_mounts")
@@ -2511,18 +2510,18 @@ class JobTaskGroupTaskArgs:
2511
2510
 
2512
2511
  if not MYPY:
2513
2512
  class JobTaskGroupTaskVolumeMountArgsDict(TypedDict):
2514
- destination: NotRequired[pulumi.Input[builtins.str]]
2515
- read_only: NotRequired[pulumi.Input[builtins.bool]]
2516
- volume: NotRequired[pulumi.Input[builtins.str]]
2513
+ destination: NotRequired[pulumi.Input[_builtins.str]]
2514
+ read_only: NotRequired[pulumi.Input[_builtins.bool]]
2515
+ volume: NotRequired[pulumi.Input[_builtins.str]]
2517
2516
  elif False:
2518
2517
  JobTaskGroupTaskVolumeMountArgsDict: TypeAlias = Mapping[str, Any]
2519
2518
 
2520
2519
  @pulumi.input_type
2521
2520
  class JobTaskGroupTaskVolumeMountArgs:
2522
2521
  def __init__(__self__, *,
2523
- destination: Optional[pulumi.Input[builtins.str]] = None,
2524
- read_only: Optional[pulumi.Input[builtins.bool]] = None,
2525
- volume: Optional[pulumi.Input[builtins.str]] = None):
2522
+ destination: Optional[pulumi.Input[_builtins.str]] = None,
2523
+ read_only: Optional[pulumi.Input[_builtins.bool]] = None,
2524
+ volume: Optional[pulumi.Input[_builtins.str]] = None):
2526
2525
  if destination is not None:
2527
2526
  pulumi.set(__self__, "destination", destination)
2528
2527
  if read_only is not None:
@@ -2530,50 +2529,50 @@ class JobTaskGroupTaskVolumeMountArgs:
2530
2529
  if volume is not None:
2531
2530
  pulumi.set(__self__, "volume", volume)
2532
2531
 
2533
- @property
2532
+ @_builtins.property
2534
2533
  @pulumi.getter
2535
- def destination(self) -> Optional[pulumi.Input[builtins.str]]:
2534
+ def destination(self) -> Optional[pulumi.Input[_builtins.str]]:
2536
2535
  return pulumi.get(self, "destination")
2537
2536
 
2538
2537
  @destination.setter
2539
- def destination(self, value: Optional[pulumi.Input[builtins.str]]):
2538
+ def destination(self, value: Optional[pulumi.Input[_builtins.str]]):
2540
2539
  pulumi.set(self, "destination", value)
2541
2540
 
2542
- @property
2541
+ @_builtins.property
2543
2542
  @pulumi.getter(name="readOnly")
2544
- def read_only(self) -> Optional[pulumi.Input[builtins.bool]]:
2543
+ def read_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
2545
2544
  return pulumi.get(self, "read_only")
2546
2545
 
2547
2546
  @read_only.setter
2548
- def read_only(self, value: Optional[pulumi.Input[builtins.bool]]):
2547
+ def read_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
2549
2548
  pulumi.set(self, "read_only", value)
2550
2549
 
2551
- @property
2550
+ @_builtins.property
2552
2551
  @pulumi.getter
2553
- def volume(self) -> Optional[pulumi.Input[builtins.str]]:
2552
+ def volume(self) -> Optional[pulumi.Input[_builtins.str]]:
2554
2553
  return pulumi.get(self, "volume")
2555
2554
 
2556
2555
  @volume.setter
2557
- def volume(self, value: Optional[pulumi.Input[builtins.str]]):
2556
+ def volume(self, value: Optional[pulumi.Input[_builtins.str]]):
2558
2557
  pulumi.set(self, "volume", value)
2559
2558
 
2560
2559
 
2561
2560
  if not MYPY:
2562
2561
  class JobTaskGroupVolumeArgsDict(TypedDict):
2563
- name: NotRequired[pulumi.Input[builtins.str]]
2564
- read_only: NotRequired[pulumi.Input[builtins.bool]]
2565
- source: NotRequired[pulumi.Input[builtins.str]]
2566
- type: NotRequired[pulumi.Input[builtins.str]]
2562
+ name: NotRequired[pulumi.Input[_builtins.str]]
2563
+ read_only: NotRequired[pulumi.Input[_builtins.bool]]
2564
+ source: NotRequired[pulumi.Input[_builtins.str]]
2565
+ type: NotRequired[pulumi.Input[_builtins.str]]
2567
2566
  elif False:
2568
2567
  JobTaskGroupVolumeArgsDict: TypeAlias = Mapping[str, Any]
2569
2568
 
2570
2569
  @pulumi.input_type
2571
2570
  class JobTaskGroupVolumeArgs:
2572
2571
  def __init__(__self__, *,
2573
- name: Optional[pulumi.Input[builtins.str]] = None,
2574
- read_only: Optional[pulumi.Input[builtins.bool]] = None,
2575
- source: Optional[pulumi.Input[builtins.str]] = None,
2576
- type: Optional[pulumi.Input[builtins.str]] = None):
2572
+ name: Optional[pulumi.Input[_builtins.str]] = None,
2573
+ read_only: Optional[pulumi.Input[_builtins.bool]] = None,
2574
+ source: Optional[pulumi.Input[_builtins.str]] = None,
2575
+ type: Optional[pulumi.Input[_builtins.str]] = None):
2577
2576
  if name is not None:
2578
2577
  pulumi.set(__self__, "name", name)
2579
2578
  if read_only is not None:
@@ -2583,50 +2582,50 @@ class JobTaskGroupVolumeArgs:
2583
2582
  if type is not None:
2584
2583
  pulumi.set(__self__, "type", type)
2585
2584
 
2586
- @property
2585
+ @_builtins.property
2587
2586
  @pulumi.getter
2588
- def name(self) -> Optional[pulumi.Input[builtins.str]]:
2587
+ def name(self) -> Optional[pulumi.Input[_builtins.str]]:
2589
2588
  return pulumi.get(self, "name")
2590
2589
 
2591
2590
  @name.setter
2592
- def name(self, value: Optional[pulumi.Input[builtins.str]]):
2591
+ def name(self, value: Optional[pulumi.Input[_builtins.str]]):
2593
2592
  pulumi.set(self, "name", value)
2594
2593
 
2595
- @property
2594
+ @_builtins.property
2596
2595
  @pulumi.getter(name="readOnly")
2597
- def read_only(self) -> Optional[pulumi.Input[builtins.bool]]:
2596
+ def read_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
2598
2597
  return pulumi.get(self, "read_only")
2599
2598
 
2600
2599
  @read_only.setter
2601
- def read_only(self, value: Optional[pulumi.Input[builtins.bool]]):
2600
+ def read_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
2602
2601
  pulumi.set(self, "read_only", value)
2603
2602
 
2604
- @property
2603
+ @_builtins.property
2605
2604
  @pulumi.getter
2606
- def source(self) -> Optional[pulumi.Input[builtins.str]]:
2605
+ def source(self) -> Optional[pulumi.Input[_builtins.str]]:
2607
2606
  return pulumi.get(self, "source")
2608
2607
 
2609
2608
  @source.setter
2610
- def source(self, value: Optional[pulumi.Input[builtins.str]]):
2609
+ def source(self, value: Optional[pulumi.Input[_builtins.str]]):
2611
2610
  pulumi.set(self, "source", value)
2612
2611
 
2613
- @property
2612
+ @_builtins.property
2614
2613
  @pulumi.getter
2615
- def type(self) -> Optional[pulumi.Input[builtins.str]]:
2614
+ def type(self) -> Optional[pulumi.Input[_builtins.str]]:
2616
2615
  return pulumi.get(self, "type")
2617
2616
 
2618
2617
  @type.setter
2619
- def type(self, value: Optional[pulumi.Input[builtins.str]]):
2618
+ def type(self, value: Optional[pulumi.Input[_builtins.str]]):
2620
2619
  pulumi.set(self, "type", value)
2621
2620
 
2622
2621
 
2623
2622
  if not MYPY:
2624
2623
  class NamespaceCapabilitiesArgsDict(TypedDict):
2625
- disabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2624
+ disabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
2626
2625
  """
2627
2626
  `([]string: <optional>)` - Task drivers disabled for the namespace.
2628
2627
  """
2629
- enabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2628
+ enabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
2630
2629
  """
2631
2630
  `([]string: <optional>)` - Task drivers enabled for the namespace.
2632
2631
  """
@@ -2636,53 +2635,53 @@ elif False:
2636
2635
  @pulumi.input_type
2637
2636
  class NamespaceCapabilitiesArgs:
2638
2637
  def __init__(__self__, *,
2639
- disabled_task_drivers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
2640
- enabled_task_drivers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
2638
+ disabled_task_drivers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
2639
+ enabled_task_drivers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
2641
2640
  """
2642
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] disabled_task_drivers: `([]string: <optional>)` - Task drivers disabled for the namespace.
2643
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] enabled_task_drivers: `([]string: <optional>)` - Task drivers enabled for the namespace.
2641
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] disabled_task_drivers: `([]string: <optional>)` - Task drivers disabled for the namespace.
2642
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] enabled_task_drivers: `([]string: <optional>)` - Task drivers enabled for the namespace.
2644
2643
  """
2645
2644
  if disabled_task_drivers is not None:
2646
2645
  pulumi.set(__self__, "disabled_task_drivers", disabled_task_drivers)
2647
2646
  if enabled_task_drivers is not None:
2648
2647
  pulumi.set(__self__, "enabled_task_drivers", enabled_task_drivers)
2649
2648
 
2650
- @property
2649
+ @_builtins.property
2651
2650
  @pulumi.getter(name="disabledTaskDrivers")
2652
- def disabled_task_drivers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2651
+ def disabled_task_drivers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
2653
2652
  """
2654
2653
  `([]string: <optional>)` - Task drivers disabled for the namespace.
2655
2654
  """
2656
2655
  return pulumi.get(self, "disabled_task_drivers")
2657
2656
 
2658
2657
  @disabled_task_drivers.setter
2659
- def disabled_task_drivers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2658
+ def disabled_task_drivers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
2660
2659
  pulumi.set(self, "disabled_task_drivers", value)
2661
2660
 
2662
- @property
2661
+ @_builtins.property
2663
2662
  @pulumi.getter(name="enabledTaskDrivers")
2664
- def enabled_task_drivers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2663
+ def enabled_task_drivers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
2665
2664
  """
2666
2665
  `([]string: <optional>)` - Task drivers enabled for the namespace.
2667
2666
  """
2668
2667
  return pulumi.get(self, "enabled_task_drivers")
2669
2668
 
2670
2669
  @enabled_task_drivers.setter
2671
- def enabled_task_drivers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2670
+ def enabled_task_drivers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
2672
2671
  pulumi.set(self, "enabled_task_drivers", value)
2673
2672
 
2674
2673
 
2675
2674
  if not MYPY:
2676
2675
  class NamespaceNodePoolConfigArgsDict(TypedDict):
2677
- alloweds: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2676
+ alloweds: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
2678
2677
  """
2679
2678
  `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
2680
2679
  """
2681
- default: NotRequired[pulumi.Input[builtins.str]]
2680
+ default: NotRequired[pulumi.Input[_builtins.str]]
2682
2681
  """
2683
2682
  `(string: <optional>)` - The default node pool for jobs that don't define one.
2684
2683
  """
2685
- denieds: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2684
+ denieds: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
2686
2685
  """
2687
2686
  `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
2688
2687
  """
@@ -2692,13 +2691,13 @@ elif False:
2692
2691
  @pulumi.input_type
2693
2692
  class NamespaceNodePoolConfigArgs:
2694
2693
  def __init__(__self__, *,
2695
- alloweds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
2696
- default: Optional[pulumi.Input[builtins.str]] = None,
2697
- denieds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
2694
+ alloweds: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
2695
+ default: Optional[pulumi.Input[_builtins.str]] = None,
2696
+ denieds: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
2698
2697
  """
2699
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] alloweds: `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
2700
- :param pulumi.Input[builtins.str] default: `(string: <optional>)` - The default node pool for jobs that don't define one.
2701
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] denieds: `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
2698
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] alloweds: `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
2699
+ :param pulumi.Input[_builtins.str] default: `(string: <optional>)` - The default node pool for jobs that don't define one.
2700
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] denieds: `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
2702
2701
  """
2703
2702
  if alloweds is not None:
2704
2703
  pulumi.set(__self__, "alloweds", alloweds)
@@ -2707,46 +2706,46 @@ class NamespaceNodePoolConfigArgs:
2707
2706
  if denieds is not None:
2708
2707
  pulumi.set(__self__, "denieds", denieds)
2709
2708
 
2710
- @property
2709
+ @_builtins.property
2711
2710
  @pulumi.getter
2712
- def alloweds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2711
+ def alloweds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
2713
2712
  """
2714
2713
  `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
2715
2714
  """
2716
2715
  return pulumi.get(self, "alloweds")
2717
2716
 
2718
2717
  @alloweds.setter
2719
- def alloweds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2718
+ def alloweds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
2720
2719
  pulumi.set(self, "alloweds", value)
2721
2720
 
2722
- @property
2721
+ @_builtins.property
2723
2722
  @pulumi.getter
2724
- def default(self) -> Optional[pulumi.Input[builtins.str]]:
2723
+ def default(self) -> Optional[pulumi.Input[_builtins.str]]:
2725
2724
  """
2726
2725
  `(string: <optional>)` - The default node pool for jobs that don't define one.
2727
2726
  """
2728
2727
  return pulumi.get(self, "default")
2729
2728
 
2730
2729
  @default.setter
2731
- def default(self, value: Optional[pulumi.Input[builtins.str]]):
2730
+ def default(self, value: Optional[pulumi.Input[_builtins.str]]):
2732
2731
  pulumi.set(self, "default", value)
2733
2732
 
2734
- @property
2733
+ @_builtins.property
2735
2734
  @pulumi.getter
2736
- def denieds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2735
+ def denieds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
2737
2736
  """
2738
2737
  `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
2739
2738
  """
2740
2739
  return pulumi.get(self, "denieds")
2741
2740
 
2742
2741
  @denieds.setter
2743
- def denieds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2742
+ def denieds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
2744
2743
  pulumi.set(self, "denieds", value)
2745
2744
 
2746
2745
 
2747
2746
  if not MYPY:
2748
2747
  class NodePoolSchedulerConfigArgsDict(TypedDict):
2749
- memory_oversubscription: NotRequired[pulumi.Input[builtins.str]]
2748
+ memory_oversubscription: NotRequired[pulumi.Input[_builtins.str]]
2750
2749
  """
2751
2750
  `(string)` - Whether or not memory
2752
2751
  oversubscription is enabled in the node pool. Possible values are
@@ -2757,7 +2756,7 @@ if not MYPY:
2757
2756
  allow distinguishing between memory oversubscription being disabled in the
2758
2757
  node pool and this property not being set.
2759
2758
  """
2760
- scheduler_algorithm: NotRequired[pulumi.Input[builtins.str]]
2759
+ scheduler_algorithm: NotRequired[pulumi.Input[_builtins.str]]
2761
2760
  """
2762
2761
  `(string)` - The scheduler algorithm used in the node
2763
2762
  pool. Possible values are `binpack` or `spread`. If not defined the global
@@ -2769,10 +2768,10 @@ elif False:
2769
2768
  @pulumi.input_type
2770
2769
  class NodePoolSchedulerConfigArgs:
2771
2770
  def __init__(__self__, *,
2772
- memory_oversubscription: Optional[pulumi.Input[builtins.str]] = None,
2773
- scheduler_algorithm: Optional[pulumi.Input[builtins.str]] = None):
2771
+ memory_oversubscription: Optional[pulumi.Input[_builtins.str]] = None,
2772
+ scheduler_algorithm: Optional[pulumi.Input[_builtins.str]] = None):
2774
2773
  """
2775
- :param pulumi.Input[builtins.str] memory_oversubscription: `(string)` - Whether or not memory
2774
+ :param pulumi.Input[_builtins.str] memory_oversubscription: `(string)` - Whether or not memory
2776
2775
  oversubscription is enabled in the node pool. Possible values are
2777
2776
  `"enabled"` or `"disabled"`. If not defined the global cluster
2778
2777
  configuration is used.
@@ -2780,7 +2779,7 @@ class NodePoolSchedulerConfigArgs:
2780
2779
  > This option differs from Nomad, where it's represented as a boolean, to
2781
2780
  allow distinguishing between memory oversubscription being disabled in the
2782
2781
  node pool and this property not being set.
2783
- :param pulumi.Input[builtins.str] scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
2782
+ :param pulumi.Input[_builtins.str] scheduler_algorithm: `(string)` - The scheduler algorithm used in the node
2784
2783
  pool. Possible values are `binpack` or `spread`. If not defined the global
2785
2784
  cluster configuration is used.
2786
2785
  """
@@ -2789,9 +2788,9 @@ class NodePoolSchedulerConfigArgs:
2789
2788
  if scheduler_algorithm is not None:
2790
2789
  pulumi.set(__self__, "scheduler_algorithm", scheduler_algorithm)
2791
2790
 
2792
- @property
2791
+ @_builtins.property
2793
2792
  @pulumi.getter(name="memoryOversubscription")
2794
- def memory_oversubscription(self) -> Optional[pulumi.Input[builtins.str]]:
2793
+ def memory_oversubscription(self) -> Optional[pulumi.Input[_builtins.str]]:
2795
2794
  """
2796
2795
  `(string)` - Whether or not memory
2797
2796
  oversubscription is enabled in the node pool. Possible values are
@@ -2805,12 +2804,12 @@ class NodePoolSchedulerConfigArgs:
2805
2804
  return pulumi.get(self, "memory_oversubscription")
2806
2805
 
2807
2806
  @memory_oversubscription.setter
2808
- def memory_oversubscription(self, value: Optional[pulumi.Input[builtins.str]]):
2807
+ def memory_oversubscription(self, value: Optional[pulumi.Input[_builtins.str]]):
2809
2808
  pulumi.set(self, "memory_oversubscription", value)
2810
2809
 
2811
- @property
2810
+ @_builtins.property
2812
2811
  @pulumi.getter(name="schedulerAlgorithm")
2813
- def scheduler_algorithm(self) -> Optional[pulumi.Input[builtins.str]]:
2812
+ def scheduler_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
2814
2813
  """
2815
2814
  `(string)` - The scheduler algorithm used in the node
2816
2815
  pool. Possible values are `binpack` or `spread`. If not defined the global
@@ -2819,17 +2818,17 @@ class NodePoolSchedulerConfigArgs:
2819
2818
  return pulumi.get(self, "scheduler_algorithm")
2820
2819
 
2821
2820
  @scheduler_algorithm.setter
2822
- def scheduler_algorithm(self, value: Optional[pulumi.Input[builtins.str]]):
2821
+ def scheduler_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
2823
2822
  pulumi.set(self, "scheduler_algorithm", value)
2824
2823
 
2825
2824
 
2826
2825
  if not MYPY:
2827
2826
  class ProviderHeaderArgsDict(TypedDict):
2828
- name: pulumi.Input[builtins.str]
2827
+ name: pulumi.Input[_builtins.str]
2829
2828
  """
2830
2829
  The header name
2831
2830
  """
2832
- value: pulumi.Input[builtins.str]
2831
+ value: pulumi.Input[_builtins.str]
2833
2832
  """
2834
2833
  The header value
2835
2834
  """
@@ -2839,43 +2838,43 @@ elif False:
2839
2838
  @pulumi.input_type
2840
2839
  class ProviderHeaderArgs:
2841
2840
  def __init__(__self__, *,
2842
- name: pulumi.Input[builtins.str],
2843
- value: pulumi.Input[builtins.str]):
2841
+ name: pulumi.Input[_builtins.str],
2842
+ value: pulumi.Input[_builtins.str]):
2844
2843
  """
2845
- :param pulumi.Input[builtins.str] name: The header name
2846
- :param pulumi.Input[builtins.str] value: The header value
2844
+ :param pulumi.Input[_builtins.str] name: The header name
2845
+ :param pulumi.Input[_builtins.str] value: The header value
2847
2846
  """
2848
2847
  pulumi.set(__self__, "name", name)
2849
2848
  pulumi.set(__self__, "value", value)
2850
2849
 
2851
- @property
2850
+ @_builtins.property
2852
2851
  @pulumi.getter
2853
- def name(self) -> pulumi.Input[builtins.str]:
2852
+ def name(self) -> pulumi.Input[_builtins.str]:
2854
2853
  """
2855
2854
  The header name
2856
2855
  """
2857
2856
  return pulumi.get(self, "name")
2858
2857
 
2859
2858
  @name.setter
2860
- def name(self, value: pulumi.Input[builtins.str]):
2859
+ def name(self, value: pulumi.Input[_builtins.str]):
2861
2860
  pulumi.set(self, "name", value)
2862
2861
 
2863
- @property
2862
+ @_builtins.property
2864
2863
  @pulumi.getter
2865
- def value(self) -> pulumi.Input[builtins.str]:
2864
+ def value(self) -> pulumi.Input[_builtins.str]:
2866
2865
  """
2867
2866
  The header value
2868
2867
  """
2869
2868
  return pulumi.get(self, "value")
2870
2869
 
2871
2870
  @value.setter
2872
- def value(self, value: pulumi.Input[builtins.str]):
2871
+ def value(self, value: pulumi.Input[_builtins.str]):
2873
2872
  pulumi.set(self, "value", value)
2874
2873
 
2875
2874
 
2876
2875
  if not MYPY:
2877
2876
  class QuoteSpecificationLimitArgsDict(TypedDict):
2878
- region: pulumi.Input[builtins.str]
2877
+ region: pulumi.Input[_builtins.str]
2879
2878
  """
2880
2879
  `(string: <required>)` - The region these limits should apply to.
2881
2880
  """
@@ -2891,10 +2890,10 @@ elif False:
2891
2890
  @pulumi.input_type
2892
2891
  class QuoteSpecificationLimitArgs:
2893
2892
  def __init__(__self__, *,
2894
- region: pulumi.Input[builtins.str],
2893
+ region: pulumi.Input[_builtins.str],
2895
2894
  region_limit: pulumi.Input['QuoteSpecificationLimitRegionLimitArgs']):
2896
2895
  """
2897
- :param pulumi.Input[builtins.str] region: `(string: <required>)` - The region these limits should apply to.
2896
+ :param pulumi.Input[_builtins.str] region: `(string: <required>)` - The region these limits should apply to.
2898
2897
  :param pulumi.Input['QuoteSpecificationLimitRegionLimitArgs'] region_limit: `(block: <required>)` - The limits to enforce. This block
2899
2898
  may only be specified once in the `limits` block. Its structure is
2900
2899
  documented below.
@@ -2902,19 +2901,19 @@ class QuoteSpecificationLimitArgs:
2902
2901
  pulumi.set(__self__, "region", region)
2903
2902
  pulumi.set(__self__, "region_limit", region_limit)
2904
2903
 
2905
- @property
2904
+ @_builtins.property
2906
2905
  @pulumi.getter
2907
- def region(self) -> pulumi.Input[builtins.str]:
2906
+ def region(self) -> pulumi.Input[_builtins.str]:
2908
2907
  """
2909
2908
  `(string: <required>)` - The region these limits should apply to.
2910
2909
  """
2911
2910
  return pulumi.get(self, "region")
2912
2911
 
2913
2912
  @region.setter
2914
- def region(self, value: pulumi.Input[builtins.str]):
2913
+ def region(self, value: pulumi.Input[_builtins.str]):
2915
2914
  pulumi.set(self, "region", value)
2916
2915
 
2917
- @property
2916
+ @_builtins.property
2918
2917
  @pulumi.getter(name="regionLimit")
2919
2918
  def region_limit(self) -> pulumi.Input['QuoteSpecificationLimitRegionLimitArgs']:
2920
2919
  """
@@ -2931,12 +2930,12 @@ class QuoteSpecificationLimitArgs:
2931
2930
 
2932
2931
  if not MYPY:
2933
2932
  class QuoteSpecificationLimitRegionLimitArgsDict(TypedDict):
2934
- cpu: NotRequired[pulumi.Input[builtins.int]]
2933
+ cpu: NotRequired[pulumi.Input[_builtins.int]]
2935
2934
  """
2936
2935
  `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
2937
2936
  is treated as unlimited, and a negative value is treated as fully disallowed.
2938
2937
  """
2939
- memory_mb: NotRequired[pulumi.Input[builtins.int]]
2938
+ memory_mb: NotRequired[pulumi.Input[_builtins.int]]
2940
2939
  """
2941
2940
  `(int: 0)` - The amount of memory (in megabytes) to limit
2942
2941
  allocations to. A value of zero is treated as unlimited, and a negative value
@@ -2948,12 +2947,12 @@ elif False:
2948
2947
  @pulumi.input_type
2949
2948
  class QuoteSpecificationLimitRegionLimitArgs:
2950
2949
  def __init__(__self__, *,
2951
- cpu: Optional[pulumi.Input[builtins.int]] = None,
2952
- memory_mb: Optional[pulumi.Input[builtins.int]] = None):
2950
+ cpu: Optional[pulumi.Input[_builtins.int]] = None,
2951
+ memory_mb: Optional[pulumi.Input[_builtins.int]] = None):
2953
2952
  """
2954
- :param pulumi.Input[builtins.int] cpu: `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
2953
+ :param pulumi.Input[_builtins.int] cpu: `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
2955
2954
  is treated as unlimited, and a negative value is treated as fully disallowed.
2956
- :param pulumi.Input[builtins.int] memory_mb: `(int: 0)` - The amount of memory (in megabytes) to limit
2955
+ :param pulumi.Input[_builtins.int] memory_mb: `(int: 0)` - The amount of memory (in megabytes) to limit
2957
2956
  allocations to. A value of zero is treated as unlimited, and a negative value
2958
2957
  is treated as fully disallowed.
2959
2958
  """
@@ -2962,9 +2961,9 @@ class QuoteSpecificationLimitRegionLimitArgs:
2962
2961
  if memory_mb is not None:
2963
2962
  pulumi.set(__self__, "memory_mb", memory_mb)
2964
2963
 
2965
- @property
2964
+ @_builtins.property
2966
2965
  @pulumi.getter
2967
- def cpu(self) -> Optional[pulumi.Input[builtins.int]]:
2966
+ def cpu(self) -> Optional[pulumi.Input[_builtins.int]]:
2968
2967
  """
2969
2968
  `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
2970
2969
  is treated as unlimited, and a negative value is treated as fully disallowed.
@@ -2972,12 +2971,12 @@ class QuoteSpecificationLimitRegionLimitArgs:
2972
2971
  return pulumi.get(self, "cpu")
2973
2972
 
2974
2973
  @cpu.setter
2975
- def cpu(self, value: Optional[pulumi.Input[builtins.int]]):
2974
+ def cpu(self, value: Optional[pulumi.Input[_builtins.int]]):
2976
2975
  pulumi.set(self, "cpu", value)
2977
2976
 
2978
- @property
2977
+ @_builtins.property
2979
2978
  @pulumi.getter(name="memoryMb")
2980
- def memory_mb(self) -> Optional[pulumi.Input[builtins.int]]:
2979
+ def memory_mb(self) -> Optional[pulumi.Input[_builtins.int]]:
2981
2980
  """
2982
2981
  `(int: 0)` - The amount of memory (in megabytes) to limit
2983
2982
  allocations to. A value of zero is treated as unlimited, and a negative value
@@ -2986,13 +2985,13 @@ class QuoteSpecificationLimitRegionLimitArgs:
2986
2985
  return pulumi.get(self, "memory_mb")
2987
2986
 
2988
2987
  @memory_mb.setter
2989
- def memory_mb(self, value: Optional[pulumi.Input[builtins.int]]):
2988
+ def memory_mb(self, value: Optional[pulumi.Input[_builtins.int]]):
2990
2989
  pulumi.set(self, "memory_mb", value)
2991
2990
 
2992
2991
 
2993
2992
  if not MYPY:
2994
2993
  class VolumeCapabilityArgsDict(TypedDict):
2995
- access_mode: pulumi.Input[builtins.str]
2994
+ access_mode: pulumi.Input[_builtins.str]
2996
2995
  """
2997
2996
  `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
2998
2997
  - `single-node-reader-only`
@@ -3001,7 +3000,7 @@ if not MYPY:
3001
3000
  - `multi-node-single-writer`
3002
3001
  - `multi-node-multi-writer`
3003
3002
  """
3004
- attachment_mode: pulumi.Input[builtins.str]
3003
+ attachment_mode: pulumi.Input[_builtins.str]
3005
3004
  """
3006
3005
  `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
3007
3006
  - `block-device`
@@ -3013,25 +3012,25 @@ elif False:
3013
3012
  @pulumi.input_type
3014
3013
  class VolumeCapabilityArgs:
3015
3014
  def __init__(__self__, *,
3016
- access_mode: pulumi.Input[builtins.str],
3017
- attachment_mode: pulumi.Input[builtins.str]):
3015
+ access_mode: pulumi.Input[_builtins.str],
3016
+ attachment_mode: pulumi.Input[_builtins.str]):
3018
3017
  """
3019
- :param pulumi.Input[builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
3018
+ :param pulumi.Input[_builtins.str] access_mode: `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
3020
3019
  - `single-node-reader-only`
3021
3020
  - `single-node-writer`
3022
3021
  - `multi-node-reader-only`
3023
3022
  - `multi-node-single-writer`
3024
3023
  - `multi-node-multi-writer`
3025
- :param pulumi.Input[builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
3024
+ :param pulumi.Input[_builtins.str] attachment_mode: `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
3026
3025
  - `block-device`
3027
3026
  - `file-system`
3028
3027
  """
3029
3028
  pulumi.set(__self__, "access_mode", access_mode)
3030
3029
  pulumi.set(__self__, "attachment_mode", attachment_mode)
3031
3030
 
3032
- @property
3031
+ @_builtins.property
3033
3032
  @pulumi.getter(name="accessMode")
3034
- def access_mode(self) -> pulumi.Input[builtins.str]:
3033
+ def access_mode(self) -> pulumi.Input[_builtins.str]:
3035
3034
  """
3036
3035
  `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
3037
3036
  - `single-node-reader-only`
@@ -3043,12 +3042,12 @@ class VolumeCapabilityArgs:
3043
3042
  return pulumi.get(self, "access_mode")
3044
3043
 
3045
3044
  @access_mode.setter
3046
- def access_mode(self, value: pulumi.Input[builtins.str]):
3045
+ def access_mode(self, value: pulumi.Input[_builtins.str]):
3047
3046
  pulumi.set(self, "access_mode", value)
3048
3047
 
3049
- @property
3048
+ @_builtins.property
3050
3049
  @pulumi.getter(name="attachmentMode")
3051
- def attachment_mode(self) -> pulumi.Input[builtins.str]:
3050
+ def attachment_mode(self) -> pulumi.Input[_builtins.str]:
3052
3051
  """
3053
3052
  `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
3054
3053
  - `block-device`
@@ -3057,17 +3056,17 @@ class VolumeCapabilityArgs:
3057
3056
  return pulumi.get(self, "attachment_mode")
3058
3057
 
3059
3058
  @attachment_mode.setter
3060
- def attachment_mode(self, value: pulumi.Input[builtins.str]):
3059
+ def attachment_mode(self, value: pulumi.Input[_builtins.str]):
3061
3060
  pulumi.set(self, "attachment_mode", value)
3062
3061
 
3063
3062
 
3064
3063
  if not MYPY:
3065
3064
  class VolumeMountOptionsArgsDict(TypedDict):
3066
- fs_type: NotRequired[pulumi.Input[builtins.str]]
3065
+ fs_type: NotRequired[pulumi.Input[_builtins.str]]
3067
3066
  """
3068
3067
  `(string: <optional>)` - The file system type.
3069
3068
  """
3070
- mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
3069
+ mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
3071
3070
  """
3072
3071
  `([]string: <optional>)` - The flags passed to `mount`.
3073
3072
  """
@@ -3077,45 +3076,45 @@ elif False:
3077
3076
  @pulumi.input_type
3078
3077
  class VolumeMountOptionsArgs:
3079
3078
  def __init__(__self__, *,
3080
- fs_type: Optional[pulumi.Input[builtins.str]] = None,
3081
- mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
3079
+ fs_type: Optional[pulumi.Input[_builtins.str]] = None,
3080
+ mount_flags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
3082
3081
  """
3083
- :param pulumi.Input[builtins.str] fs_type: `(string: <optional>)` - The file system type.
3084
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
3082
+ :param pulumi.Input[_builtins.str] fs_type: `(string: <optional>)` - The file system type.
3083
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] mount_flags: `([]string: <optional>)` - The flags passed to `mount`.
3085
3084
  """
3086
3085
  if fs_type is not None:
3087
3086
  pulumi.set(__self__, "fs_type", fs_type)
3088
3087
  if mount_flags is not None:
3089
3088
  pulumi.set(__self__, "mount_flags", mount_flags)
3090
3089
 
3091
- @property
3090
+ @_builtins.property
3092
3091
  @pulumi.getter(name="fsType")
3093
- def fs_type(self) -> Optional[pulumi.Input[builtins.str]]:
3092
+ def fs_type(self) -> Optional[pulumi.Input[_builtins.str]]:
3094
3093
  """
3095
3094
  `(string: <optional>)` - The file system type.
3096
3095
  """
3097
3096
  return pulumi.get(self, "fs_type")
3098
3097
 
3099
3098
  @fs_type.setter
3100
- def fs_type(self, value: Optional[pulumi.Input[builtins.str]]):
3099
+ def fs_type(self, value: Optional[pulumi.Input[_builtins.str]]):
3101
3100
  pulumi.set(self, "fs_type", value)
3102
3101
 
3103
- @property
3102
+ @_builtins.property
3104
3103
  @pulumi.getter(name="mountFlags")
3105
- def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
3104
+ def mount_flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
3106
3105
  """
3107
3106
  `([]string: <optional>)` - The flags passed to `mount`.
3108
3107
  """
3109
3108
  return pulumi.get(self, "mount_flags")
3110
3109
 
3111
3110
  @mount_flags.setter
3112
- def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
3111
+ def mount_flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
3113
3112
  pulumi.set(self, "mount_flags", value)
3114
3113
 
3115
3114
 
3116
3115
  if not MYPY:
3117
3116
  class VolumeTopologyArgsDict(TypedDict):
3118
- segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
3117
+ segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
3119
3118
  """
3120
3119
  `(map[string]string)` - Define the attributes for the topology request.
3121
3120
 
@@ -3128,9 +3127,9 @@ elif False:
3128
3127
  @pulumi.input_type
3129
3128
  class VolumeTopologyArgs:
3130
3129
  def __init__(__self__, *,
3131
- segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
3130
+ segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
3132
3131
  """
3133
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
3132
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
3134
3133
 
3135
3134
  In addition to the above arguments, the following attributes are exported and
3136
3135
  can be referenced:
@@ -3138,9 +3137,9 @@ class VolumeTopologyArgs:
3138
3137
  if segments is not None:
3139
3138
  pulumi.set(__self__, "segments", segments)
3140
3139
 
3141
- @property
3140
+ @_builtins.property
3142
3141
  @pulumi.getter
3143
- def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
3142
+ def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
3144
3143
  """
3145
3144
  `(map[string]string)` - Define the attributes for the topology request.
3146
3145
 
@@ -3150,7 +3149,7 @@ class VolumeTopologyArgs:
3150
3149
  return pulumi.get(self, "segments")
3151
3150
 
3152
3151
  @segments.setter
3153
- def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
3152
+ def segments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
3154
3153
  pulumi.set(self, "segments", value)
3155
3154
 
3156
3155
 
@@ -3173,7 +3172,7 @@ class VolumeTopologyRequestArgs:
3173
3172
  if required is not None:
3174
3173
  pulumi.set(__self__, "required", required)
3175
3174
 
3176
- @property
3175
+ @_builtins.property
3177
3176
  @pulumi.getter
3178
3177
  def required(self) -> Optional[pulumi.Input['VolumeTopologyRequestRequiredArgs']]:
3179
3178
  """
@@ -3204,7 +3203,7 @@ class VolumeTopologyRequestRequiredArgs:
3204
3203
  """
3205
3204
  pulumi.set(__self__, "topologies", topologies)
3206
3205
 
3207
- @property
3206
+ @_builtins.property
3208
3207
  @pulumi.getter
3209
3208
  def topologies(self) -> pulumi.Input[Sequence[pulumi.Input['VolumeTopologyRequestRequiredTopologyArgs']]]:
3210
3209
  """
@@ -3219,7 +3218,7 @@ class VolumeTopologyRequestRequiredArgs:
3219
3218
 
3220
3219
  if not MYPY:
3221
3220
  class VolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
3222
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]
3221
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]
3223
3222
  """
3224
3223
  Define attributes for the topology request.
3225
3224
  """
@@ -3229,22 +3228,22 @@ elif False:
3229
3228
  @pulumi.input_type
3230
3229
  class VolumeTopologyRequestRequiredTopologyArgs:
3231
3230
  def __init__(__self__, *,
3232
- segments: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
3231
+ segments: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
3233
3232
  """
3234
- :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] segments: Define attributes for the topology request.
3233
+ :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] segments: Define attributes for the topology request.
3235
3234
  """
3236
3235
  pulumi.set(__self__, "segments", segments)
3237
3236
 
3238
- @property
3237
+ @_builtins.property
3239
3238
  @pulumi.getter
3240
- def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]:
3239
+ def segments(self) -> pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]:
3241
3240
  """
3242
3241
  Define attributes for the topology request.
3243
3242
  """
3244
3243
  return pulumi.get(self, "segments")
3245
3244
 
3246
3245
  @segments.setter
3247
- def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]):
3246
+ def segments(self, value: pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]):
3248
3247
  pulumi.set(self, "segments", value)
3249
3248
 
3250
3249