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