pulumi-linode 5.1.1__py3-none-any.whl → 5.2.0__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.

Potentially problematic release.

This version of pulumi-linode might be problematic. Click here for more details.

Files changed (20) hide show
  1. pulumi_linode/__init__.py +1 -0
  2. pulumi_linode/_inputs.py +240 -0
  3. pulumi_linode/account_settings.py +47 -0
  4. pulumi_linode/config/__init__.pyi +1 -2
  5. pulumi_linode/config/vars.py +1 -2
  6. pulumi_linode/get_account_settings.py +15 -1
  7. pulumi_linode/get_lke_cluster.py +1 -1
  8. pulumi_linode/get_maintenance_policies.py +129 -0
  9. pulumi_linode/instance.py +96 -112
  10. pulumi_linode/lke_node_pool.py +54 -14
  11. pulumi_linode/node_balancer_config.py +11 -22
  12. pulumi_linode/object_storage_bucket.py +4 -8
  13. pulumi_linode/outputs.py +151 -0
  14. pulumi_linode/provider.py +3 -6
  15. pulumi_linode/pulumi-plugin.json +1 -1
  16. pulumi_linode/reserved_ip_assignment.py +7 -14
  17. {pulumi_linode-5.1.1.dist-info → pulumi_linode-5.2.0.dist-info}/METADATA +1 -1
  18. {pulumi_linode-5.1.1.dist-info → pulumi_linode-5.2.0.dist-info}/RECORD +20 -19
  19. {pulumi_linode-5.1.1.dist-info → pulumi_linode-5.2.0.dist-info}/WHEEL +0 -0
  20. {pulumi_linode-5.1.1.dist-info → pulumi_linode-5.2.0.dist-info}/top_level.txt +0 -0
pulumi_linode/lke_node_pool.py CHANGED
@@ -25,6 +25,7 @@ class LkeNodePoolArgs:
25
25
  type: pulumi.Input[_builtins.str],
26
26
  autoscaler: Optional[pulumi.Input['LkeNodePoolAutoscalerArgs']] = None,
27
27
  k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
28
+ label: Optional[pulumi.Input[_builtins.str]] = None,
28
29
  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
29
30
  node_count: Optional[pulumi.Input[_builtins.int]] = None,
30
31
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
@@ -35,11 +36,11 @@ class LkeNodePoolArgs:
35
36
  :param pulumi.Input[_builtins.int] cluster_id: ID of the LKE Cluster where to create the current Node Pool.
36
37
  :param pulumi.Input[_builtins.str] type: A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
37
38
  :param pulumi.Input[_builtins.str] k8s_version: The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
39
+ :param pulumi.Input[_builtins.str] label: A label for the Node Pool. If not provided, it defaults to empty string.
38
40
  :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
39
41
  :param pulumi.Input[_builtins.int] node_count: The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
40
42
  :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
41
- :param pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
42
- allowing them to repel certain pods.
43
+ :param pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
43
44
  :param pulumi.Input[_builtins.str] update_strategy: The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
44
45
 
45
46
  * `autoscaler` - (Optional) If defined, an autoscaler will be enabled with the given configuration.
@@ -52,6 +53,8 @@ class LkeNodePoolArgs:
52
53
  pulumi.set(__self__, "autoscaler", autoscaler)
53
54
  if k8s_version is not None:
54
55
  pulumi.set(__self__, "k8s_version", k8s_version)
56
+ if label is not None:
57
+ pulumi.set(__self__, "label", label)
55
58
  if labels is not None:
56
59
  pulumi.set(__self__, "labels", labels)
57
60
  if node_count is not None:
@@ -108,6 +111,18 @@ class LkeNodePoolArgs:
108
111
  def k8s_version(self, value: Optional[pulumi.Input[_builtins.str]]):
109
112
  pulumi.set(self, "k8s_version", value)
110
113
 
114
+ @_builtins.property
115
+ @pulumi.getter
116
+ def label(self) -> Optional[pulumi.Input[_builtins.str]]:
117
+ """
118
+ A label for the Node Pool. If not provided, it defaults to empty string.
119
+ """
120
+ return pulumi.get(self, "label")
121
+
122
+ @label.setter
123
+ def label(self, value: Optional[pulumi.Input[_builtins.str]]):
124
+ pulumi.set(self, "label", value)
125
+
111
126
  @_builtins.property
112
127
  @pulumi.getter
113
128
  def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
@@ -148,8 +163,7 @@ class LkeNodePoolArgs:
148
163
  @pulumi.getter
149
164
  def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]]]:
150
165
  """
151
- Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
152
- allowing them to repel certain pods.
166
+ Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
153
167
  """
154
168
  return pulumi.get(self, "taints")
155
169
 
@@ -181,6 +195,7 @@ class _LkeNodePoolState:
181
195
  cluster_id: Optional[pulumi.Input[_builtins.int]] = None,
182
196
  disk_encryption: Optional[pulumi.Input[_builtins.str]] = None,
183
197
  k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
198
+ label: Optional[pulumi.Input[_builtins.str]] = None,
184
199
  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
185
200
  node_count: Optional[pulumi.Input[_builtins.int]] = None,
186
201
  nodes: Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolNodeArgs']]]] = None,
@@ -193,12 +208,12 @@ class _LkeNodePoolState:
193
208
  :param pulumi.Input[_builtins.int] cluster_id: ID of the LKE Cluster where to create the current Node Pool.
194
209
  :param pulumi.Input[_builtins.str] disk_encryption: The disk encryption policy for nodes in this pool.
195
210
  :param pulumi.Input[_builtins.str] k8s_version: The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
211
+ :param pulumi.Input[_builtins.str] label: A label for the Node Pool. If not provided, it defaults to empty string.
196
212
  :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
197
213
  :param pulumi.Input[_builtins.int] node_count: The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
198
214
  :param pulumi.Input[Sequence[pulumi.Input['LkeNodePoolNodeArgs']]] nodes: A list of nodes in the node pool.
199
215
  :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
200
- :param pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
201
- allowing them to repel certain pods.
216
+ :param pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
202
217
  :param pulumi.Input[_builtins.str] type: A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
203
218
  :param pulumi.Input[_builtins.str] update_strategy: The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
204
219
 
@@ -214,6 +229,8 @@ class _LkeNodePoolState:
214
229
  pulumi.set(__self__, "disk_encryption", disk_encryption)
215
230
  if k8s_version is not None:
216
231
  pulumi.set(__self__, "k8s_version", k8s_version)
232
+ if label is not None:
233
+ pulumi.set(__self__, "label", label)
217
234
  if labels is not None:
218
235
  pulumi.set(__self__, "labels", labels)
219
236
  if node_count is not None:
@@ -274,6 +291,18 @@ class _LkeNodePoolState:
274
291
  def k8s_version(self, value: Optional[pulumi.Input[_builtins.str]]):
275
292
  pulumi.set(self, "k8s_version", value)
276
293
 
294
+ @_builtins.property
295
+ @pulumi.getter
296
+ def label(self) -> Optional[pulumi.Input[_builtins.str]]:
297
+ """
298
+ A label for the Node Pool. If not provided, it defaults to empty string.
299
+ """
300
+ return pulumi.get(self, "label")
301
+
302
+ @label.setter
303
+ def label(self, value: Optional[pulumi.Input[_builtins.str]]):
304
+ pulumi.set(self, "label", value)
305
+
277
306
  @_builtins.property
278
307
  @pulumi.getter
279
308
  def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
@@ -326,8 +355,7 @@ class _LkeNodePoolState:
326
355
  @pulumi.getter
327
356
  def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]]]:
328
357
  """
329
- Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
330
- allowing them to repel certain pods.
358
+ Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
331
359
  """
332
360
  return pulumi.get(self, "taints")
333
361
 
@@ -373,6 +401,7 @@ class LkeNodePool(pulumi.CustomResource):
373
401
  autoscaler: Optional[pulumi.Input[Union['LkeNodePoolAutoscalerArgs', 'LkeNodePoolAutoscalerArgsDict']]] = None,
374
402
  cluster_id: Optional[pulumi.Input[_builtins.int]] = None,
375
403
  k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
404
+ label: Optional[pulumi.Input[_builtins.str]] = None,
376
405
  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
377
406
  node_count: Optional[pulumi.Input[_builtins.int]] = None,
378
407
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
@@ -393,11 +422,11 @@ class LkeNodePool(pulumi.CustomResource):
393
422
  :param pulumi.ResourceOptions opts: Options for the resource.
394
423
  :param pulumi.Input[_builtins.int] cluster_id: ID of the LKE Cluster where to create the current Node Pool.
395
424
  :param pulumi.Input[_builtins.str] k8s_version: The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
425
+ :param pulumi.Input[_builtins.str] label: A label for the Node Pool. If not provided, it defaults to empty string.
396
426
  :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
397
427
  :param pulumi.Input[_builtins.int] node_count: The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
398
428
  :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
399
- :param pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
400
- allowing them to repel certain pods.
429
+ :param pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
401
430
  :param pulumi.Input[_builtins.str] type: A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
402
431
  :param pulumi.Input[_builtins.str] update_strategy: The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
403
432
 
@@ -438,6 +467,7 @@ class LkeNodePool(pulumi.CustomResource):
438
467
  autoscaler: Optional[pulumi.Input[Union['LkeNodePoolAutoscalerArgs', 'LkeNodePoolAutoscalerArgsDict']]] = None,
439
468
  cluster_id: Optional[pulumi.Input[_builtins.int]] = None,
440
469
  k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
470
+ label: Optional[pulumi.Input[_builtins.str]] = None,
441
471
  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
442
472
  node_count: Optional[pulumi.Input[_builtins.int]] = None,
443
473
  tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
@@ -458,6 +488,7 @@ class LkeNodePool(pulumi.CustomResource):
458
488
  raise TypeError("Missing required property 'cluster_id'")
459
489
  __props__.__dict__["cluster_id"] = cluster_id
460
490
  __props__.__dict__["k8s_version"] = k8s_version
491
+ __props__.__dict__["label"] = label
461
492
  __props__.__dict__["labels"] = labels
462
493
  __props__.__dict__["node_count"] = node_count
463
494
  __props__.__dict__["tags"] = tags
@@ -482,6 +513,7 @@ class LkeNodePool(pulumi.CustomResource):
482
513
  cluster_id: Optional[pulumi.Input[_builtins.int]] = None,
483
514
  disk_encryption: Optional[pulumi.Input[_builtins.str]] = None,
484
515
  k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
516
+ label: Optional[pulumi.Input[_builtins.str]] = None,
485
517
  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
486
518
  node_count: Optional[pulumi.Input[_builtins.int]] = None,
487
519
  nodes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolNodeArgs', 'LkeNodePoolNodeArgsDict']]]]] = None,
@@ -499,12 +531,12 @@ class LkeNodePool(pulumi.CustomResource):
499
531
  :param pulumi.Input[_builtins.int] cluster_id: ID of the LKE Cluster where to create the current Node Pool.
500
532
  :param pulumi.Input[_builtins.str] disk_encryption: The disk encryption policy for nodes in this pool.
501
533
  :param pulumi.Input[_builtins.str] k8s_version: The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
534
+ :param pulumi.Input[_builtins.str] label: A label for the Node Pool. If not provided, it defaults to empty string.
502
535
  :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
503
536
  :param pulumi.Input[_builtins.int] node_count: The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
504
537
  :param pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolNodeArgs', 'LkeNodePoolNodeArgsDict']]]] nodes: A list of nodes in the node pool.
505
538
  :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
506
- :param pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
507
- allowing them to repel certain pods.
539
+ :param pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
508
540
  :param pulumi.Input[_builtins.str] type: A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
509
541
  :param pulumi.Input[_builtins.str] update_strategy: The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
510
542
 
@@ -520,6 +552,7 @@ class LkeNodePool(pulumi.CustomResource):
520
552
  __props__.__dict__["cluster_id"] = cluster_id
521
553
  __props__.__dict__["disk_encryption"] = disk_encryption
522
554
  __props__.__dict__["k8s_version"] = k8s_version
555
+ __props__.__dict__["label"] = label
523
556
  __props__.__dict__["labels"] = labels
524
557
  __props__.__dict__["node_count"] = node_count
525
558
  __props__.__dict__["nodes"] = nodes
@@ -558,6 +591,14 @@ class LkeNodePool(pulumi.CustomResource):
558
591
  """
559
592
  return pulumi.get(self, "k8s_version")
560
593
 
594
+ @_builtins.property
595
+ @pulumi.getter
596
+ def label(self) -> pulumi.Output[_builtins.str]:
597
+ """
598
+ A label for the Node Pool. If not provided, it defaults to empty string.
599
+ """
600
+ return pulumi.get(self, "label")
601
+
561
602
  @_builtins.property
562
603
  @pulumi.getter
563
604
  def labels(self) -> pulumi.Output[Mapping[str, _builtins.str]]:
@@ -594,8 +635,7 @@ class LkeNodePool(pulumi.CustomResource):
594
635
  @pulumi.getter
595
636
  def taints(self) -> pulumi.Output[Optional[Sequence['outputs.LkeNodePoolTaint']]]:
596
637
  """
597
- Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
598
- allowing them to repel certain pods.
638
+ Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically allowing them to repel certain pods.
599
639
  """
600
640
  return pulumi.get(self, "taints")
601
641
 
pulumi_linode/node_balancer_config.py CHANGED
@@ -46,8 +46,7 @@ class NodeBalancerConfigArgs:
46
46
  :param pulumi.Input[_builtins.str] algorithm: What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
47
47
  :param pulumi.Input[_builtins.str] check: The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
48
48
  :param pulumi.Input[_builtins.int] check_attempts: How many times to attempt a check before considering a backend to be down. (1-30)
49
- :param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in
50
- the response body of a check request, the backend is considered to be down
49
+ :param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
51
50
  :param pulumi.Input[_builtins.int] check_interval: How often, in seconds, to check that backends are up and serving requests.
52
51
  :param pulumi.Input[_builtins.bool] check_passive: If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
53
52
  :param pulumi.Input[_builtins.str] check_path: The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
@@ -151,8 +150,7 @@ class NodeBalancerConfigArgs:
151
150
  @pulumi.getter(name="checkBody")
152
151
  def check_body(self) -> Optional[pulumi.Input[_builtins.str]]:
153
152
  """
154
- This value must be present in the response body of the check in order for it to pass. If this value is not present in
155
- the response body of a check request, the backend is considered to be down
153
+ This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
156
154
  """
157
155
  return pulumi.get(self, "check_body")
158
156
 
@@ -336,15 +334,13 @@ class _NodeBalancerConfigState:
336
334
  :param pulumi.Input[_builtins.str] algorithm: What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
337
335
  :param pulumi.Input[_builtins.str] check: The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
338
336
  :param pulumi.Input[_builtins.int] check_attempts: How many times to attempt a check before considering a backend to be down. (1-30)
339
- :param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in
340
- the response body of a check request, the backend is considered to be down
337
+ :param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
341
338
  :param pulumi.Input[_builtins.int] check_interval: How often, in seconds, to check that backends are up and serving requests.
342
339
  :param pulumi.Input[_builtins.bool] check_passive: If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
343
340
  :param pulumi.Input[_builtins.str] check_path: The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
344
341
  :param pulumi.Input[_builtins.int] check_timeout: How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
345
342
  :param pulumi.Input[_builtins.str] cipher_suite: What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
346
- :param pulumi.Input[Sequence[pulumi.Input['NodeBalancerConfigNodeStatusArgs']]] node_statuses: A structure containing information about the health of the backends for this port. This information is updated
347
- periodically as checks are performed against backends.
343
+ :param pulumi.Input[Sequence[pulumi.Input['NodeBalancerConfigNodeStatusArgs']]] node_statuses: A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
348
344
  :param pulumi.Input[_builtins.int] nodebalancer_id: The ID of the NodeBalancer to access.
349
345
 
350
346
  - - -
@@ -444,8 +440,7 @@ class _NodeBalancerConfigState:
444
440
  @pulumi.getter(name="checkBody")
445
441
  def check_body(self) -> Optional[pulumi.Input[_builtins.str]]:
446
442
  """
447
- This value must be present in the response body of the check in order for it to pass. If this value is not present in
448
- the response body of a check request, the backend is considered to be down
443
+ This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
449
444
  """
450
445
  return pulumi.get(self, "check_body")
451
446
 
@@ -517,8 +512,7 @@ class _NodeBalancerConfigState:
517
512
  @pulumi.getter(name="nodeStatuses")
518
513
  def node_statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodeBalancerConfigNodeStatusArgs']]]]:
519
514
  """
520
- A structure containing information about the health of the backends for this port. This information is updated
521
- periodically as checks are performed against backends.
515
+ A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
522
516
  """
523
517
  return pulumi.get(self, "node_statuses")
524
518
 
@@ -729,8 +723,7 @@ class NodeBalancerConfig(pulumi.CustomResource):
729
723
  :param pulumi.Input[_builtins.str] algorithm: What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
730
724
  :param pulumi.Input[_builtins.str] check: The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
731
725
  :param pulumi.Input[_builtins.int] check_attempts: How many times to attempt a check before considering a backend to be down. (1-30)
732
- :param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in
733
- the response body of a check request, the backend is considered to be down
726
+ :param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
734
727
  :param pulumi.Input[_builtins.int] check_interval: How often, in seconds, to check that backends are up and serving requests.
735
728
  :param pulumi.Input[_builtins.bool] check_passive: If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
736
729
  :param pulumi.Input[_builtins.str] check_path: The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
@@ -899,15 +892,13 @@ class NodeBalancerConfig(pulumi.CustomResource):
899
892
  :param pulumi.Input[_builtins.str] algorithm: What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
900
893
  :param pulumi.Input[_builtins.str] check: The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
901
894
  :param pulumi.Input[_builtins.int] check_attempts: How many times to attempt a check before considering a backend to be down. (1-30)
902
- :param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in
903
- the response body of a check request, the backend is considered to be down
895
+ :param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
904
896
  :param pulumi.Input[_builtins.int] check_interval: How often, in seconds, to check that backends are up and serving requests.
905
897
  :param pulumi.Input[_builtins.bool] check_passive: If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
906
898
  :param pulumi.Input[_builtins.str] check_path: The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
907
899
  :param pulumi.Input[_builtins.int] check_timeout: How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
908
900
  :param pulumi.Input[_builtins.str] cipher_suite: What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
909
- :param pulumi.Input[Sequence[pulumi.Input[Union['NodeBalancerConfigNodeStatusArgs', 'NodeBalancerConfigNodeStatusArgsDict']]]] node_statuses: A structure containing information about the health of the backends for this port. This information is updated
910
- periodically as checks are performed against backends.
901
+ :param pulumi.Input[Sequence[pulumi.Input[Union['NodeBalancerConfigNodeStatusArgs', 'NodeBalancerConfigNodeStatusArgsDict']]]] node_statuses: A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
911
902
  :param pulumi.Input[_builtins.int] nodebalancer_id: The ID of the NodeBalancer to access.
912
903
 
913
904
  - - -
@@ -979,8 +970,7 @@ class NodeBalancerConfig(pulumi.CustomResource):
979
970
  @pulumi.getter(name="checkBody")
980
971
  def check_body(self) -> pulumi.Output[_builtins.str]:
981
972
  """
982
- This value must be present in the response body of the check in order for it to pass. If this value is not present in
983
- the response body of a check request, the backend is considered to be down
973
+ This value must be present in the response body of the check in order for it to pass. If this value is not present in the response body of a check request, the backend is considered to be down
984
974
  """
985
975
  return pulumi.get(self, "check_body")
986
976
 
@@ -1028,8 +1018,7 @@ class NodeBalancerConfig(pulumi.CustomResource):
1028
1018
  @pulumi.getter(name="nodeStatuses")
1029
1019
  def node_statuses(self) -> pulumi.Output[Sequence['outputs.NodeBalancerConfigNodeStatus']]:
1030
1020
  """
1031
- A structure containing information about the health of the backends for this port. This information is updated
1032
- periodically as checks are performed against backends.
1021
+ A structure containing information about the health of the backends for this port. This information is updated periodically as checks are performed against backends.
1033
1022
  """
1034
1023
  return pulumi.get(self, "node_statuses")
1035
1024
 
pulumi_linode/object_storage_bucket.py CHANGED
@@ -268,8 +268,7 @@ class _ObjectStorageBucketState:
268
268
  :param pulumi.Input[_builtins.bool] cors_enabled: If true, the bucket will have CORS enabled for all origins.
269
269
  :param pulumi.Input[_builtins.str] endpoint: The endpoint for the bucket used for s3 connections.
270
270
  :param pulumi.Input[_builtins.str] endpoint_type: The type of `s3_endpoint` available to the user in this region. See [Endpoint types](https://techdocs.akamai.com/cloud-computing/docs/object-storage#endpoint-type) for more information.
271
- :param pulumi.Input[_builtins.str] hostname: The hostname where this bucket can be accessed. This hostname can be accessed through a browser if the bucket is made
272
- public.
271
+ :param pulumi.Input[_builtins.str] hostname: The hostname where this bucket can be accessed. This hostname can be accessed through a browser if the bucket is made public.
273
272
  :param pulumi.Input[_builtins.str] label: The label of the Linode Object Storage Bucket.
274
273
  :param pulumi.Input[Sequence[pulumi.Input['ObjectStorageBucketLifecycleRuleArgs']]] lifecycle_rules: Lifecycle rules to be applied to the bucket.
275
274
  :param pulumi.Input[_builtins.str] region: The region of the Linode Object Storage Bucket. Exactly one of `region` and `cluster` is required for creating a bucket.
@@ -411,8 +410,7 @@ class _ObjectStorageBucketState:
411
410
  @pulumi.getter
412
411
  def hostname(self) -> Optional[pulumi.Input[_builtins.str]]:
413
412
  """
414
- The hostname where this bucket can be accessed. This hostname can be accessed through a browser if the bucket is made
415
- public.
413
+ The hostname where this bucket can be accessed. This hostname can be accessed through a browser if the bucket is made public.
416
414
  """
417
415
  return pulumi.get(self, "hostname")
418
416
 
@@ -741,8 +739,7 @@ class ObjectStorageBucket(pulumi.CustomResource):
741
739
  :param pulumi.Input[_builtins.bool] cors_enabled: If true, the bucket will have CORS enabled for all origins.
742
740
  :param pulumi.Input[_builtins.str] endpoint: The endpoint for the bucket used for s3 connections.
743
741
  :param pulumi.Input[_builtins.str] endpoint_type: The type of `s3_endpoint` available to the user in this region. See [Endpoint types](https://techdocs.akamai.com/cloud-computing/docs/object-storage#endpoint-type) for more information.
744
- :param pulumi.Input[_builtins.str] hostname: The hostname where this bucket can be accessed. This hostname can be accessed through a browser if the bucket is made
745
- public.
742
+ :param pulumi.Input[_builtins.str] hostname: The hostname where this bucket can be accessed. This hostname can be accessed through a browser if the bucket is made public.
746
743
  :param pulumi.Input[_builtins.str] label: The label of the Linode Object Storage Bucket.
747
744
  :param pulumi.Input[Sequence[pulumi.Input[Union['ObjectStorageBucketLifecycleRuleArgs', 'ObjectStorageBucketLifecycleRuleArgsDict']]]] lifecycle_rules: Lifecycle rules to be applied to the bucket.
748
745
  :param pulumi.Input[_builtins.str] region: The region of the Linode Object Storage Bucket. Exactly one of `region` and `cluster` is required for creating a bucket.
@@ -841,8 +838,7 @@ class ObjectStorageBucket(pulumi.CustomResource):
841
838
  @pulumi.getter
842
839
  def hostname(self) -> pulumi.Output[_builtins.str]:
843
840
  """
844
- The hostname where this bucket can be accessed. This hostname can be accessed through a browser if the bucket is made
845
- public.
841
+ The hostname where this bucket can be accessed. This hostname can be accessed through a browser if the bucket is made public.
846
842
  """
847
843
  return pulumi.get(self, "hostname")
848
844
 
pulumi_linode/outputs.py CHANGED
@@ -241,6 +241,8 @@ __all__ = [
241
241
  'GetLkeTypesTypePriceResult',
242
242
  'GetLkeTypesTypeRegionPriceResult',
243
243
  'GetLkeVersionsVersionResult',
244
+ 'GetMaintenancePoliciesFilterResult',
245
+ 'GetMaintenancePoliciesMaintenancePolicyResult',
244
246
  'GetNbTypesFilterResult',
245
247
  'GetNbTypesTypeResult',
246
248
  'GetNbTypesTypePriceResult',
@@ -3147,6 +3149,7 @@ class LkeClusterPool(dict):
3147
3149
  disk_encryption: Optional[_builtins.str] = None,
3148
3150
  id: Optional[_builtins.int] = None,
3149
3151
  k8s_version: Optional[_builtins.str] = None,
3152
+ label: Optional[_builtins.str] = None,
3150
3153
  labels: Optional[Mapping[str, _builtins.str]] = None,
3151
3154
  nodes: Optional[Sequence['outputs.LkeClusterPoolNode']] = None,
3152
3155
  tags: Optional[Sequence[_builtins.str]] = None,
@@ -3159,6 +3162,7 @@ class LkeClusterPool(dict):
3159
3162
  :param _builtins.str disk_encryption: The disk encryption policy for nodes in this pool.
3160
3163
  :param _builtins.int id: The ID of the node.
3161
3164
  :param _builtins.str k8s_version: The k8s version of the nodes in this Node Pool. For LKE enterprise only and may not currently available to all users even under v4beta.
3165
+ :param _builtins.str label: A label for the Node Pool. If not provided, it defaults to empty string.
3162
3166
  :param Mapping[str, _builtins.str] labels: A map of key/value pairs to apply to all nodes in the pool. Labels are used to identify and organize Kubernetes resources within your cluster.
3163
3167
  :param Sequence['LkeClusterPoolNodeArgs'] nodes: The nodes in the node pool.
3164
3168
  :param Sequence[_builtins.str] tags: A set of tags applied to this node pool. Tags can be used to flag node pools as externally managed. See Externally Managed Node Pools for more details.
@@ -3176,6 +3180,8 @@ class LkeClusterPool(dict):
3176
3180
  pulumi.set(__self__, "id", id)
3177
3181
  if k8s_version is not None:
3178
3182
  pulumi.set(__self__, "k8s_version", k8s_version)
3183
+ if label is not None:
3184
+ pulumi.set(__self__, "label", label)
3179
3185
  if labels is not None:
3180
3186
  pulumi.set(__self__, "labels", labels)
3181
3187
  if nodes is not None:
@@ -3235,6 +3241,14 @@ class LkeClusterPool(dict):
3235
3241
  """
3236
3242
  return pulumi.get(self, "k8s_version")
3237
3243
 
3244
+ @_builtins.property
3245
+ @pulumi.getter
3246
+ def label(self) -> Optional[_builtins.str]:
3247
+ """
3248
+ A label for the Node Pool. If not provided, it defaults to empty string.
3249
+ """
3250
+ return pulumi.get(self, "label")
3251
+
3238
3252
  @_builtins.property
3239
3253
  @pulumi.getter
3240
3254
  def labels(self) -> Optional[Mapping[str, _builtins.str]]:
@@ -11294,6 +11308,7 @@ class GetInstancesInstanceResult(dict):
11294
11308
  ipv6: _builtins.str,
11295
11309
  label: _builtins.str,
11296
11310
  lke_cluster_id: _builtins.int,
11311
+ maintenance_policy: _builtins.str,
11297
11312
  placement_groups: Sequence['outputs.GetInstancesInstancePlacementGroupResult'],
11298
11313
  private_ip_address: _builtins.str,
11299
11314
  region: _builtins.str,
@@ -11320,6 +11335,7 @@ class GetInstancesInstanceResult(dict):
11320
11335
  :param _builtins.str ipv6: This Linode's IPv6 SLAAC addresses. This address is specific to a Linode, and may not be shared. The prefix (`/128`) is included in this attribute.
11321
11336
  :param _builtins.str label: The label of the Placement Group. This field can only contain ASCII letters, digits and dashes.
11322
11337
  :param _builtins.int lke_cluster_id: If applicable, the ID of the LKE cluster this instance is a part of.
11338
+ :param _builtins.str maintenance_policy: The maintenance policy of this Linode instance. (**Note: v4beta only.**)
11323
11339
  :param _builtins.str private_ip_address: This Linode's Private IPv4 Address, if enabled. The regional private IP address range, 192.168.128.0/17, is shared by all Linode Instances in a region.
11324
11340
  :param _builtins.str region: This is the location where the Linode is deployed. Examples are `"us-east"`, `"us-west"`, `"ap-south"`, etc. See all regions [here](https://api.linode.com/v4/regions).
11325
11341
  :param _builtins.str status: The status of the instance, indicating the current readiness state. (`running`, `offline`, ...)
@@ -11345,6 +11361,7 @@ class GetInstancesInstanceResult(dict):
11345
11361
  pulumi.set(__self__, "ipv6", ipv6)
11346
11362
  pulumi.set(__self__, "label", label)
11347
11363
  pulumi.set(__self__, "lke_cluster_id", lke_cluster_id)
11364
+ pulumi.set(__self__, "maintenance_policy", maintenance_policy)
11348
11365
  pulumi.set(__self__, "placement_groups", placement_groups)
11349
11366
  pulumi.set(__self__, "private_ip_address", private_ip_address)
11350
11367
  pulumi.set(__self__, "region", region)
@@ -11488,6 +11505,14 @@ class GetInstancesInstanceResult(dict):
11488
11505
  """
11489
11506
  return pulumi.get(self, "lke_cluster_id")
11490
11507
 
11508
+ @_builtins.property
11509
+ @pulumi.getter(name="maintenancePolicy")
11510
+ def maintenance_policy(self) -> _builtins.str:
11511
+ """
11512
+ The maintenance policy of this Linode instance. (**Note: v4beta only.**)
11513
+ """
11514
+ return pulumi.get(self, "maintenance_policy")
11515
+
11491
11516
  @_builtins.property
11492
11517
  @pulumi.getter(name="placementGroups")
11493
11518
  def placement_groups(self) -> Sequence['outputs.GetInstancesInstancePlacementGroupResult']:
@@ -12971,6 +12996,7 @@ class GetLkeClusterPoolResult(dict):
12971
12996
  update_strategy: _builtins.str,
12972
12997
  autoscalers: Optional[Sequence['outputs.GetLkeClusterPoolAutoscalerResult']] = None,
12973
12998
  disks: Optional[Sequence['outputs.GetLkeClusterPoolDiskResult']] = None,
12999
+ label: Optional[_builtins.str] = None,
12974
13000
  nodes: Optional[Sequence['outputs.GetLkeClusterPoolNodeResult']] = None):
12975
13001
  """
12976
13002
  :param _builtins.int count: The number of nodes in the Node Pool.
@@ -12984,6 +13010,7 @@ class GetLkeClusterPoolResult(dict):
12984
13010
  :param _builtins.str update_strategy: The strategy for updating the Node Pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
12985
13011
  :param Sequence['GetLkeClusterPoolAutoscalerArgs'] autoscalers: The configuration options for the autoscaler. This field only contains an autoscaler configuration if autoscaling is enabled on this cluster.
12986
13012
  :param Sequence['GetLkeClusterPoolDiskArgs'] disks: This Node Pool’s custom disk layout.
13013
+ :param _builtins.str label: The label of the Node Pool.
12987
13014
  :param Sequence['GetLkeClusterPoolNodeArgs'] nodes: The nodes in the Node Pool.
12988
13015
  """
12989
13016
  pulumi.set(__self__, "count", count)
@@ -12999,6 +13026,8 @@ class GetLkeClusterPoolResult(dict):
12999
13026
  pulumi.set(__self__, "autoscalers", autoscalers)
13000
13027
  if disks is not None:
13001
13028
  pulumi.set(__self__, "disks", disks)
13029
+ if label is not None:
13030
+ pulumi.set(__self__, "label", label)
13002
13031
  if nodes is not None:
13003
13032
  pulumi.set(__self__, "nodes", nodes)
13004
13033
 
@@ -13090,6 +13119,14 @@ class GetLkeClusterPoolResult(dict):
13090
13119
  """
13091
13120
  return pulumi.get(self, "disks")
13092
13121
 
13122
+ @_builtins.property
13123
+ @pulumi.getter
13124
+ def label(self) -> Optional[_builtins.str]:
13125
+ """
13126
+ The label of the Node Pool.
13127
+ """
13128
+ return pulumi.get(self, "label")
13129
+
13093
13130
  @_builtins.property
13094
13131
  @pulumi.getter
13095
13132
  def nodes(self) -> Optional[Sequence['outputs.GetLkeClusterPoolNodeResult']]:
@@ -13629,6 +13666,120 @@ class GetLkeVersionsVersionResult(dict):
13629
13666
  return pulumi.get(self, "tier")
13630
13667
 
13631
13668
 
13669
+ @pulumi.output_type
13670
+ class GetMaintenancePoliciesFilterResult(dict):
13671
+ def __init__(__self__, *,
13672
+ name: _builtins.str,
13673
+ values: Sequence[_builtins.str],
13674
+ match_by: Optional[_builtins.str] = None):
13675
+ """
13676
+ :param _builtins.str name: The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
13677
+ :param Sequence[_builtins.str] values: A list of values for the filter to allow. These values should all be in string form.
13678
+ :param _builtins.str match_by: The method to match the field by. (`exact`, `regex`, `substring`; default `exact`)
13679
+ """
13680
+ pulumi.set(__self__, "name", name)
13681
+ pulumi.set(__self__, "values", values)
13682
+ if match_by is not None:
13683
+ pulumi.set(__self__, "match_by", match_by)
13684
+
13685
+ @_builtins.property
13686
+ @pulumi.getter
13687
+ def name(self) -> _builtins.str:
13688
+ """
13689
+ The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
13690
+ """
13691
+ return pulumi.get(self, "name")
13692
+
13693
+ @_builtins.property
13694
+ @pulumi.getter
13695
+ def values(self) -> Sequence[_builtins.str]:
13696
+ """
13697
+ A list of values for the filter to allow. These values should all be in string form.
13698
+ """
13699
+ return pulumi.get(self, "values")
13700
+
13701
+ @_builtins.property
13702
+ @pulumi.getter(name="matchBy")
13703
+ def match_by(self) -> Optional[_builtins.str]:
13704
+ """
13705
+ The method to match the field by. (`exact`, `regex`, `substring`; default `exact`)
13706
+ """
13707
+ return pulumi.get(self, "match_by")
13708
+
13709
+
13710
+ @pulumi.output_type
13711
+ class GetMaintenancePoliciesMaintenancePolicyResult(dict):
13712
+ def __init__(__self__, *,
13713
+ description: _builtins.str,
13714
+ is_default: _builtins.bool,
13715
+ label: _builtins.str,
13716
+ notification_period_sec: _builtins.int,
13717
+ slug: _builtins.str,
13718
+ type: _builtins.str):
13719
+ """
13720
+ :param _builtins.str description: Description of this policy
13721
+ :param _builtins.bool is_default: Whether this is the default policy for the account.
13722
+ :param _builtins.str label: The label for this policy.
13723
+ :param _builtins.int notification_period_sec: The notification lead time in seconds.
13724
+ :param _builtins.str slug: Unique identifier for this policy
13725
+ :param _builtins.str type: The type of action taken during maintenance.
13726
+ """
13727
+ pulumi.set(__self__, "description", description)
13728
+ pulumi.set(__self__, "is_default", is_default)
13729
+ pulumi.set(__self__, "label", label)
13730
+ pulumi.set(__self__, "notification_period_sec", notification_period_sec)
13731
+ pulumi.set(__self__, "slug", slug)
13732
+ pulumi.set(__self__, "type", type)
13733
+
13734
+ @_builtins.property
13735
+ @pulumi.getter
13736
+ def description(self) -> _builtins.str:
13737
+ """
13738
+ Description of this policy
13739
+ """
13740
+ return pulumi.get(self, "description")
13741
+
13742
+ @_builtins.property
13743
+ @pulumi.getter(name="isDefault")
13744
+ def is_default(self) -> _builtins.bool:
13745
+ """
13746
+ Whether this is the default policy for the account.
13747
+ """
13748
+ return pulumi.get(self, "is_default")
13749
+
13750
+ @_builtins.property
13751
+ @pulumi.getter
13752
+ def label(self) -> _builtins.str:
13753
+ """
13754
+ The label for this policy.
13755
+ """
13756
+ return pulumi.get(self, "label")
13757
+
13758
+ @_builtins.property
13759
+ @pulumi.getter(name="notificationPeriodSec")
13760
+ def notification_period_sec(self) -> _builtins.int:
13761
+ """
13762
+ The notification lead time in seconds.
13763
+ """
13764
+ return pulumi.get(self, "notification_period_sec")
13765
+
13766
+ @_builtins.property
13767
+ @pulumi.getter
13768
+ def slug(self) -> _builtins.str:
13769
+ """
13770
+ Unique identifier for this policy
13771
+ """
13772
+ return pulumi.get(self, "slug")
13773
+
13774
+ @_builtins.property
13775
+ @pulumi.getter
13776
+ def type(self) -> _builtins.str:
13777
+ """
13778
+ The type of action taken during maintenance.
13779
+ """
13780
+ return pulumi.get(self, "type")
13781
+
13782
+
13632
13783
  @pulumi.output_type
13633
13784
  class GetNbTypesFilterResult(dict):
13634
13785
  def __init__(__self__, *,