pulumi-nomad 2.3.3a1728590718__py3-none-any.whl → 2.4.0a1717653571__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 (53) hide show
  1. pulumi_nomad/_inputs.py +13 -729
  2. pulumi_nomad/_utilities.py +5 -41
  3. pulumi_nomad/acl_auth_method.py +23 -28
  4. pulumi_nomad/acl_binding_rule.py +0 -5
  5. pulumi_nomad/acl_policy.py +5 -10
  6. pulumi_nomad/acl_role.py +5 -10
  7. pulumi_nomad/acl_token.py +5 -10
  8. pulumi_nomad/config/__init__.pyi +0 -5
  9. pulumi_nomad/config/outputs.py +0 -5
  10. pulumi_nomad/config/vars.py +0 -5
  11. pulumi_nomad/csi_volume.py +16 -21
  12. pulumi_nomad/csi_volume_registration.py +16 -21
  13. pulumi_nomad/external_volume.py +54 -59
  14. pulumi_nomad/get_acl_policies.py +4 -13
  15. pulumi_nomad/get_acl_policy.py +4 -14
  16. pulumi_nomad/get_acl_role.py +4 -14
  17. pulumi_nomad/get_acl_roles.py +4 -13
  18. pulumi_nomad/get_acl_token.py +4 -21
  19. pulumi_nomad/get_acl_tokens.py +4 -13
  20. pulumi_nomad/get_allocations.py +4 -17
  21. pulumi_nomad/get_datacenters.py +4 -15
  22. pulumi_nomad/get_deployments.py +5 -12
  23. pulumi_nomad/get_job.py +4 -33
  24. pulumi_nomad/get_job_parser.py +4 -15
  25. pulumi_nomad/get_jwks.py +4 -12
  26. pulumi_nomad/get_namespace.py +4 -17
  27. pulumi_nomad/get_namespaces.py +4 -11
  28. pulumi_nomad/get_node_pool.py +4 -15
  29. pulumi_nomad/get_node_pools.py +4 -15
  30. pulumi_nomad/get_plugin.py +4 -24
  31. pulumi_nomad/get_plugins.py +5 -14
  32. pulumi_nomad/get_regions.py +4 -11
  33. pulumi_nomad/get_scaling_policies.py +4 -15
  34. pulumi_nomad/get_scaling_policy.py +5 -18
  35. pulumi_nomad/get_scheduler_policy.py +4 -13
  36. pulumi_nomad/get_variable.py +5 -16
  37. pulumi_nomad/get_volumes.py +5 -20
  38. pulumi_nomad/job.py +21 -16
  39. pulumi_nomad/namespace.py +24 -29
  40. pulumi_nomad/node_pool.py +5 -10
  41. pulumi_nomad/outputs.py +17 -68
  42. pulumi_nomad/provider.py +3 -8
  43. pulumi_nomad/pulumi-plugin.json +1 -1
  44. pulumi_nomad/quote_specification.py +19 -24
  45. pulumi_nomad/scheduler_config.py +0 -5
  46. pulumi_nomad/sentinel_policy.py +0 -5
  47. pulumi_nomad/variable.py +14 -19
  48. pulumi_nomad/volume.py +72 -65
  49. {pulumi_nomad-2.3.3a1728590718.dist-info → pulumi_nomad-2.4.0a1717653571.dist-info}/METADATA +2 -3
  50. pulumi_nomad-2.4.0a1717653571.dist-info/RECORD +55 -0
  51. {pulumi_nomad-2.3.3a1728590718.dist-info → pulumi_nomad-2.4.0a1717653571.dist-info}/WHEEL +1 -1
  52. pulumi_nomad-2.3.3a1728590718.dist-info/RECORD +0 -55
  53. {pulumi_nomad-2.3.3a1728590718.dist-info → pulumi_nomad-2.4.0a1717653571.dist-info}/top_level.txt +0 -0
pulumi_nomad/_inputs.py CHANGED
@@ -4,201 +4,57 @@
4
4
 
5
5
  import copy
6
6
  import warnings
7
- import sys
8
7
  import pulumi
9
8
  import pulumi.runtime
10
9
  from typing import Any, Mapping, Optional, Sequence, Union, overload
11
- if sys.version_info >= (3, 11):
12
- from typing import NotRequired, TypedDict, TypeAlias
13
- else:
14
- from typing_extensions import NotRequired, TypedDict, TypeAlias
15
10
  from . import _utilities
16
11
 
17
12
  __all__ = [
18
13
  'AclAuthMethodConfigArgs',
19
- 'AclAuthMethodConfigArgsDict',
20
14
  'AclPolicyJobAclArgs',
21
- 'AclPolicyJobAclArgsDict',
22
15
  'AclRolePolicyArgs',
23
- 'AclRolePolicyArgsDict',
24
16
  'AclTokenRoleArgs',
25
- 'AclTokenRoleArgsDict',
26
17
  'CsiVolumeCapabilityArgs',
27
- 'CsiVolumeCapabilityArgsDict',
28
18
  'CsiVolumeMountOptionsArgs',
29
- 'CsiVolumeMountOptionsArgsDict',
30
19
  'CsiVolumeRegistrationCapabilityArgs',
31
- 'CsiVolumeRegistrationCapabilityArgsDict',
32
20
  'CsiVolumeRegistrationMountOptionsArgs',
33
- 'CsiVolumeRegistrationMountOptionsArgsDict',
34
21
  'CsiVolumeRegistrationTopologyArgs',
35
- 'CsiVolumeRegistrationTopologyArgsDict',
36
22
  'CsiVolumeRegistrationTopologyRequestArgs',
37
- 'CsiVolumeRegistrationTopologyRequestArgsDict',
38
23
  'CsiVolumeRegistrationTopologyRequestRequiredArgs',
39
- 'CsiVolumeRegistrationTopologyRequestRequiredArgsDict',
40
24
  'CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs',
41
- 'CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict',
42
25
  'CsiVolumeTopologyArgs',
43
- 'CsiVolumeTopologyArgsDict',
44
26
  'CsiVolumeTopologyRequestArgs',
45
- 'CsiVolumeTopologyRequestArgsDict',
46
27
  'CsiVolumeTopologyRequestPreferredArgs',
47
- 'CsiVolumeTopologyRequestPreferredArgsDict',
48
28
  'CsiVolumeTopologyRequestPreferredTopologyArgs',
49
- 'CsiVolumeTopologyRequestPreferredTopologyArgsDict',
50
29
  'CsiVolumeTopologyRequestRequiredArgs',
51
- 'CsiVolumeTopologyRequestRequiredArgsDict',
52
30
  'CsiVolumeTopologyRequestRequiredTopologyArgs',
53
- 'CsiVolumeTopologyRequestRequiredTopologyArgsDict',
54
31
  'ExternalVolumeCapabilityArgs',
55
- 'ExternalVolumeCapabilityArgsDict',
56
32
  'ExternalVolumeMountOptionsArgs',
57
- 'ExternalVolumeMountOptionsArgsDict',
58
33
  'ExternalVolumeTopologyArgs',
59
- 'ExternalVolumeTopologyArgsDict',
60
34
  'ExternalVolumeTopologyRequestArgs',
61
- 'ExternalVolumeTopologyRequestArgsDict',
62
35
  'ExternalVolumeTopologyRequestPreferredArgs',
63
- 'ExternalVolumeTopologyRequestPreferredArgsDict',
64
36
  'ExternalVolumeTopologyRequestPreferredTopologyArgs',
65
- 'ExternalVolumeTopologyRequestPreferredTopologyArgsDict',
66
37
  'ExternalVolumeTopologyRequestRequiredArgs',
67
- 'ExternalVolumeTopologyRequestRequiredArgsDict',
68
38
  'ExternalVolumeTopologyRequestRequiredTopologyArgs',
69
- 'ExternalVolumeTopologyRequestRequiredTopologyArgsDict',
70
39
  'JobHcl2Args',
71
- 'JobHcl2ArgsDict',
72
40
  'JobTaskGroupArgs',
73
- 'JobTaskGroupArgsDict',
74
41
  'JobTaskGroupTaskArgs',
75
- 'JobTaskGroupTaskArgsDict',
76
42
  'JobTaskGroupTaskVolumeMountArgs',
77
- 'JobTaskGroupTaskVolumeMountArgsDict',
78
43
  'JobTaskGroupVolumeArgs',
79
- 'JobTaskGroupVolumeArgsDict',
80
44
  'NamespaceCapabilitiesArgs',
81
- 'NamespaceCapabilitiesArgsDict',
82
45
  'NamespaceNodePoolConfigArgs',
83
- 'NamespaceNodePoolConfigArgsDict',
84
46
  'NodePoolSchedulerConfigArgs',
85
- 'NodePoolSchedulerConfigArgsDict',
86
47
  'ProviderHeaderArgs',
87
- 'ProviderHeaderArgsDict',
88
48
  'QuoteSpecificationLimitArgs',
89
- 'QuoteSpecificationLimitArgsDict',
90
49
  'QuoteSpecificationLimitRegionLimitArgs',
91
- 'QuoteSpecificationLimitRegionLimitArgsDict',
92
50
  'VolumeCapabilityArgs',
93
- 'VolumeCapabilityArgsDict',
94
51
  'VolumeMountOptionsArgs',
95
- 'VolumeMountOptionsArgsDict',
96
52
  'VolumeTopologyArgs',
97
- 'VolumeTopologyArgsDict',
98
53
  'VolumeTopologyRequestArgs',
99
- 'VolumeTopologyRequestArgsDict',
100
54
  'VolumeTopologyRequestRequiredArgs',
101
- 'VolumeTopologyRequestRequiredArgsDict',
102
55
  'VolumeTopologyRequestRequiredTopologyArgs',
103
- 'VolumeTopologyRequestRequiredTopologyArgsDict',
104
56
  ]
105
57
 
106
- MYPY = False
107
-
108
- if not MYPY:
109
- class AclAuthMethodConfigArgsDict(TypedDict):
110
- allowed_redirect_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
111
- """
112
- `([]string: <optional>)` - A list of allowed values
113
- that can be used for the redirect URI.
114
- """
115
- bound_audiences: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
116
- """
117
- `([]string: <optional>)` - List of auth claims that are
118
- valid for login.
119
- """
120
- bound_issuers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
121
- """
122
- `([]string: <optional>)` - The value against which to match
123
- the iss claim in a JWT.
124
- """
125
- claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
126
- """
127
- Mappings of claims (key) that will be copied to a metadata field (value).
128
- """
129
- clock_skew_leeway: NotRequired[pulumi.Input[str]]
130
- """
131
- `(string: <optional>)` - Duration of leeway when validating
132
- all claims in the form of a time duration such as "5m" or "1h".
133
- """
134
- discovery_ca_pems: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
135
- """
136
- `([]string: <optional>)` - PEM encoded CA certs for use
137
- by the TLS client used to talk with the OIDC Discovery URL.
138
- """
139
- expiration_leeway: NotRequired[pulumi.Input[str]]
140
- """
141
- `(string: <optional>)` - Duration of leeway when validating
142
- expiration of a JWT in the form of a time duration such as "5m" or "1h".
143
- """
144
- jwks_ca_cert: NotRequired[pulumi.Input[str]]
145
- """
146
- `(string: <optional>)` - PEM encoded CA cert for use by the
147
- TLS client used to talk with the JWKS server.
148
- """
149
- jwks_url: NotRequired[pulumi.Input[str]]
150
- """
151
- `(string: <optional>)` - JSON Web Key Sets url for authenticating
152
- signatures.
153
- """
154
- jwt_validation_pub_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
155
- """
156
- `([]string: <optional>)` - List of PEM-encoded
157
- public keys to use to authenticate signatures locally.
158
- """
159
- list_claim_mappings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
160
- """
161
- Mappings of list claims (key) that will be copied to a metadata field (value).
162
- """
163
- not_before_leeway: NotRequired[pulumi.Input[str]]
164
- """
165
- `(string: <optional>)` - Duration of leeway when validating
166
- not before values of a token in the form of a time duration such as "5m" or "1h".
167
- """
168
- oidc_client_id: NotRequired[pulumi.Input[str]]
169
- """
170
- `(string: <optional>)` - The OAuth Client ID configured
171
- with the OIDC provider.
172
- """
173
- oidc_client_secret: NotRequired[pulumi.Input[str]]
174
- """
175
- `(string: <optional>)` - The OAuth Client Secret
176
- configured with the OIDC provider.
177
- """
178
- oidc_disable_userinfo: NotRequired[pulumi.Input[bool]]
179
- """
180
- `(bool: false)` - When set to `true`, Nomad will
181
- not make a request to the identity provider to get OIDC `UserInfo`.
182
- You may wish to set this if your identity provider doesn't send any
183
- additional claims from the `UserInfo` endpoint.
184
- """
185
- oidc_discovery_url: NotRequired[pulumi.Input[str]]
186
- """
187
- `(string: <optional>)` - The OIDC Discovery URL,
188
- without any .well-known component (base path).
189
- """
190
- oidc_scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
191
- """
192
- `([]string: <optional>)` - List of OIDC scopes.
193
- """
194
- signing_algs: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
195
- """
196
- `([]string: <optional>)` - A list of supported signing
197
- algorithms.
198
- """
199
- elif False:
200
- AclAuthMethodConfigArgsDict: TypeAlias = Mapping[str, Any]
201
-
202
58
  @pulumi.input_type
203
59
  class AclAuthMethodConfigArgs:
204
60
  def __init__(__self__, *,
@@ -528,27 +384,6 @@ class AclAuthMethodConfigArgs:
528
384
  pulumi.set(self, "signing_algs", value)
529
385
 
530
386
 
531
- if not MYPY:
532
- class AclPolicyJobAclArgsDict(TypedDict):
533
- job_id: pulumi.Input[str]
534
- """
535
- Job
536
- """
537
- group: NotRequired[pulumi.Input[str]]
538
- """
539
- Group
540
- """
541
- namespace: NotRequired[pulumi.Input[str]]
542
- """
543
- Namespace
544
- """
545
- task: NotRequired[pulumi.Input[str]]
546
- """
547
- Task
548
- """
549
- elif False:
550
- AclPolicyJobAclArgsDict: TypeAlias = Mapping[str, Any]
551
-
552
387
  @pulumi.input_type
553
388
  class AclPolicyJobAclArgs:
554
389
  def __init__(__self__, *,
@@ -619,15 +454,6 @@ class AclPolicyJobAclArgs:
619
454
  pulumi.set(self, "task", value)
620
455
 
621
456
 
622
- if not MYPY:
623
- class AclRolePolicyArgsDict(TypedDict):
624
- name: pulumi.Input[str]
625
- """
626
- `(string: <required>)` - A human-friendly name for this ACL Role.
627
- """
628
- elif False:
629
- AclRolePolicyArgsDict: TypeAlias = Mapping[str, Any]
630
-
631
457
  @pulumi.input_type
632
458
  class AclRolePolicyArgs:
633
459
  def __init__(__self__, *,
@@ -650,19 +476,6 @@ class AclRolePolicyArgs:
650
476
  pulumi.set(self, "name", value)
651
477
 
652
478
 
653
- if not MYPY:
654
- class AclTokenRoleArgsDict(TypedDict):
655
- id: pulumi.Input[str]
656
- """
657
- The ID of the ACL role to link.
658
- """
659
- name: NotRequired[pulumi.Input[str]]
660
- """
661
- `(string: "")` - A human-friendly name for this token.
662
- """
663
- elif False:
664
- AclTokenRoleArgsDict: TypeAlias = Mapping[str, Any]
665
-
666
479
  @pulumi.input_type
667
480
  class AclTokenRoleArgs:
668
481
  def __init__(__self__, *,
@@ -701,26 +514,6 @@ class AclTokenRoleArgs:
701
514
  pulumi.set(self, "name", value)
702
515
 
703
516
 
704
- if not MYPY:
705
- class CsiVolumeCapabilityArgsDict(TypedDict):
706
- access_mode: pulumi.Input[str]
707
- """
708
- `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
709
- - `single-node-reader-only`
710
- - `single-node-writer`
711
- - `multi-node-reader-only`
712
- - `multi-node-single-writer`
713
- - `multi-node-multi-writer`
714
- """
715
- attachment_mode: pulumi.Input[str]
716
- """
717
- `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
718
- - `block-device`
719
- - `file-system`
720
- """
721
- elif False:
722
- CsiVolumeCapabilityArgsDict: TypeAlias = Mapping[str, Any]
723
-
724
517
  @pulumi.input_type
725
518
  class CsiVolumeCapabilityArgs:
726
519
  def __init__(__self__, *,
@@ -772,19 +565,6 @@ class CsiVolumeCapabilityArgs:
772
565
  pulumi.set(self, "attachment_mode", value)
773
566
 
774
567
 
775
- if not MYPY:
776
- class CsiVolumeMountOptionsArgsDict(TypedDict):
777
- fs_type: NotRequired[pulumi.Input[str]]
778
- """
779
- `(string: optional)` - The file system type.
780
- """
781
- mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
782
- """
783
- `[]string: optional` - The flags passed to `mount`.
784
- """
785
- elif False:
786
- CsiVolumeMountOptionsArgsDict: TypeAlias = Mapping[str, Any]
787
-
788
568
  @pulumi.input_type
789
569
  class CsiVolumeMountOptionsArgs:
790
570
  def __init__(__self__, *,
@@ -824,26 +604,6 @@ class CsiVolumeMountOptionsArgs:
824
604
  pulumi.set(self, "mount_flags", value)
825
605
 
826
606
 
827
- if not MYPY:
828
- class CsiVolumeRegistrationCapabilityArgsDict(TypedDict):
829
- access_mode: pulumi.Input[str]
830
- """
831
- `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
832
- - `single-node-reader-only`
833
- - `single-node-writer`
834
- - `multi-node-reader-only`
835
- - `multi-node-single-writer`
836
- - `multi-node-multi-writer`
837
- """
838
- attachment_mode: pulumi.Input[str]
839
- """
840
- `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
841
- - `block-device`
842
- - `file-system`
843
- """
844
- elif False:
845
- CsiVolumeRegistrationCapabilityArgsDict: TypeAlias = Mapping[str, Any]
846
-
847
607
  @pulumi.input_type
848
608
  class CsiVolumeRegistrationCapabilityArgs:
849
609
  def __init__(__self__, *,
@@ -895,19 +655,6 @@ class CsiVolumeRegistrationCapabilityArgs:
895
655
  pulumi.set(self, "attachment_mode", value)
896
656
 
897
657
 
898
- if not MYPY:
899
- class CsiVolumeRegistrationMountOptionsArgsDict(TypedDict):
900
- fs_type: NotRequired[pulumi.Input[str]]
901
- """
902
- `(string: <optional>)` - The file system type.
903
- """
904
- mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
905
- """
906
- `([]string: <optional>)` - The flags passed to `mount`.
907
- """
908
- elif False:
909
- CsiVolumeRegistrationMountOptionsArgsDict: TypeAlias = Mapping[str, Any]
910
-
911
658
  @pulumi.input_type
912
659
  class CsiVolumeRegistrationMountOptionsArgs:
913
660
  def __init__(__self__, *,
@@ -947,40 +694,16 @@ class CsiVolumeRegistrationMountOptionsArgs:
947
694
  pulumi.set(self, "mount_flags", value)
948
695
 
949
696
 
950
- if not MYPY:
951
- class CsiVolumeRegistrationTopologyArgsDict(TypedDict):
952
- segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
953
- """
954
- `(map[string]string)` - Define the attributes for the topology request.
955
-
956
- In addition to the above arguments, the following attributes are exported and
957
- can be referenced:
958
- """
959
- elif False:
960
- CsiVolumeRegistrationTopologyArgsDict: TypeAlias = Mapping[str, Any]
961
-
962
697
  @pulumi.input_type
963
698
  class CsiVolumeRegistrationTopologyArgs:
964
699
  def __init__(__self__, *,
965
700
  segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
966
- """
967
- :param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
968
-
969
- In addition to the above arguments, the following attributes are exported and
970
- can be referenced:
971
- """
972
701
  if segments is not None:
973
702
  pulumi.set(__self__, "segments", segments)
974
703
 
975
704
  @property
976
705
  @pulumi.getter
977
706
  def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
978
- """
979
- `(map[string]string)` - Define the attributes for the topology request.
980
-
981
- In addition to the above arguments, the following attributes are exported and
982
- can be referenced:
983
- """
984
707
  return pulumi.get(self, "segments")
985
708
 
986
709
  @segments.setter
@@ -988,15 +711,6 @@ class CsiVolumeRegistrationTopologyArgs:
988
711
  pulumi.set(self, "segments", value)
989
712
 
990
713
 
991
- if not MYPY:
992
- class CsiVolumeRegistrationTopologyRequestArgsDict(TypedDict):
993
- required: NotRequired[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredArgsDict']]
994
- """
995
- `(``Topology``: <optional>)` - Required topologies indicate that the volume must be created in a location accessible from all the listed topologies.
996
- """
997
- elif False:
998
- CsiVolumeRegistrationTopologyRequestArgsDict: TypeAlias = Mapping[str, Any]
999
-
1000
714
  @pulumi.input_type
1001
715
  class CsiVolumeRegistrationTopologyRequestArgs:
1002
716
  def __init__(__self__, *,
@@ -1020,15 +734,6 @@ class CsiVolumeRegistrationTopologyRequestArgs:
1020
734
  pulumi.set(self, "required", value)
1021
735
 
1022
736
 
1023
- if not MYPY:
1024
- class CsiVolumeRegistrationTopologyRequestRequiredArgsDict(TypedDict):
1025
- topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict']]]
1026
- """
1027
- Defines the location for the volume.
1028
- """
1029
- elif False:
1030
- CsiVolumeRegistrationTopologyRequestRequiredArgsDict: TypeAlias = Mapping[str, Any]
1031
-
1032
737
  @pulumi.input_type
1033
738
  class CsiVolumeRegistrationTopologyRequestRequiredArgs:
1034
739
  def __init__(__self__, *,
@@ -1051,15 +756,6 @@ class CsiVolumeRegistrationTopologyRequestRequiredArgs:
1051
756
  pulumi.set(self, "topologies", value)
1052
757
 
1053
758
 
1054
- if not MYPY:
1055
- class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict(TypedDict):
1056
- segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
1057
- """
1058
- Define attributes for the topology request.
1059
- """
1060
- elif False:
1061
- CsiVolumeRegistrationTopologyRequestRequiredTopologyArgsDict: TypeAlias = Mapping[str, Any]
1062
-
1063
759
  @pulumi.input_type
1064
760
  class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
1065
761
  def __init__(__self__, *,
@@ -1082,40 +778,16 @@ class CsiVolumeRegistrationTopologyRequestRequiredTopologyArgs:
1082
778
  pulumi.set(self, "segments", value)
1083
779
 
1084
780
 
1085
- if not MYPY:
1086
- class CsiVolumeTopologyArgsDict(TypedDict):
1087
- segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
1088
- """
1089
- `(map[string]string)` - Define the attributes for the topology request.
1090
-
1091
- In addition to the above arguments, the following attributes are exported and
1092
- can be referenced:
1093
- """
1094
- elif False:
1095
- CsiVolumeTopologyArgsDict: TypeAlias = Mapping[str, Any]
1096
-
1097
781
  @pulumi.input_type
1098
782
  class CsiVolumeTopologyArgs:
1099
783
  def __init__(__self__, *,
1100
784
  segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
1101
- """
1102
- :param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
1103
-
1104
- In addition to the above arguments, the following attributes are exported and
1105
- can be referenced:
1106
- """
1107
785
  if segments is not None:
1108
786
  pulumi.set(__self__, "segments", segments)
1109
787
 
1110
788
  @property
1111
789
  @pulumi.getter
1112
790
  def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
1113
- """
1114
- `(map[string]string)` - Define the attributes for the topology request.
1115
-
1116
- In addition to the above arguments, the following attributes are exported and
1117
- can be referenced:
1118
- """
1119
791
  return pulumi.get(self, "segments")
1120
792
 
1121
793
  @segments.setter
@@ -1123,19 +795,6 @@ class CsiVolumeTopologyArgs:
1123
795
  pulumi.set(self, "segments", value)
1124
796
 
1125
797
 
1126
- if not MYPY:
1127
- class CsiVolumeTopologyRequestArgsDict(TypedDict):
1128
- preferred: NotRequired[pulumi.Input['CsiVolumeTopologyRequestPreferredArgsDict']]
1129
- """
1130
- `(``Topology``: <optional>)` - Preferred topologies indicate that the volume should be created in a location accessible from some of the listed topologies.
1131
- """
1132
- required: NotRequired[pulumi.Input['CsiVolumeTopologyRequestRequiredArgsDict']]
1133
- """
1134
- `(``Topology``: <optional>)` - Required topologies indicate that the volume must be created in a location accessible from all the listed topologies.
1135
- """
1136
- elif False:
1137
- CsiVolumeTopologyRequestArgsDict: TypeAlias = Mapping[str, Any]
1138
-
1139
798
  @pulumi.input_type
1140
799
  class CsiVolumeTopologyRequestArgs:
1141
800
  def __init__(__self__, *,
@@ -1175,15 +834,6 @@ class CsiVolumeTopologyRequestArgs:
1175
834
  pulumi.set(self, "required", value)
1176
835
 
1177
836
 
1178
- if not MYPY:
1179
- class CsiVolumeTopologyRequestPreferredArgsDict(TypedDict):
1180
- topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestPreferredTopologyArgsDict']]]
1181
- """
1182
- Defines the location for the volume.
1183
- """
1184
- elif False:
1185
- CsiVolumeTopologyRequestPreferredArgsDict: TypeAlias = Mapping[str, Any]
1186
-
1187
837
  @pulumi.input_type
1188
838
  class CsiVolumeTopologyRequestPreferredArgs:
1189
839
  def __init__(__self__, *,
@@ -1206,15 +856,6 @@ class CsiVolumeTopologyRequestPreferredArgs:
1206
856
  pulumi.set(self, "topologies", value)
1207
857
 
1208
858
 
1209
- if not MYPY:
1210
- class CsiVolumeTopologyRequestPreferredTopologyArgsDict(TypedDict):
1211
- segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
1212
- """
1213
- Define the attributes for the topology request.
1214
- """
1215
- elif False:
1216
- CsiVolumeTopologyRequestPreferredTopologyArgsDict: TypeAlias = Mapping[str, Any]
1217
-
1218
859
  @pulumi.input_type
1219
860
  class CsiVolumeTopologyRequestPreferredTopologyArgs:
1220
861
  def __init__(__self__, *,
@@ -1237,15 +878,6 @@ class CsiVolumeTopologyRequestPreferredTopologyArgs:
1237
878
  pulumi.set(self, "segments", value)
1238
879
 
1239
880
 
1240
- if not MYPY:
1241
- class CsiVolumeTopologyRequestRequiredArgsDict(TypedDict):
1242
- topologies: pulumi.Input[Sequence[pulumi.Input['CsiVolumeTopologyRequestRequiredTopologyArgsDict']]]
1243
- """
1244
- Defines the location for the volume.
1245
- """
1246
- elif False:
1247
- CsiVolumeTopologyRequestRequiredArgsDict: TypeAlias = Mapping[str, Any]
1248
-
1249
881
  @pulumi.input_type
1250
882
  class CsiVolumeTopologyRequestRequiredArgs:
1251
883
  def __init__(__self__, *,
@@ -1268,15 +900,6 @@ class CsiVolumeTopologyRequestRequiredArgs:
1268
900
  pulumi.set(self, "topologies", value)
1269
901
 
1270
902
 
1271
- if not MYPY:
1272
- class CsiVolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
1273
- segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
1274
- """
1275
- Define the attributes for the topology request.
1276
- """
1277
- elif False:
1278
- CsiVolumeTopologyRequestRequiredTopologyArgsDict: TypeAlias = Mapping[str, Any]
1279
-
1280
903
  @pulumi.input_type
1281
904
  class CsiVolumeTopologyRequestRequiredTopologyArgs:
1282
905
  def __init__(__self__, *,
@@ -1299,26 +922,6 @@ class CsiVolumeTopologyRequestRequiredTopologyArgs:
1299
922
  pulumi.set(self, "segments", value)
1300
923
 
1301
924
 
1302
- if not MYPY:
1303
- class ExternalVolumeCapabilityArgsDict(TypedDict):
1304
- access_mode: pulumi.Input[str]
1305
- """
1306
- `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
1307
- - `single-node-reader-only`
1308
- - `single-node-writer`
1309
- - `multi-node-reader-only`
1310
- - `multi-node-single-writer`
1311
- - `multi-node-multi-writer`
1312
- """
1313
- attachment_mode: pulumi.Input[str]
1314
- """
1315
- `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
1316
- - `block-device`
1317
- - `file-system`
1318
- """
1319
- elif False:
1320
- ExternalVolumeCapabilityArgsDict: TypeAlias = Mapping[str, Any]
1321
-
1322
925
  @pulumi.input_type
1323
926
  class ExternalVolumeCapabilityArgs:
1324
927
  def __init__(__self__, *,
@@ -1370,19 +973,6 @@ class ExternalVolumeCapabilityArgs:
1370
973
  pulumi.set(self, "attachment_mode", value)
1371
974
 
1372
975
 
1373
- if not MYPY:
1374
- class ExternalVolumeMountOptionsArgsDict(TypedDict):
1375
- fs_type: NotRequired[pulumi.Input[str]]
1376
- """
1377
- `(string: optional)` - The file system type.
1378
- """
1379
- mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1380
- """
1381
- `[]string: optional` - The flags passed to `mount`.
1382
- """
1383
- elif False:
1384
- ExternalVolumeMountOptionsArgsDict: TypeAlias = Mapping[str, Any]
1385
-
1386
976
  @pulumi.input_type
1387
977
  class ExternalVolumeMountOptionsArgs:
1388
978
  def __init__(__self__, *,
@@ -1422,40 +1012,16 @@ class ExternalVolumeMountOptionsArgs:
1422
1012
  pulumi.set(self, "mount_flags", value)
1423
1013
 
1424
1014
 
1425
- if not MYPY:
1426
- class ExternalVolumeTopologyArgsDict(TypedDict):
1427
- segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
1428
- """
1429
- `(map[string]string)` - Define the attributes for the topology request.
1430
-
1431
- In addition to the above arguments, the following attributes are exported and
1432
- can be referenced:
1433
- """
1434
- elif False:
1435
- ExternalVolumeTopologyArgsDict: TypeAlias = Mapping[str, Any]
1436
-
1437
1015
  @pulumi.input_type
1438
1016
  class ExternalVolumeTopologyArgs:
1439
1017
  def __init__(__self__, *,
1440
1018
  segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
1441
- """
1442
- :param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
1443
-
1444
- In addition to the above arguments, the following attributes are exported and
1445
- can be referenced:
1446
- """
1447
1019
  if segments is not None:
1448
1020
  pulumi.set(__self__, "segments", segments)
1449
1021
 
1450
1022
  @property
1451
1023
  @pulumi.getter
1452
1024
  def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
1453
- """
1454
- `(map[string]string)` - Define the attributes for the topology request.
1455
-
1456
- In addition to the above arguments, the following attributes are exported and
1457
- can be referenced:
1458
- """
1459
1025
  return pulumi.get(self, "segments")
1460
1026
 
1461
1027
  @segments.setter
@@ -1463,19 +1029,6 @@ class ExternalVolumeTopologyArgs:
1463
1029
  pulumi.set(self, "segments", value)
1464
1030
 
1465
1031
 
1466
- if not MYPY:
1467
- class ExternalVolumeTopologyRequestArgsDict(TypedDict):
1468
- preferred: NotRequired[pulumi.Input['ExternalVolumeTopologyRequestPreferredArgsDict']]
1469
- """
1470
- `(``Topology``: <optional>)` - Preferred topologies indicate that the volume should be created in a location accessible from some of the listed topologies.
1471
- """
1472
- required: NotRequired[pulumi.Input['ExternalVolumeTopologyRequestRequiredArgsDict']]
1473
- """
1474
- `(``Topology``: <optional>)` - Required topologies indicate that the volume must be created in a location accessible from all the listed topologies.
1475
- """
1476
- elif False:
1477
- ExternalVolumeTopologyRequestArgsDict: TypeAlias = Mapping[str, Any]
1478
-
1479
1032
  @pulumi.input_type
1480
1033
  class ExternalVolumeTopologyRequestArgs:
1481
1034
  def __init__(__self__, *,
@@ -1515,15 +1068,6 @@ class ExternalVolumeTopologyRequestArgs:
1515
1068
  pulumi.set(self, "required", value)
1516
1069
 
1517
1070
 
1518
- if not MYPY:
1519
- class ExternalVolumeTopologyRequestPreferredArgsDict(TypedDict):
1520
- topologies: pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestPreferredTopologyArgsDict']]]
1521
- """
1522
- Defines the location for the volume.
1523
- """
1524
- elif False:
1525
- ExternalVolumeTopologyRequestPreferredArgsDict: TypeAlias = Mapping[str, Any]
1526
-
1527
1071
  @pulumi.input_type
1528
1072
  class ExternalVolumeTopologyRequestPreferredArgs:
1529
1073
  def __init__(__self__, *,
@@ -1546,15 +1090,6 @@ class ExternalVolumeTopologyRequestPreferredArgs:
1546
1090
  pulumi.set(self, "topologies", value)
1547
1091
 
1548
1092
 
1549
- if not MYPY:
1550
- class ExternalVolumeTopologyRequestPreferredTopologyArgsDict(TypedDict):
1551
- segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
1552
- """
1553
- Define the attributes for the topology request.
1554
- """
1555
- elif False:
1556
- ExternalVolumeTopologyRequestPreferredTopologyArgsDict: TypeAlias = Mapping[str, Any]
1557
-
1558
1093
  @pulumi.input_type
1559
1094
  class ExternalVolumeTopologyRequestPreferredTopologyArgs:
1560
1095
  def __init__(__self__, *,
@@ -1577,15 +1112,6 @@ class ExternalVolumeTopologyRequestPreferredTopologyArgs:
1577
1112
  pulumi.set(self, "segments", value)
1578
1113
 
1579
1114
 
1580
- if not MYPY:
1581
- class ExternalVolumeTopologyRequestRequiredArgsDict(TypedDict):
1582
- topologies: pulumi.Input[Sequence[pulumi.Input['ExternalVolumeTopologyRequestRequiredTopologyArgsDict']]]
1583
- """
1584
- Defines the location for the volume.
1585
- """
1586
- elif False:
1587
- ExternalVolumeTopologyRequestRequiredArgsDict: TypeAlias = Mapping[str, Any]
1588
-
1589
1115
  @pulumi.input_type
1590
1116
  class ExternalVolumeTopologyRequestRequiredArgs:
1591
1117
  def __init__(__self__, *,
@@ -1608,15 +1134,6 @@ class ExternalVolumeTopologyRequestRequiredArgs:
1608
1134
  pulumi.set(self, "topologies", value)
1609
1135
 
1610
1136
 
1611
- if not MYPY:
1612
- class ExternalVolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
1613
- segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
1614
- """
1615
- Define the attributes for the topology request.
1616
- """
1617
- elif False:
1618
- ExternalVolumeTopologyRequestRequiredTopologyArgsDict: TypeAlias = Mapping[str, Any]
1619
-
1620
1137
  @pulumi.input_type
1621
1138
  class ExternalVolumeTopologyRequestRequiredTopologyArgs:
1622
1139
  def __init__(__self__, *,
@@ -1639,37 +1156,18 @@ class ExternalVolumeTopologyRequestRequiredTopologyArgs:
1639
1156
  pulumi.set(self, "segments", value)
1640
1157
 
1641
1158
 
1642
- if not MYPY:
1643
- class JobHcl2ArgsDict(TypedDict):
1644
- allow_fs: NotRequired[pulumi.Input[bool]]
1645
- """
1646
- `(boolean: false)` - Set this to `true` to be able to use
1647
- HCL2 filesystem functions
1648
- """
1649
- enabled: NotRequired[pulumi.Input[bool]]
1650
- """
1651
- `(boolean: false)` - **Deprecated** All HCL jobs are parsed as
1652
- HCL2 by default.
1653
- """
1654
- vars: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
1655
- """
1656
- Additional variables to use when templating the job with HCL2
1657
- """
1658
- elif False:
1659
- JobHcl2ArgsDict: TypeAlias = Mapping[str, Any]
1660
-
1661
1159
  @pulumi.input_type
1662
1160
  class JobHcl2Args:
1663
1161
  def __init__(__self__, *,
1664
1162
  allow_fs: Optional[pulumi.Input[bool]] = None,
1665
1163
  enabled: Optional[pulumi.Input[bool]] = None,
1666
- vars: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
1164
+ vars: Optional[pulumi.Input[Mapping[str, Any]]] = None):
1667
1165
  """
1668
1166
  :param pulumi.Input[bool] allow_fs: `(boolean: false)` - Set this to `true` to be able to use
1669
1167
  HCL2 filesystem functions
1670
1168
  :param pulumi.Input[bool] enabled: `(boolean: false)` - **Deprecated** All HCL jobs are parsed as
1671
1169
  HCL2 by default.
1672
- :param pulumi.Input[Mapping[str, pulumi.Input[str]]] vars: Additional variables to use when templating the job with HCL2
1170
+ :param pulumi.Input[Mapping[str, Any]] vars: Additional variables to use when templating the job with HCL2
1673
1171
  """
1674
1172
  if allow_fs is not None:
1675
1173
  pulumi.set(__self__, "allow_fs", allow_fs)
@@ -1696,12 +1194,14 @@ class JobHcl2Args:
1696
1194
 
1697
1195
  @property
1698
1196
  @pulumi.getter
1699
- @_utilities.deprecated("""Starting with version 2.0.0 of the Nomad provider, jobs are parsed using HCL2 by default, so this field is no longer used and may be safely removed from your configuration files. Set 'hcl1 = true' if you must use HCL1 job parsing.""")
1700
1197
  def enabled(self) -> Optional[pulumi.Input[bool]]:
1701
1198
  """
1702
1199
  `(boolean: false)` - **Deprecated** All HCL jobs are parsed as
1703
1200
  HCL2 by default.
1704
1201
  """
1202
+ warnings.warn("""Starting with version 2.0.0 of the Nomad provider, jobs are parsed using HCL2 by default, so this field is no longer used and may be safely removed from your configuration files. Set 'hcl1 = true' if you must use HCL1 job parsing.""", DeprecationWarning)
1203
+ pulumi.log.warn("""enabled is deprecated: Starting with version 2.0.0 of the Nomad provider, jobs are parsed using HCL2 by default, so this field is no longer used and may be safely removed from your configuration files. Set 'hcl1 = true' if you must use HCL1 job parsing.""")
1204
+
1705
1205
  return pulumi.get(self, "enabled")
1706
1206
 
1707
1207
  @enabled.setter
@@ -1710,32 +1210,22 @@ class JobHcl2Args:
1710
1210
 
1711
1211
  @property
1712
1212
  @pulumi.getter
1713
- def vars(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
1213
+ def vars(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
1714
1214
  """
1715
1215
  Additional variables to use when templating the job with HCL2
1716
1216
  """
1717
1217
  return pulumi.get(self, "vars")
1718
1218
 
1719
1219
  @vars.setter
1720
- def vars(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
1220
+ def vars(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
1721
1221
  pulumi.set(self, "vars", value)
1722
1222
 
1723
1223
 
1724
- if not MYPY:
1725
- class JobTaskGroupArgsDict(TypedDict):
1726
- count: NotRequired[pulumi.Input[int]]
1727
- meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
1728
- name: NotRequired[pulumi.Input[str]]
1729
- tasks: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgsDict']]]]
1730
- volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgsDict']]]]
1731
- elif False:
1732
- JobTaskGroupArgsDict: TypeAlias = Mapping[str, Any]
1733
-
1734
1224
  @pulumi.input_type
1735
1225
  class JobTaskGroupArgs:
1736
1226
  def __init__(__self__, *,
1737
1227
  count: Optional[pulumi.Input[int]] = None,
1738
- meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
1228
+ meta: Optional[pulumi.Input[Mapping[str, Any]]] = None,
1739
1229
  name: Optional[pulumi.Input[str]] = None,
1740
1230
  tasks: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskArgs']]]] = None,
1741
1231
  volumes: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupVolumeArgs']]]] = None):
@@ -1761,11 +1251,11 @@ class JobTaskGroupArgs:
1761
1251
 
1762
1252
  @property
1763
1253
  @pulumi.getter
1764
- def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
1254
+ def meta(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
1765
1255
  return pulumi.get(self, "meta")
1766
1256
 
1767
1257
  @meta.setter
1768
- def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
1258
+ def meta(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
1769
1259
  pulumi.set(self, "meta", value)
1770
1260
 
1771
1261
  @property
@@ -1796,20 +1286,11 @@ class JobTaskGroupArgs:
1796
1286
  pulumi.set(self, "volumes", value)
1797
1287
 
1798
1288
 
1799
- if not MYPY:
1800
- class JobTaskGroupTaskArgsDict(TypedDict):
1801
- driver: NotRequired[pulumi.Input[str]]
1802
- meta: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
1803
- name: NotRequired[pulumi.Input[str]]
1804
- volume_mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgsDict']]]]
1805
- elif False:
1806
- JobTaskGroupTaskArgsDict: TypeAlias = Mapping[str, Any]
1807
-
1808
1289
  @pulumi.input_type
1809
1290
  class JobTaskGroupTaskArgs:
1810
1291
  def __init__(__self__, *,
1811
1292
  driver: Optional[pulumi.Input[str]] = None,
1812
- meta: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
1293
+ meta: Optional[pulumi.Input[Mapping[str, Any]]] = None,
1813
1294
  name: Optional[pulumi.Input[str]] = None,
1814
1295
  volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupTaskVolumeMountArgs']]]] = None):
1815
1296
  if driver is not None:
@@ -1832,11 +1313,11 @@ class JobTaskGroupTaskArgs:
1832
1313
 
1833
1314
  @property
1834
1315
  @pulumi.getter
1835
- def meta(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
1316
+ def meta(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
1836
1317
  return pulumi.get(self, "meta")
1837
1318
 
1838
1319
  @meta.setter
1839
- def meta(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
1320
+ def meta(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
1840
1321
  pulumi.set(self, "meta", value)
1841
1322
 
1842
1323
  @property
@@ -1858,14 +1339,6 @@ class JobTaskGroupTaskArgs:
1858
1339
  pulumi.set(self, "volume_mounts", value)
1859
1340
 
1860
1341
 
1861
- if not MYPY:
1862
- class JobTaskGroupTaskVolumeMountArgsDict(TypedDict):
1863
- destination: NotRequired[pulumi.Input[str]]
1864
- read_only: NotRequired[pulumi.Input[bool]]
1865
- volume: NotRequired[pulumi.Input[str]]
1866
- elif False:
1867
- JobTaskGroupTaskVolumeMountArgsDict: TypeAlias = Mapping[str, Any]
1868
-
1869
1342
  @pulumi.input_type
1870
1343
  class JobTaskGroupTaskVolumeMountArgs:
1871
1344
  def __init__(__self__, *,
@@ -1907,15 +1380,6 @@ class JobTaskGroupTaskVolumeMountArgs:
1907
1380
  pulumi.set(self, "volume", value)
1908
1381
 
1909
1382
 
1910
- if not MYPY:
1911
- class JobTaskGroupVolumeArgsDict(TypedDict):
1912
- name: NotRequired[pulumi.Input[str]]
1913
- read_only: NotRequired[pulumi.Input[bool]]
1914
- source: NotRequired[pulumi.Input[str]]
1915
- type: NotRequired[pulumi.Input[str]]
1916
- elif False:
1917
- JobTaskGroupVolumeArgsDict: TypeAlias = Mapping[str, Any]
1918
-
1919
1383
  @pulumi.input_type
1920
1384
  class JobTaskGroupVolumeArgs:
1921
1385
  def __init__(__self__, *,
@@ -1969,19 +1433,6 @@ class JobTaskGroupVolumeArgs:
1969
1433
  pulumi.set(self, "type", value)
1970
1434
 
1971
1435
 
1972
- if not MYPY:
1973
- class NamespaceCapabilitiesArgsDict(TypedDict):
1974
- disabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1975
- """
1976
- `([]string: <optional>)` - Task drivers disabled for the namespace.
1977
- """
1978
- enabled_task_drivers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1979
- """
1980
- `([]string: <optional>)` - Task drivers enabled for the namespace.
1981
- """
1982
- elif False:
1983
- NamespaceCapabilitiesArgsDict: TypeAlias = Mapping[str, Any]
1984
-
1985
1436
  @pulumi.input_type
1986
1437
  class NamespaceCapabilitiesArgs:
1987
1438
  def __init__(__self__, *,
@@ -2021,23 +1472,6 @@ class NamespaceCapabilitiesArgs:
2021
1472
  pulumi.set(self, "enabled_task_drivers", value)
2022
1473
 
2023
1474
 
2024
- if not MYPY:
2025
- class NamespaceNodePoolConfigArgsDict(TypedDict):
2026
- alloweds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
2027
- """
2028
- `([]string: <optional>)` - The list of node pools that are allowed to be used in this namespace.
2029
- """
2030
- default: NotRequired[pulumi.Input[str]]
2031
- """
2032
- `(string: <optional>)` - The default node pool for jobs that don't define one.
2033
- """
2034
- denieds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
2035
- """
2036
- `([]string: <optional>)` - The list of node pools that are not allowed to be used in this namespace.
2037
- """
2038
- elif False:
2039
- NamespaceNodePoolConfigArgsDict: TypeAlias = Mapping[str, Any]
2040
-
2041
1475
  @pulumi.input_type
2042
1476
  class NamespaceNodePoolConfigArgs:
2043
1477
  def __init__(__self__, *,
@@ -2093,28 +1527,6 @@ class NamespaceNodePoolConfigArgs:
2093
1527
  pulumi.set(self, "denieds", value)
2094
1528
 
2095
1529
 
2096
- if not MYPY:
2097
- class NodePoolSchedulerConfigArgsDict(TypedDict):
2098
- memory_oversubscription: NotRequired[pulumi.Input[str]]
2099
- """
2100
- `(string)` - Whether or not memory
2101
- oversubscription is enabled in the node pool. Possible values are
2102
- `"enabled"` or `"disabled"`. If not defined the global cluster
2103
- configuration is used.
2104
-
2105
- > This option differs from Nomad, where it's represented as a boolean, to
2106
- allow distinguishing between memory oversubscription being disabled in the
2107
- node pool and this property not being set.
2108
- """
2109
- scheduler_algorithm: NotRequired[pulumi.Input[str]]
2110
- """
2111
- `(string)` - The scheduler algorithm used in the node
2112
- pool. Possible values are `binpack` or `spread`. If not defined the global
2113
- cluster configuration is used.
2114
- """
2115
- elif False:
2116
- NodePoolSchedulerConfigArgsDict: TypeAlias = Mapping[str, Any]
2117
-
2118
1530
  @pulumi.input_type
2119
1531
  class NodePoolSchedulerConfigArgs:
2120
1532
  def __init__(__self__, *,
@@ -2172,19 +1584,6 @@ class NodePoolSchedulerConfigArgs:
2172
1584
  pulumi.set(self, "scheduler_algorithm", value)
2173
1585
 
2174
1586
 
2175
- if not MYPY:
2176
- class ProviderHeaderArgsDict(TypedDict):
2177
- name: pulumi.Input[str]
2178
- """
2179
- The header name
2180
- """
2181
- value: pulumi.Input[str]
2182
- """
2183
- The header value
2184
- """
2185
- elif False:
2186
- ProviderHeaderArgsDict: TypeAlias = Mapping[str, Any]
2187
-
2188
1587
  @pulumi.input_type
2189
1588
  class ProviderHeaderArgs:
2190
1589
  def __init__(__self__, *,
@@ -2222,21 +1621,6 @@ class ProviderHeaderArgs:
2222
1621
  pulumi.set(self, "value", value)
2223
1622
 
2224
1623
 
2225
- if not MYPY:
2226
- class QuoteSpecificationLimitArgsDict(TypedDict):
2227
- region: pulumi.Input[str]
2228
- """
2229
- `(string: <required>)` - The region these limits should apply to.
2230
- """
2231
- region_limit: pulumi.Input['QuoteSpecificationLimitRegionLimitArgsDict']
2232
- """
2233
- `(block: <required>)` - The limits to enforce. This block
2234
- may only be specified once in the `limits` block. Its structure is
2235
- documented below.
2236
- """
2237
- elif False:
2238
- QuoteSpecificationLimitArgsDict: TypeAlias = Mapping[str, Any]
2239
-
2240
1624
  @pulumi.input_type
2241
1625
  class QuoteSpecificationLimitArgs:
2242
1626
  def __init__(__self__, *,
@@ -2278,22 +1662,6 @@ class QuoteSpecificationLimitArgs:
2278
1662
  pulumi.set(self, "region_limit", value)
2279
1663
 
2280
1664
 
2281
- if not MYPY:
2282
- class QuoteSpecificationLimitRegionLimitArgsDict(TypedDict):
2283
- cpu: NotRequired[pulumi.Input[int]]
2284
- """
2285
- `(int: 0)` - The amount of CPU to limit allocations to. A value of zero
2286
- is treated as unlimited, and a negative value is treated as fully disallowed.
2287
- """
2288
- memory_mb: NotRequired[pulumi.Input[int]]
2289
- """
2290
- `(int: 0)` - The amount of memory (in megabytes) to limit
2291
- allocations to. A value of zero is treated as unlimited, and a negative value
2292
- is treated as fully disallowed.
2293
- """
2294
- elif False:
2295
- QuoteSpecificationLimitRegionLimitArgsDict: TypeAlias = Mapping[str, Any]
2296
-
2297
1665
  @pulumi.input_type
2298
1666
  class QuoteSpecificationLimitRegionLimitArgs:
2299
1667
  def __init__(__self__, *,
@@ -2339,26 +1707,6 @@ class QuoteSpecificationLimitRegionLimitArgs:
2339
1707
  pulumi.set(self, "memory_mb", value)
2340
1708
 
2341
1709
 
2342
- if not MYPY:
2343
- class VolumeCapabilityArgsDict(TypedDict):
2344
- access_mode: pulumi.Input[str]
2345
- """
2346
- `(string: <required>)` - Defines whether a volume should be available concurrently. Possible values are:
2347
- - `single-node-reader-only`
2348
- - `single-node-writer`
2349
- - `multi-node-reader-only`
2350
- - `multi-node-single-writer`
2351
- - `multi-node-multi-writer`
2352
- """
2353
- attachment_mode: pulumi.Input[str]
2354
- """
2355
- `(string: <required>)` - The storage API that will be used by the volume. Possible values are:
2356
- - `block-device`
2357
- - `file-system`
2358
- """
2359
- elif False:
2360
- VolumeCapabilityArgsDict: TypeAlias = Mapping[str, Any]
2361
-
2362
1710
  @pulumi.input_type
2363
1711
  class VolumeCapabilityArgs:
2364
1712
  def __init__(__self__, *,
@@ -2410,19 +1758,6 @@ class VolumeCapabilityArgs:
2410
1758
  pulumi.set(self, "attachment_mode", value)
2411
1759
 
2412
1760
 
2413
- if not MYPY:
2414
- class VolumeMountOptionsArgsDict(TypedDict):
2415
- fs_type: NotRequired[pulumi.Input[str]]
2416
- """
2417
- `(string: <optional>)` - The file system type.
2418
- """
2419
- mount_flags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
2420
- """
2421
- `([]string: <optional>)` - The flags passed to `mount`.
2422
- """
2423
- elif False:
2424
- VolumeMountOptionsArgsDict: TypeAlias = Mapping[str, Any]
2425
-
2426
1761
  @pulumi.input_type
2427
1762
  class VolumeMountOptionsArgs:
2428
1763
  def __init__(__self__, *,
@@ -2462,40 +1797,16 @@ class VolumeMountOptionsArgs:
2462
1797
  pulumi.set(self, "mount_flags", value)
2463
1798
 
2464
1799
 
2465
- if not MYPY:
2466
- class VolumeTopologyArgsDict(TypedDict):
2467
- segments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
2468
- """
2469
- `(map[string]string)` - Define the attributes for the topology request.
2470
-
2471
- In addition to the above arguments, the following attributes are exported and
2472
- can be referenced:
2473
- """
2474
- elif False:
2475
- VolumeTopologyArgsDict: TypeAlias = Mapping[str, Any]
2476
-
2477
1800
  @pulumi.input_type
2478
1801
  class VolumeTopologyArgs:
2479
1802
  def __init__(__self__, *,
2480
1803
  segments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
2481
- """
2482
- :param pulumi.Input[Mapping[str, pulumi.Input[str]]] segments: `(map[string]string)` - Define the attributes for the topology request.
2483
-
2484
- In addition to the above arguments, the following attributes are exported and
2485
- can be referenced:
2486
- """
2487
1804
  if segments is not None:
2488
1805
  pulumi.set(__self__, "segments", segments)
2489
1806
 
2490
1807
  @property
2491
1808
  @pulumi.getter
2492
1809
  def segments(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
2493
- """
2494
- `(map[string]string)` - Define the attributes for the topology request.
2495
-
2496
- In addition to the above arguments, the following attributes are exported and
2497
- can be referenced:
2498
- """
2499
1810
  return pulumi.get(self, "segments")
2500
1811
 
2501
1812
  @segments.setter
@@ -2503,15 +1814,6 @@ class VolumeTopologyArgs:
2503
1814
  pulumi.set(self, "segments", value)
2504
1815
 
2505
1816
 
2506
- if not MYPY:
2507
- class VolumeTopologyRequestArgsDict(TypedDict):
2508
- required: NotRequired[pulumi.Input['VolumeTopologyRequestRequiredArgsDict']]
2509
- """
2510
- `(``Topology``: <optional>)` - Required topologies indicate that the volume must be created in a location accessible from all the listed topologies.
2511
- """
2512
- elif False:
2513
- VolumeTopologyRequestArgsDict: TypeAlias = Mapping[str, Any]
2514
-
2515
1817
  @pulumi.input_type
2516
1818
  class VolumeTopologyRequestArgs:
2517
1819
  def __init__(__self__, *,
@@ -2535,15 +1837,6 @@ class VolumeTopologyRequestArgs:
2535
1837
  pulumi.set(self, "required", value)
2536
1838
 
2537
1839
 
2538
- if not MYPY:
2539
- class VolumeTopologyRequestRequiredArgsDict(TypedDict):
2540
- topologies: pulumi.Input[Sequence[pulumi.Input['VolumeTopologyRequestRequiredTopologyArgsDict']]]
2541
- """
2542
- Defines the location for the volume.
2543
- """
2544
- elif False:
2545
- VolumeTopologyRequestRequiredArgsDict: TypeAlias = Mapping[str, Any]
2546
-
2547
1840
  @pulumi.input_type
2548
1841
  class VolumeTopologyRequestRequiredArgs:
2549
1842
  def __init__(__self__, *,
@@ -2566,15 +1859,6 @@ class VolumeTopologyRequestRequiredArgs:
2566
1859
  pulumi.set(self, "topologies", value)
2567
1860
 
2568
1861
 
2569
- if not MYPY:
2570
- class VolumeTopologyRequestRequiredTopologyArgsDict(TypedDict):
2571
- segments: pulumi.Input[Mapping[str, pulumi.Input[str]]]
2572
- """
2573
- Define attributes for the topology request.
2574
- """
2575
- elif False:
2576
- VolumeTopologyRequestRequiredTopologyArgsDict: TypeAlias = Mapping[str, Any]
2577
-
2578
1862
  @pulumi.input_type
2579
1863
  class VolumeTopologyRequestRequiredTopologyArgs:
2580
1864
  def __init__(__self__, *,