pulumi-linode 5.2.0a1756506768__tar.gz → 5.3.0__tar.gz

{pulumi_linode-5.2.0a1756506768 → pulumi_linode-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_linode
-Version: 5.2.0a1756506768
+Version: 5.3.0
 Summary: A Pulumi package for creating and managing linode cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_linode-5.2.0a1756506768 → pulumi_linode-5.3.0}/pulumi_linode/__init__.py

@@ -57,6 +57,7 @@ from .get_lke_clusters import *
 from .get_lke_types import *
 from .get_lke_version import *
 from .get_lke_versions import *
+from .get_maintenance_policies import *
 from .get_nb_types import *
 from .get_network_transfer_prices import *
 from .get_networking_ip import *

{pulumi_linode-5.2.0a1756506768 → pulumi_linode-5.3.0}/pulumi_linode/_inputs.py

@@ -281,6 +281,10 @@ __all__ = [
     'GetLkeTypesTypeRegionPriceArgsDict',
     'GetLkeVersionsVersionArgs',
     'GetLkeVersionsVersionArgsDict',
+    'GetMaintenancePoliciesFilterArgs',
+    'GetMaintenancePoliciesFilterArgsDict',
+    'GetMaintenancePoliciesMaintenancePolicyArgs',
+    'GetMaintenancePoliciesMaintenancePolicyArgsDict',
     'GetNbTypesFilterArgs',
     'GetNbTypesFilterArgsDict',
     'GetNbTypesTypeArgs',
@@ -4040,12 +4044,16 @@ if not MYPY:
         """
         Defines the ACL configuration for an LKE cluster's control plane.
         """
-        high_availability: NotRequired[pulumi.Input[_builtins.bool]]
+        audit_logs_enabled: NotRequired[pulumi.Input[_builtins.bool]]
         """
-        Defines whether High Availability is enabled for the cluster Control Plane. This is an **irreversible** change.
+        Enables audit logs on the cluster's control plane.
 
         * `acl` - (Optional) Defines the ACL configuration for an LKE cluster's control plane.
         """
+        high_availability: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Defines whether High Availability is enabled for the cluster Control Plane. This is an **irreversible** change.
+        """
 elif False:
     LkeClusterControlPlaneArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -4053,15 +4061,19 @@ elif False:
 class LkeClusterControlPlaneArgs:
     def __init__(__self__, *,
                  acl: Optional[pulumi.Input['LkeClusterControlPlaneAclArgs']] = None,
+                 audit_logs_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                  high_availability: Optional[pulumi.Input[_builtins.bool]] = None):
         """
         :param pulumi.Input['LkeClusterControlPlaneAclArgs'] acl: Defines the ACL configuration for an LKE cluster's control plane.
-        :param pulumi.Input[_builtins.bool] high_availability: Defines whether High Availability is enabled for the cluster Control Plane. This is an **irreversible** change.
+        :param pulumi.Input[_builtins.bool] audit_logs_enabled: Enables audit logs on the cluster's control plane.
                
                * `acl` - (Optional) Defines the ACL configuration for an LKE cluster's control plane.
+        :param pulumi.Input[_builtins.bool] high_availability: Defines whether High Availability is enabled for the cluster Control Plane. This is an **irreversible** change.
         """
         if acl is not None:
             pulumi.set(__self__, "acl", acl)
+        if audit_logs_enabled is not None:
+            pulumi.set(__self__, "audit_logs_enabled", audit_logs_enabled)
         if high_availability is not None:
             pulumi.set(__self__, "high_availability", high_availability)
 
@@ -4077,13 +4089,25 @@ class LkeClusterControlPlaneArgs:
     def acl(self, value: Optional[pulumi.Input['LkeClusterControlPlaneAclArgs']]):
         pulumi.set(self, "acl", value)
 
+    @_builtins.property
+    @pulumi.getter(name="auditLogsEnabled")
+    def audit_logs_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Enables audit logs on the cluster's control plane.
+
+        * `acl` - (Optional) Defines the ACL configuration for an LKE cluster's control plane.
+        """
+        return pulumi.get(self, "audit_logs_enabled")
+
+    @audit_logs_enabled.setter
+    def audit_logs_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "audit_logs_enabled", value)
+
     @_builtins.property
     @pulumi.getter(name="highAvailability")
     def high_availability(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
         Defines whether High Availability is enabled for the cluster Control Plane. This is an **irreversible** change.
-
-        * `acl` - (Optional) Defines the ACL configuration for an LKE cluster's control plane.
         """
         return pulumi.get(self, "high_availability")
 
@@ -4228,6 +4252,10 @@ if not MYPY:
         """
         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.
         """
+        label: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A label for the Node Pool. If not provided, it defaults to empty string.
+        """
         labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
         """
         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.
@@ -4260,6 +4288,7 @@ class LkeClusterPoolArgs:
                  disk_encryption: Optional[pulumi.Input[_builtins.str]] = None,
                  id: Optional[pulumi.Input[_builtins.int]] = None,
                  k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
+                 label: Optional[pulumi.Input[_builtins.str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                  nodes: Optional[pulumi.Input[Sequence[pulumi.Input['LkeClusterPoolNodeArgs']]]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
@@ -4272,6 +4301,7 @@ class LkeClusterPoolArgs:
         :param pulumi.Input[_builtins.str] disk_encryption: The disk encryption policy for nodes in this pool.
         :param pulumi.Input[_builtins.int] id: The ID of the node.
         :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.
+        :param pulumi.Input[_builtins.str] label: A label for the Node Pool. If not provided, it defaults to empty string.
         :param pulumi.Input[Mapping[str, pulumi.Input[_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.
         :param pulumi.Input[Sequence[pulumi.Input['LkeClusterPoolNodeArgs']]] nodes: The nodes in the node pool.
         :param pulumi.Input[Sequence[pulumi.Input[_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.
@@ -4289,6 +4319,8 @@ class LkeClusterPoolArgs:
             pulumi.set(__self__, "id", id)
         if k8s_version is not None:
             pulumi.set(__self__, "k8s_version", k8s_version)
+        if label is not None:
+            pulumi.set(__self__, "label", label)
         if labels is not None:
             pulumi.set(__self__, "labels", labels)
         if nodes is not None:
@@ -4372,6 +4404,18 @@ class LkeClusterPoolArgs:
     def k8s_version(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "k8s_version", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def label(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A label for the Node Pool. If not provided, it defaults to empty string.
+        """
+        return pulumi.get(self, "label")
+
+    @label.setter
+    def label(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "label", value)
+
     @_builtins.property
     @pulumi.getter
     def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
@@ -11304,6 +11348,10 @@ class GetKernelsKernelArgs:
 
 if not MYPY:
     class GetLkeClusterControlPlaneArgsDict(TypedDict):
+        audit_logs_enabled: _builtins.bool
+        """
+        Enables audit logs on the cluster's control plane.
+        """
         high_availability: _builtins.bool
         """
         Whether High Availability is enabled for the cluster Control Plane.
@@ -11318,16 +11366,31 @@ elif False:
 @pulumi.input_type
 class GetLkeClusterControlPlaneArgs:
     def __init__(__self__, *,
+                 audit_logs_enabled: _builtins.bool,
                  high_availability: _builtins.bool,
                  acls: Optional[Sequence['GetLkeClusterControlPlaneAclArgs']] = None):
         """
+        :param _builtins.bool audit_logs_enabled: Enables audit logs on the cluster's control plane.
         :param _builtins.bool high_availability: Whether High Availability is enabled for the cluster Control Plane.
         :param Sequence['GetLkeClusterControlPlaneAclArgs'] acls: The ACL configuration for an LKE cluster's control plane.
         """
+        pulumi.set(__self__, "audit_logs_enabled", audit_logs_enabled)
         pulumi.set(__self__, "high_availability", high_availability)
         if acls is not None:
             pulumi.set(__self__, "acls", acls)
 
+    @_builtins.property
+    @pulumi.getter(name="auditLogsEnabled")
+    def audit_logs_enabled(self) -> _builtins.bool:
+        """
+        Enables audit logs on the cluster's control plane.
+        """
+        return pulumi.get(self, "audit_logs_enabled")
+
+    @audit_logs_enabled.setter
+    def audit_logs_enabled(self, value: _builtins.bool):
+        pulumi.set(self, "audit_logs_enabled", value)
+
     @_builtins.property
     @pulumi.getter(name="highAvailability")
     def high_availability(self) -> _builtins.bool:
@@ -11500,6 +11563,10 @@ if not MYPY:
         """
         This Node Pool’s custom disk layout.
         """
+        label: NotRequired[_builtins.str]
+        """
+        The label of the Node Pool.
+        """
         nodes: NotRequired[Sequence['GetLkeClusterPoolNodeArgsDict']]
         """
         The nodes in the Node Pool.
@@ -11521,6 +11588,7 @@ class GetLkeClusterPoolArgs:
                  update_strategy: _builtins.str,
                  autoscalers: Optional[Sequence['GetLkeClusterPoolAutoscalerArgs']] = None,
                  disks: Optional[Sequence['GetLkeClusterPoolDiskArgs']] = None,
+                 label: Optional[_builtins.str] = None,
                  nodes: Optional[Sequence['GetLkeClusterPoolNodeArgs']] = None):
         """
         :param _builtins.int count: The number of nodes in the Node Pool.
@@ -11534,6 +11602,7 @@ class GetLkeClusterPoolArgs:
         :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.
         :param Sequence['GetLkeClusterPoolAutoscalerArgs'] autoscalers: The configuration options for the autoscaler. This field only contains an autoscaler configuration if autoscaling is enabled on this cluster.
         :param Sequence['GetLkeClusterPoolDiskArgs'] disks: This Node Pool’s custom disk layout.
+        :param _builtins.str label: The label of the Node Pool.
         :param Sequence['GetLkeClusterPoolNodeArgs'] nodes: The nodes in the Node Pool.
         """
         pulumi.set(__self__, "count", count)
@@ -11549,6 +11618,8 @@ class GetLkeClusterPoolArgs:
             pulumi.set(__self__, "autoscalers", autoscalers)
         if disks is not None:
             pulumi.set(__self__, "disks", disks)
+        if label is not None:
+            pulumi.set(__self__, "label", label)
         if nodes is not None:
             pulumi.set(__self__, "nodes", nodes)
 
@@ -11684,6 +11755,18 @@ class GetLkeClusterPoolArgs:
     def disks(self, value: Optional[Sequence['GetLkeClusterPoolDiskArgs']]):
         pulumi.set(self, "disks", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def label(self) -> Optional[_builtins.str]:
+        """
+        The label of the Node Pool.
+        """
+        return pulumi.get(self, "label")
+
+    @label.setter
+    def label(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "label", value)
+
     @_builtins.property
     @pulumi.getter
     def nodes(self) -> Optional[Sequence['GetLkeClusterPoolNodeArgs']]:
@@ -12050,10 +12133,18 @@ if not MYPY:
         """
         This Kubernetes cluster's location.
         """
+        stack_type: _builtins.str
+        """
+        The networking stack type of the Kubernetes cluster.
+        """
         status: _builtins.str
         """
         The status of the cluster.
         """
+        subnet_id: _builtins.int
+        """
+        The ID of the VPC subnet to use for the Kubernetes cluster. This subnet must be dual stack (IPv4 and IPv6 should both be enabled).
+        """
         tags: Sequence[_builtins.str]
         """
         An array of tags applied to this object. Tags are case-insensitive and are for organizational purposes only.
@@ -12066,6 +12157,10 @@ if not MYPY:
         """
         When this Kubernetes cluster was updated.
         """
+        vpc_id: _builtins.int
+        """
+        The ID of the VPC to use for the Kubernetes cluster.
+        """
         control_plane: NotRequired['GetLkeClustersLkeClusterControlPlaneArgsDict']
         """
         Defines settings for the Kubernetes Control Plane.
@@ -12082,10 +12177,13 @@ class GetLkeClustersLkeClusterArgs:
                  k8s_version: _builtins.str,
                  label: _builtins.str,
                  region: _builtins.str,
+                 stack_type: _builtins.str,
                  status: _builtins.str,
+                 subnet_id: _builtins.int,
                  tags: Sequence[_builtins.str],
                  tier: _builtins.str,
                  updated: _builtins.str,
+                 vpc_id: _builtins.int,
                  control_plane: Optional['GetLkeClustersLkeClusterControlPlaneArgs'] = None):
         """
         :param _builtins.bool apl_enabled: Enables the App Platform Layer for this cluster. Note: v4beta only and may not currently be available to all users.
@@ -12094,10 +12192,13 @@ class GetLkeClustersLkeClusterArgs:
         :param _builtins.str k8s_version: The Kubernetes version for this Kubernetes cluster in the format of `major.minor` (e.g. `1.17`).
         :param _builtins.str label: The unique label for the cluster.
         :param _builtins.str region: This Kubernetes cluster's location.
+        :param _builtins.str stack_type: The networking stack type of the Kubernetes cluster.
         :param _builtins.str status: The status of the cluster.
+        :param _builtins.int subnet_id: The ID of the VPC subnet to use for the Kubernetes cluster. This subnet must be dual stack (IPv4 and IPv6 should both be enabled).
         :param Sequence[_builtins.str] tags: An array of tags applied to this object. Tags are case-insensitive and are for organizational purposes only.
         :param _builtins.str tier: The desired Kubernetes tier. (**Note: v4beta only and may not currently be available to all users.**)
         :param _builtins.str updated: When this Kubernetes cluster was updated.
+        :param _builtins.int vpc_id: The ID of the VPC to use for the Kubernetes cluster.
         :param 'GetLkeClustersLkeClusterControlPlaneArgs' control_plane: Defines settings for the Kubernetes Control Plane.
         """
         pulumi.set(__self__, "apl_enabled", apl_enabled)
@@ -12106,10 +12207,13 @@ class GetLkeClustersLkeClusterArgs:
         pulumi.set(__self__, "k8s_version", k8s_version)
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "region", region)
+        pulumi.set(__self__, "stack_type", stack_type)
         pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "subnet_id", subnet_id)
         pulumi.set(__self__, "tags", tags)
         pulumi.set(__self__, "tier", tier)
         pulumi.set(__self__, "updated", updated)
+        pulumi.set(__self__, "vpc_id", vpc_id)
         if control_plane is not None:
             pulumi.set(__self__, "control_plane", control_plane)
 
@@ -12185,6 +12289,18 @@ class GetLkeClustersLkeClusterArgs:
     def region(self, value: _builtins.str):
         pulumi.set(self, "region", value)
 
+    @_builtins.property
+    @pulumi.getter(name="stackType")
+    def stack_type(self) -> _builtins.str:
+        """
+        The networking stack type of the Kubernetes cluster.
+        """
+        return pulumi.get(self, "stack_type")
+
+    @stack_type.setter
+    def stack_type(self, value: _builtins.str):
+        pulumi.set(self, "stack_type", value)
+
     @_builtins.property
     @pulumi.getter
     def status(self) -> _builtins.str:
@@ -12197,6 +12313,18 @@ class GetLkeClustersLkeClusterArgs:
     def status(self, value: _builtins.str):
         pulumi.set(self, "status", value)
 
+    @_builtins.property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> _builtins.int:
+        """
+        The ID of the VPC subnet to use for the Kubernetes cluster. This subnet must be dual stack (IPv4 and IPv6 should both be enabled).
+        """
+        return pulumi.get(self, "subnet_id")
+
+    @subnet_id.setter
+    def subnet_id(self, value: _builtins.int):
+        pulumi.set(self, "subnet_id", value)
+
     @_builtins.property
     @pulumi.getter
     def tags(self) -> Sequence[_builtins.str]:
@@ -12233,6 +12361,18 @@ class GetLkeClustersLkeClusterArgs:
     def updated(self, value: _builtins.str):
         pulumi.set(self, "updated", value)
 
+    @_builtins.property
+    @pulumi.getter(name="vpcId")
+    def vpc_id(self) -> _builtins.int:
+        """
+        The ID of the VPC to use for the Kubernetes cluster.
+        """
+        return pulumi.get(self, "vpc_id")
+
+    @vpc_id.setter
+    def vpc_id(self, value: _builtins.int):
+        pulumi.set(self, "vpc_id", value)
+
     @_builtins.property
     @pulumi.getter(name="controlPlane")
     def control_plane(self) -> Optional['GetLkeClustersLkeClusterControlPlaneArgs']:
@@ -12248,6 +12388,10 @@ class GetLkeClustersLkeClusterArgs:
 
 if not MYPY:
     class GetLkeClustersLkeClusterControlPlaneArgsDict(TypedDict):
+        audit_logs_enabled: _builtins.bool
+        """
+        Enables audit logs on the cluster's control plane.
+        """
         high_availability: _builtins.bool
         """
         Whether High Availability is enabled for the cluster Control Plane.
@@ -12258,12 +12402,27 @@ elif False:
 @pulumi.input_type
 class GetLkeClustersLkeClusterControlPlaneArgs:
     def __init__(__self__, *,
+                 audit_logs_enabled: _builtins.bool,
                  high_availability: _builtins.bool):
         """
+        :param _builtins.bool audit_logs_enabled: Enables audit logs on the cluster's control plane.
         :param _builtins.bool high_availability: Whether High Availability is enabled for the cluster Control Plane.
         """
+        pulumi.set(__self__, "audit_logs_enabled", audit_logs_enabled)
         pulumi.set(__self__, "high_availability", high_availability)
 
+    @_builtins.property
+    @pulumi.getter(name="auditLogsEnabled")
+    def audit_logs_enabled(self) -> _builtins.bool:
+        """
+        Enables audit logs on the cluster's control plane.
+        """
+        return pulumi.get(self, "audit_logs_enabled")
+
+    @audit_logs_enabled.setter
+    def audit_logs_enabled(self, value: _builtins.bool):
+        pulumi.set(self, "audit_logs_enabled", value)
+
     @_builtins.property
     @pulumi.getter(name="highAvailability")
     def high_availability(self) -> _builtins.bool:
@@ -12609,6 +12768,202 @@ class GetLkeVersionsVersionArgs:
         pulumi.set(self, "tier", value)
 
 
+if not MYPY:
+    class GetMaintenancePoliciesFilterArgsDict(TypedDict):
+        name: _builtins.str
+        """
+        The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
+        """
+        values: Sequence[_builtins.str]
+        """
+        A list of values for the filter to allow. These values should all be in string form.
+        """
+        match_by: NotRequired[_builtins.str]
+        """
+        The method to match the field by. (`exact`, `regex`, `substring`; default `exact`)
+        """
+elif False:
+    GetMaintenancePoliciesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetMaintenancePoliciesFilterArgs:
+    def __init__(__self__, *,
+                 name: _builtins.str,
+                 values: Sequence[_builtins.str],
+                 match_by: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str name: The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
+        :param Sequence[_builtins.str] values: A list of values for the filter to allow. These values should all be in string form.
+        :param _builtins.str match_by: The method to match the field by. (`exact`, `regex`, `substring`; default `exact`)
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "values", values)
+        if match_by is not None:
+            pulumi.set(__self__, "match_by", match_by)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        """
+        The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: _builtins.str):
+        pulumi.set(self, "name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def values(self) -> Sequence[_builtins.str]:
+        """
+        A list of values for the filter to allow. These values should all be in string form.
+        """
+        return pulumi.get(self, "values")
+
+    @values.setter
+    def values(self, value: Sequence[_builtins.str]):
+        pulumi.set(self, "values", value)
+
+    @_builtins.property
+    @pulumi.getter(name="matchBy")
+    def match_by(self) -> Optional[_builtins.str]:
+        """
+        The method to match the field by. (`exact`, `regex`, `substring`; default `exact`)
+        """
+        return pulumi.get(self, "match_by")
+
+    @match_by.setter
+    def match_by(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "match_by", value)
+
+
+if not MYPY:
+    class GetMaintenancePoliciesMaintenancePolicyArgsDict(TypedDict):
+        description: _builtins.str
+        """
+        Description of this policy
+        """
+        is_default: _builtins.bool
+        """
+        Whether this is the default policy for the account.
+        """
+        label: _builtins.str
+        """
+        The label for this policy.
+        """
+        notification_period_sec: _builtins.int
+        """
+        The notification lead time in seconds.
+        """
+        slug: _builtins.str
+        """
+        Unique identifier for this policy
+        """
+        type: _builtins.str
+        """
+        The type of action taken during maintenance.
+        """
+elif False:
+    GetMaintenancePoliciesMaintenancePolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetMaintenancePoliciesMaintenancePolicyArgs:
+    def __init__(__self__, *,
+                 description: _builtins.str,
+                 is_default: _builtins.bool,
+                 label: _builtins.str,
+                 notification_period_sec: _builtins.int,
+                 slug: _builtins.str,
+                 type: _builtins.str):
+        """
+        :param _builtins.str description: Description of this policy
+        :param _builtins.bool is_default: Whether this is the default policy for the account.
+        :param _builtins.str label: The label for this policy.
+        :param _builtins.int notification_period_sec: The notification lead time in seconds.
+        :param _builtins.str slug: Unique identifier for this policy
+        :param _builtins.str type: The type of action taken during maintenance.
+        """
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "is_default", is_default)
+        pulumi.set(__self__, "label", label)
+        pulumi.set(__self__, "notification_period_sec", notification_period_sec)
+        pulumi.set(__self__, "slug", slug)
+        pulumi.set(__self__, "type", type)
+
+    @_builtins.property
+    @pulumi.getter
+    def description(self) -> _builtins.str:
+        """
+        Description of this policy
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: _builtins.str):
+        pulumi.set(self, "description", value)
+
+    @_builtins.property
+    @pulumi.getter(name="isDefault")
+    def is_default(self) -> _builtins.bool:
+        """
+        Whether this is the default policy for the account.
+        """
+        return pulumi.get(self, "is_default")
+
+    @is_default.setter
+    def is_default(self, value: _builtins.bool):
+        pulumi.set(self, "is_default", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def label(self) -> _builtins.str:
+        """
+        The label for this policy.
+        """
+        return pulumi.get(self, "label")
+
+    @label.setter
+    def label(self, value: _builtins.str):
+        pulumi.set(self, "label", value)
+
+    @_builtins.property
+    @pulumi.getter(name="notificationPeriodSec")
+    def notification_period_sec(self) -> _builtins.int:
+        """
+        The notification lead time in seconds.
+        """
+        return pulumi.get(self, "notification_period_sec")
+
+    @notification_period_sec.setter
+    def notification_period_sec(self, value: _builtins.int):
+        pulumi.set(self, "notification_period_sec", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def slug(self) -> _builtins.str:
+        """
+        Unique identifier for this policy
+        """
+        return pulumi.get(self, "slug")
+
+    @slug.setter
+    def slug(self, value: _builtins.str):
+        pulumi.set(self, "slug", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        The type of action taken during maintenance.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: _builtins.str):
+        pulumi.set(self, "type", value)
+
+
 if not MYPY:
     class GetNbTypesFilterArgsDict(TypedDict):
         name: _builtins.str