pulumi-oci 2.33.0a1745955172__py3-none-any.whl → 2.33.0a1746138884__py3-none-any.whl

pulumi_oci/containerengine/_inputs.py

@@ -4261,6 +4261,10 @@ if not MYPY:
         """
         (Updatable) Duration after which OKE will give up eviction of the pods on the node. PT0M will indicate you want to delete the node without cordon and drain. Default PT60M, Min PT0M, Max: PT60M. Format ISO 8601 e.g PT30M
         """
+        is_force_action_after_grace_duration: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        (Updatable) If the node action should be performed if not all the pods can be evicted in the grace period
+        """
         is_force_delete_after_grace_duration: NotRequired[pulumi.Input[builtins.bool]]
         """
         (Updatable) If the underlying compute instance should be deleted if you cannot evict all the pods in grace period
@@ -4272,13 +4276,17 @@ elif False:
 class NodePoolNodeEvictionNodePoolSettingsArgs:
     def __init__(__self__, *,
                  eviction_grace_duration: Optional[pulumi.Input[builtins.str]] = None,
+                 is_force_action_after_grace_duration: Optional[pulumi.Input[builtins.bool]] = None,
                  is_force_delete_after_grace_duration: Optional[pulumi.Input[builtins.bool]] = None):
         """
         :param pulumi.Input[builtins.str] eviction_grace_duration: (Updatable) Duration after which OKE will give up eviction of the pods on the node. PT0M will indicate you want to delete the node without cordon and drain. Default PT60M, Min PT0M, Max: PT60M. Format ISO 8601 e.g PT30M
+        :param pulumi.Input[builtins.bool] is_force_action_after_grace_duration: (Updatable) If the node action should be performed if not all the pods can be evicted in the grace period
         :param pulumi.Input[builtins.bool] is_force_delete_after_grace_duration: (Updatable) If the underlying compute instance should be deleted if you cannot evict all the pods in grace period
         """
         if eviction_grace_duration is not None:
             pulumi.set(__self__, "eviction_grace_duration", eviction_grace_duration)
+        if is_force_action_after_grace_duration is not None:
+            pulumi.set(__self__, "is_force_action_after_grace_duration", is_force_action_after_grace_duration)
         if is_force_delete_after_grace_duration is not None:
             pulumi.set(__self__, "is_force_delete_after_grace_duration", is_force_delete_after_grace_duration)
 
@@ -4294,6 +4302,18 @@ class NodePoolNodeEvictionNodePoolSettingsArgs:
     def eviction_grace_duration(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "eviction_grace_duration", value)
 
+    @property
+    @pulumi.getter(name="isForceActionAfterGraceDuration")
+    def is_force_action_after_grace_duration(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        (Updatable) If the node action should be performed if not all the pods can be evicted in the grace period
+        """
+        return pulumi.get(self, "is_force_action_after_grace_duration")
+
+    @is_force_action_after_grace_duration.setter
+    def is_force_action_after_grace_duration(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "is_force_action_after_grace_duration", value)
+
     @property
     @pulumi.getter(name="isForceDeleteAfterGraceDuration")
     def is_force_delete_after_grace_duration(self) -> Optional[pulumi.Input[builtins.bool]]:
@@ -4309,9 +4329,13 @@ class NodePoolNodeEvictionNodePoolSettingsArgs:
 
 if not MYPY:
     class NodePoolNodePoolCyclingDetailsArgsDict(TypedDict):
+        cycle_modes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
+        """
+        (Updatable) An ordered list of cycle modes that should be performed on the OKE nodes.
+        """
         is_node_cycling_enabled: NotRequired[pulumi.Input[builtins.bool]]
         """
-        (Updatable) If nodes in the nodepool will be cycled to have new changes.
+        (Updatable) If cycling operation should be performed on the nodes in the node pool.
         """
         maximum_surge: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -4327,14 +4351,18 @@ elif False:
 @pulumi.input_type
 class NodePoolNodePoolCyclingDetailsArgs:
     def __init__(__self__, *,
+                 cycle_modes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  is_node_cycling_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                  maximum_surge: Optional[pulumi.Input[builtins.str]] = None,
                  maximum_unavailable: Optional[pulumi.Input[builtins.str]] = None):
         """
-        :param pulumi.Input[builtins.bool] is_node_cycling_enabled: (Updatable) If nodes in the nodepool will be cycled to have new changes.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] cycle_modes: (Updatable) An ordered list of cycle modes that should be performed on the OKE nodes.
+        :param pulumi.Input[builtins.bool] is_node_cycling_enabled: (Updatable) If cycling operation should be performed on the nodes in the node pool.
         :param pulumi.Input[builtins.str] maximum_surge: (Updatable) Maximum additional new compute instances that would be temporarily created and added to nodepool during the cycling nodepool process. OKE supports both integer and percentage input. Defaults to 1, Ranges from 0 to Nodepool size or 0% to 100%
         :param pulumi.Input[builtins.str] maximum_unavailable: (Updatable) Maximum active nodes that would be terminated from nodepool during the cycling nodepool process. OKE supports both integer and percentage input. Defaults to 0, Ranges from 0 to Nodepool size or 0% to 100%
         """
+        if cycle_modes is not None:
+            pulumi.set(__self__, "cycle_modes", cycle_modes)
         if is_node_cycling_enabled is not None:
             pulumi.set(__self__, "is_node_cycling_enabled", is_node_cycling_enabled)
         if maximum_surge is not None:
@@ -4342,11 +4370,23 @@ class NodePoolNodePoolCyclingDetailsArgs:
         if maximum_unavailable is not None:
             pulumi.set(__self__, "maximum_unavailable", maximum_unavailable)
 
+    @property
+    @pulumi.getter(name="cycleModes")
+    def cycle_modes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
+        """
+        (Updatable) An ordered list of cycle modes that should be performed on the OKE nodes.
+        """
+        return pulumi.get(self, "cycle_modes")
+
+    @cycle_modes.setter
+    def cycle_modes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "cycle_modes", value)
+
     @property
     @pulumi.getter(name="isNodeCyclingEnabled")
     def is_node_cycling_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
         """
-        (Updatable) If nodes in the nodepool will be cycled to have new changes.
+        (Updatable) If cycling operation should be performed on the nodes in the node pool.
         """
         return pulumi.get(self, "is_node_cycling_enabled")
 

pulumi_oci/containerengine/get_cluster.py

@@ -28,7 +28,7 @@ class GetClusterResult:
     """
     A collection of values returned by getCluster.
     """
-    def __init__(__self__, available_kubernetes_upgrades=None, cluster_id=None, cluster_pod_network_options=None, compartment_id=None, defined_tags=None, endpoint_configs=None, endpoints=None, freeform_tags=None, id=None, image_policy_configs=None, kms_key_id=None, kubernetes_version=None, lifecycle_details=None, metadatas=None, name=None, open_id_connect_discovery_endpoint=None, options=None, state=None, type=None, vcn_id=None):
+    def __init__(__self__, available_kubernetes_upgrades=None, cluster_id=None, cluster_pod_network_options=None, compartment_id=None, defined_tags=None, endpoint_configs=None, endpoints=None, freeform_tags=None, id=None, image_policy_configs=None, kms_key_id=None, kubernetes_version=None, lifecycle_details=None, metadatas=None, name=None, open_id_connect_discovery_endpoint=None, options=None, should_include_oidc_config_file=None, state=None, type=None, vcn_id=None):
         if available_kubernetes_upgrades and not isinstance(available_kubernetes_upgrades, list):
             raise TypeError("Expected argument 'available_kubernetes_upgrades' to be a list")
         pulumi.set(__self__, "available_kubernetes_upgrades", available_kubernetes_upgrades)
@@ -80,6 +80,9 @@ class GetClusterResult:
         if options and not isinstance(options, list):
             raise TypeError("Expected argument 'options' to be a list")
         pulumi.set(__self__, "options", options)
+        if should_include_oidc_config_file and not isinstance(should_include_oidc_config_file, str):
+            raise TypeError("Expected argument 'should_include_oidc_config_file' to be a str")
+        pulumi.set(__self__, "should_include_oidc_config_file", should_include_oidc_config_file)
         if state and not isinstance(state, str):
             raise TypeError("Expected argument 'state' to be a str")
         pulumi.set(__self__, "state", state)
@@ -220,6 +223,11 @@ class GetClusterResult:
         """
         return pulumi.get(self, "options")
 
+    @property
+    @pulumi.getter(name="shouldIncludeOidcConfigFile")
+    def should_include_oidc_config_file(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "should_include_oidc_config_file")
+
     @property
     @pulumi.getter
     def state(self) -> builtins.str:
@@ -268,12 +276,14 @@ class AwaitableGetClusterResult(GetClusterResult):
             name=self.name,
             open_id_connect_discovery_endpoint=self.open_id_connect_discovery_endpoint,
             options=self.options,
+            should_include_oidc_config_file=self.should_include_oidc_config_file,
             state=self.state,
             type=self.type,
             vcn_id=self.vcn_id)
 
 
 def get_cluster(cluster_id: Optional[builtins.str] = None,
+                should_include_oidc_config_file: Optional[builtins.str] = None,
                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetClusterResult:
     """
     This data source provides details about a specific Cluster resource in Oracle Cloud Infrastructure Container Engine service.
@@ -286,14 +296,17 @@ def get_cluster(cluster_id: Optional[builtins.str] = None,
     import pulumi
     import pulumi_oci as oci
 
-    test_cluster = oci.ContainerEngine.get_cluster(cluster_id=test_cluster_oci_containerengine_cluster["id"])
+    test_cluster = oci.ContainerEngine.get_cluster(cluster_id=test_cluster_oci_containerengine_cluster["id"],
+        should_include_oidc_config_file=cluster_should_include_oidc_config_file)
     ```
 
 
     :param builtins.str cluster_id: The OCID of the cluster.
+    :param builtins.str should_include_oidc_config_file: Boolean value to determine if the OpenIdConnectAuth configuration file should be displayed for the provided cluster.
     """
     __args__ = dict()
     __args__['clusterId'] = cluster_id
+    __args__['shouldIncludeOidcConfigFile'] = should_include_oidc_config_file
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('oci:ContainerEngine/getCluster:getCluster', __args__, opts=opts, typ=GetClusterResult).value
 
@@ -315,10 +328,12 @@ def get_cluster(cluster_id: Optional[builtins.str] = None,
         name=pulumi.get(__ret__, 'name'),
         open_id_connect_discovery_endpoint=pulumi.get(__ret__, 'open_id_connect_discovery_endpoint'),
         options=pulumi.get(__ret__, 'options'),
+        should_include_oidc_config_file=pulumi.get(__ret__, 'should_include_oidc_config_file'),
         state=pulumi.get(__ret__, 'state'),
         type=pulumi.get(__ret__, 'type'),
         vcn_id=pulumi.get(__ret__, 'vcn_id'))
 def get_cluster_output(cluster_id: Optional[pulumi.Input[builtins.str]] = None,
+                       should_include_oidc_config_file: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetClusterResult]:
     """
     This data source provides details about a specific Cluster resource in Oracle Cloud Infrastructure Container Engine service.
@@ -331,14 +346,17 @@ def get_cluster_output(cluster_id: Optional[pulumi.Input[builtins.str]] = None,
     import pulumi
     import pulumi_oci as oci
 
-    test_cluster = oci.ContainerEngine.get_cluster(cluster_id=test_cluster_oci_containerengine_cluster["id"])
+    test_cluster = oci.ContainerEngine.get_cluster(cluster_id=test_cluster_oci_containerengine_cluster["id"],
+        should_include_oidc_config_file=cluster_should_include_oidc_config_file)
     ```
 
 
     :param builtins.str cluster_id: The OCID of the cluster.
+    :param builtins.str should_include_oidc_config_file: Boolean value to determine if the OpenIdConnectAuth configuration file should be displayed for the provided cluster.
     """
     __args__ = dict()
     __args__['clusterId'] = cluster_id
+    __args__['shouldIncludeOidcConfigFile'] = should_include_oidc_config_file
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('oci:ContainerEngine/getCluster:getCluster', __args__, opts=opts, typ=GetClusterResult)
     return __ret__.apply(lambda __response__: GetClusterResult(
@@ -359,6 +377,7 @@ def get_cluster_output(cluster_id: Optional[pulumi.Input[builtins.str]] = None,
         name=pulumi.get(__response__, 'name'),
         open_id_connect_discovery_endpoint=pulumi.get(__response__, 'open_id_connect_discovery_endpoint'),
         options=pulumi.get(__response__, 'options'),
+        should_include_oidc_config_file=pulumi.get(__response__, 'should_include_oidc_config_file'),
         state=pulumi.get(__response__, 'state'),
         type=pulumi.get(__response__, 'type'),
         vcn_id=pulumi.get(__response__, 'vcn_id')))

pulumi_oci/containerengine/node_pool.py

@@ -823,11 +823,13 @@ class NodePool(pulumi.CustomResource):
             },
             node_eviction_node_pool_settings={
                 "eviction_grace_duration": node_pool_node_eviction_node_pool_settings_eviction_grace_duration,
+                "is_force_action_after_grace_duration": node_pool_node_eviction_node_pool_settings_is_force_action_after_grace_duration,
                 "is_force_delete_after_grace_duration": node_pool_node_eviction_node_pool_settings_is_force_delete_after_grace_duration,
             },
             node_image_name=test_image["name"],
             node_metadata=node_pool_node_metadata,
             node_pool_cycling_details={
+                "cycle_modes": node_pool_node_pool_cycling_details_cycle_modes,
                 "is_node_cycling_enabled": node_pool_node_pool_cycling_details_is_node_cycling_enabled,
                 "maximum_surge": node_pool_node_pool_cycling_details_maximum_surge,
                 "maximum_unavailable": node_pool_node_pool_cycling_details_maximum_unavailable,
@@ -945,11 +947,13 @@ class NodePool(pulumi.CustomResource):
             },
             node_eviction_node_pool_settings={
                 "eviction_grace_duration": node_pool_node_eviction_node_pool_settings_eviction_grace_duration,
+                "is_force_action_after_grace_duration": node_pool_node_eviction_node_pool_settings_is_force_action_after_grace_duration,
                 "is_force_delete_after_grace_duration": node_pool_node_eviction_node_pool_settings_is_force_delete_after_grace_duration,
             },
             node_image_name=test_image["name"],
             node_metadata=node_pool_node_metadata,
             node_pool_cycling_details={
+                "cycle_modes": node_pool_node_pool_cycling_details_cycle_modes,
                 "is_node_cycling_enabled": node_pool_node_pool_cycling_details_is_node_cycling_enabled,
                 "maximum_surge": node_pool_node_pool_cycling_details_maximum_surge,
                 "maximum_unavailable": node_pool_node_pool_cycling_details_maximum_unavailable,

pulumi_oci/containerengine/outputs.py

@@ -3380,6 +3380,8 @@ class NodePoolNodeEvictionNodePoolSettings(dict):
         suggest = None
         if key == "evictionGraceDuration":
             suggest = "eviction_grace_duration"
+        elif key == "isForceActionAfterGraceDuration":
+            suggest = "is_force_action_after_grace_duration"
         elif key == "isForceDeleteAfterGraceDuration":
             suggest = "is_force_delete_after_grace_duration"
 
@@ -3396,13 +3398,17 @@ class NodePoolNodeEvictionNodePoolSettings(dict):
 
     def __init__(__self__, *,
                  eviction_grace_duration: Optional[builtins.str] = None,
+                 is_force_action_after_grace_duration: Optional[builtins.bool] = None,
                  is_force_delete_after_grace_duration: Optional[builtins.bool] = None):
         """
         :param builtins.str eviction_grace_duration: (Updatable) Duration after which OKE will give up eviction of the pods on the node. PT0M will indicate you want to delete the node without cordon and drain. Default PT60M, Min PT0M, Max: PT60M. Format ISO 8601 e.g PT30M
+        :param builtins.bool is_force_action_after_grace_duration: (Updatable) If the node action should be performed if not all the pods can be evicted in the grace period
         :param builtins.bool is_force_delete_after_grace_duration: (Updatable) If the underlying compute instance should be deleted if you cannot evict all the pods in grace period
         """
         if eviction_grace_duration is not None:
             pulumi.set(__self__, "eviction_grace_duration", eviction_grace_duration)
+        if is_force_action_after_grace_duration is not None:
+            pulumi.set(__self__, "is_force_action_after_grace_duration", is_force_action_after_grace_duration)
         if is_force_delete_after_grace_duration is not None:
             pulumi.set(__self__, "is_force_delete_after_grace_duration", is_force_delete_after_grace_duration)
 
@@ -3414,6 +3420,14 @@ class NodePoolNodeEvictionNodePoolSettings(dict):
         """
         return pulumi.get(self, "eviction_grace_duration")
 
+    @property
+    @pulumi.getter(name="isForceActionAfterGraceDuration")
+    def is_force_action_after_grace_duration(self) -> Optional[builtins.bool]:
+        """
+        (Updatable) If the node action should be performed if not all the pods can be evicted in the grace period
+        """
+        return pulumi.get(self, "is_force_action_after_grace_duration")
+
     @property
     @pulumi.getter(name="isForceDeleteAfterGraceDuration")
     def is_force_delete_after_grace_duration(self) -> Optional[builtins.bool]:
@@ -3428,7 +3442,9 @@ class NodePoolNodePoolCyclingDetails(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "isNodeCyclingEnabled":
+        if key == "cycleModes":
+            suggest = "cycle_modes"
+        elif key == "isNodeCyclingEnabled":
             suggest = "is_node_cycling_enabled"
         elif key == "maximumSurge":
             suggest = "maximum_surge"
@@ -3447,14 +3463,18 @@ class NodePoolNodePoolCyclingDetails(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 cycle_modes: Optional[Sequence[builtins.str]] = None,
                  is_node_cycling_enabled: Optional[builtins.bool] = None,
                  maximum_surge: Optional[builtins.str] = None,
                  maximum_unavailable: Optional[builtins.str] = None):
         """
-        :param builtins.bool is_node_cycling_enabled: (Updatable) If nodes in the nodepool will be cycled to have new changes.
+        :param Sequence[builtins.str] cycle_modes: (Updatable) An ordered list of cycle modes that should be performed on the OKE nodes.
+        :param builtins.bool is_node_cycling_enabled: (Updatable) If cycling operation should be performed on the nodes in the node pool.
         :param builtins.str maximum_surge: (Updatable) Maximum additional new compute instances that would be temporarily created and added to nodepool during the cycling nodepool process. OKE supports both integer and percentage input. Defaults to 1, Ranges from 0 to Nodepool size or 0% to 100%
         :param builtins.str maximum_unavailable: (Updatable) Maximum active nodes that would be terminated from nodepool during the cycling nodepool process. OKE supports both integer and percentage input. Defaults to 0, Ranges from 0 to Nodepool size or 0% to 100%
         """
+        if cycle_modes is not None:
+            pulumi.set(__self__, "cycle_modes", cycle_modes)
         if is_node_cycling_enabled is not None:
             pulumi.set(__self__, "is_node_cycling_enabled", is_node_cycling_enabled)
         if maximum_surge is not None:
@@ -3462,11 +3482,19 @@ class NodePoolNodePoolCyclingDetails(dict):
         if maximum_unavailable is not None:
             pulumi.set(__self__, "maximum_unavailable", maximum_unavailable)
 
+    @property
+    @pulumi.getter(name="cycleModes")
+    def cycle_modes(self) -> Optional[Sequence[builtins.str]]:
+        """
+        (Updatable) An ordered list of cycle modes that should be performed on the OKE nodes.
+        """
+        return pulumi.get(self, "cycle_modes")
+
     @property
     @pulumi.getter(name="isNodeCyclingEnabled")
     def is_node_cycling_enabled(self) -> Optional[builtins.bool]:
         """
-        (Updatable) If nodes in the nodepool will be cycled to have new changes.
+        (Updatable) If cycling operation should be performed on the nodes in the node pool.
         """
         return pulumi.get(self, "is_node_cycling_enabled")
 
@@ -6801,12 +6829,15 @@ class GetNodePoolNodeErrorResult(dict):
 class GetNodePoolNodeEvictionNodePoolSettingResult(dict):
     def __init__(__self__, *,
                  eviction_grace_duration: builtins.str,
+                 is_force_action_after_grace_duration: builtins.bool,
                  is_force_delete_after_grace_duration: builtins.bool):
         """
         :param builtins.str eviction_grace_duration: Duration after which OKE will give up eviction of the pods on the node. PT0M will indicate you want to delete the node without cordon and drain. Default PT60M, Min PT0M, Max: PT60M. Format ISO 8601 e.g PT30M
+        :param builtins.bool is_force_action_after_grace_duration: If the node action should be performed if not all the pods can be evicted in the grace period
         :param builtins.bool is_force_delete_after_grace_duration: If the underlying compute instance should be deleted if you cannot evict all the pods in grace period
         """
         pulumi.set(__self__, "eviction_grace_duration", eviction_grace_duration)
+        pulumi.set(__self__, "is_force_action_after_grace_duration", is_force_action_after_grace_duration)
         pulumi.set(__self__, "is_force_delete_after_grace_duration", is_force_delete_after_grace_duration)
 
     @property
@@ -6817,6 +6848,14 @@ class GetNodePoolNodeEvictionNodePoolSettingResult(dict):
         """
         return pulumi.get(self, "eviction_grace_duration")
 
+    @property
+    @pulumi.getter(name="isForceActionAfterGraceDuration")
+    def is_force_action_after_grace_duration(self) -> builtins.bool:
+        """
+        If the node action should be performed if not all the pods can be evicted in the grace period
+        """
+        return pulumi.get(self, "is_force_action_after_grace_duration")
+
     @property
     @pulumi.getter(name="isForceDeleteAfterGraceDuration")
     def is_force_delete_after_grace_duration(self) -> builtins.bool:
@@ -6829,23 +6868,34 @@ class GetNodePoolNodeEvictionNodePoolSettingResult(dict):
 @pulumi.output_type
 class GetNodePoolNodePoolCyclingDetailResult(dict):
     def __init__(__self__, *,
+                 cycle_modes: Sequence[builtins.str],
                  is_node_cycling_enabled: builtins.bool,
                  maximum_surge: builtins.str,
                  maximum_unavailable: builtins.str):
         """
-        :param builtins.bool is_node_cycling_enabled: If nodes in the nodepool will be cycled to have new changes.
+        :param Sequence[builtins.str] cycle_modes: An ordered list of cycle modes that should be performed on the OKE nodes.
+        :param builtins.bool is_node_cycling_enabled: If cycling operation should be performed on the nodes in the node pool.
         :param builtins.str maximum_surge: Maximum additional new compute instances that would be temporarily created and added to nodepool during the cycling nodepool process. OKE supports both integer and percentage input. Defaults to 1, Ranges from 0 to Nodepool size or 0% to 100%
         :param builtins.str maximum_unavailable: Maximum active nodes that would be terminated from nodepool during the cycling nodepool process. OKE supports both integer and percentage input. Defaults to 0, Ranges from 0 to Nodepool size or 0% to 100%
         """
+        pulumi.set(__self__, "cycle_modes", cycle_modes)
         pulumi.set(__self__, "is_node_cycling_enabled", is_node_cycling_enabled)
         pulumi.set(__self__, "maximum_surge", maximum_surge)
         pulumi.set(__self__, "maximum_unavailable", maximum_unavailable)
 
+    @property
+    @pulumi.getter(name="cycleModes")
+    def cycle_modes(self) -> Sequence[builtins.str]:
+        """
+        An ordered list of cycle modes that should be performed on the OKE nodes.
+        """
+        return pulumi.get(self, "cycle_modes")
+
     @property
     @pulumi.getter(name="isNodeCyclingEnabled")
     def is_node_cycling_enabled(self) -> builtins.bool:
         """
-        If nodes in the nodepool will be cycled to have new changes.
+        If cycling operation should be performed on the nodes in the node pool.
         """
         return pulumi.get(self, "is_node_cycling_enabled")
 
@@ -7775,12 +7825,15 @@ class GetNodePoolsNodePoolNodeErrorResult(dict):
 class GetNodePoolsNodePoolNodeEvictionNodePoolSettingResult(dict):
     def __init__(__self__, *,
                  eviction_grace_duration: builtins.str,
+                 is_force_action_after_grace_duration: builtins.bool,
                  is_force_delete_after_grace_duration: builtins.bool):
         """
         :param builtins.str eviction_grace_duration: Duration after which OKE will give up eviction of the pods on the node. PT0M will indicate you want to delete the node without cordon and drain. Default PT60M, Min PT0M, Max: PT60M. Format ISO 8601 e.g PT30M
+        :param builtins.bool is_force_action_after_grace_duration: If the node action should be performed if not all the pods can be evicted in the grace period
         :param builtins.bool is_force_delete_after_grace_duration: If the underlying compute instance should be deleted if you cannot evict all the pods in grace period
         """
         pulumi.set(__self__, "eviction_grace_duration", eviction_grace_duration)
+        pulumi.set(__self__, "is_force_action_after_grace_duration", is_force_action_after_grace_duration)
         pulumi.set(__self__, "is_force_delete_after_grace_duration", is_force_delete_after_grace_duration)
 
     @property
@@ -7791,6 +7844,14 @@ class GetNodePoolsNodePoolNodeEvictionNodePoolSettingResult(dict):
         """
         return pulumi.get(self, "eviction_grace_duration")
 
+    @property
+    @pulumi.getter(name="isForceActionAfterGraceDuration")
+    def is_force_action_after_grace_duration(self) -> builtins.bool:
+        """
+        If the node action should be performed if not all the pods can be evicted in the grace period
+        """
+        return pulumi.get(self, "is_force_action_after_grace_duration")
+
     @property
     @pulumi.getter(name="isForceDeleteAfterGraceDuration")
     def is_force_delete_after_grace_duration(self) -> builtins.bool:
@@ -7803,23 +7864,34 @@ class GetNodePoolsNodePoolNodeEvictionNodePoolSettingResult(dict):
 @pulumi.output_type
 class GetNodePoolsNodePoolNodePoolCyclingDetailResult(dict):
     def __init__(__self__, *,
+                 cycle_modes: Sequence[builtins.str],
                  is_node_cycling_enabled: builtins.bool,
                  maximum_surge: builtins.str,
                  maximum_unavailable: builtins.str):
         """
-        :param builtins.bool is_node_cycling_enabled: If nodes in the nodepool will be cycled to have new changes.
+        :param Sequence[builtins.str] cycle_modes: An ordered list of cycle modes that should be performed on the OKE nodes.
+        :param builtins.bool is_node_cycling_enabled: If cycling operation should be performed on the nodes in the node pool.
         :param builtins.str maximum_surge: Maximum additional new compute instances that would be temporarily created and added to nodepool during the cycling nodepool process. OKE supports both integer and percentage input. Defaults to 1, Ranges from 0 to Nodepool size or 0% to 100%
         :param builtins.str maximum_unavailable: Maximum active nodes that would be terminated from nodepool during the cycling nodepool process. OKE supports both integer and percentage input. Defaults to 0, Ranges from 0 to Nodepool size or 0% to 100%
         """
+        pulumi.set(__self__, "cycle_modes", cycle_modes)
         pulumi.set(__self__, "is_node_cycling_enabled", is_node_cycling_enabled)
         pulumi.set(__self__, "maximum_surge", maximum_surge)
         pulumi.set(__self__, "maximum_unavailable", maximum_unavailable)
 
+    @property
+    @pulumi.getter(name="cycleModes")
+    def cycle_modes(self) -> Sequence[builtins.str]:
+        """
+        An ordered list of cycle modes that should be performed on the OKE nodes.
+        """
+        return pulumi.get(self, "cycle_modes")
+
     @property
     @pulumi.getter(name="isNodeCyclingEnabled")
     def is_node_cycling_enabled(self) -> builtins.bool:
         """
-        If nodes in the nodepool will be cycled to have new changes.
+        If cycling operation should be performed on the nodes in the node pool.
         """
         return pulumi.get(self, "is_node_cycling_enabled")
 

pulumi_oci/database/_inputs.py

@@ -6495,7 +6495,7 @@ class AutonomousDatabaseResourcePoolSummaryArgs:
 
 if not MYPY:
     class AutonomousDatabaseScheduledOperationArgsDict(TypedDict):
-        day_of_week: pulumi.Input['AutonomousDatabaseScheduledOperationDayOfWeekArgsDict']
+        day_of_week: NotRequired[pulumi.Input['AutonomousDatabaseScheduledOperationDayOfWeekArgsDict']]
         """
         (Updatable) Day of the week.
         """
@@ -6513,7 +6513,7 @@ elif False:
 @pulumi.input_type
 class AutonomousDatabaseScheduledOperationArgs:
     def __init__(__self__, *,
-                 day_of_week: pulumi.Input['AutonomousDatabaseScheduledOperationDayOfWeekArgs'],
+                 day_of_week: Optional[pulumi.Input['AutonomousDatabaseScheduledOperationDayOfWeekArgs']] = None,
                  scheduled_start_time: Optional[pulumi.Input[builtins.str]] = None,
                  scheduled_stop_time: Optional[pulumi.Input[builtins.str]] = None):
         """
@@ -6521,7 +6521,8 @@ class AutonomousDatabaseScheduledOperationArgs:
         :param pulumi.Input[builtins.str] scheduled_start_time: (Updatable) auto start time. value must be of ISO-8601 format "HH:mm"
         :param pulumi.Input[builtins.str] scheduled_stop_time: (Updatable) auto stop time. value must be of ISO-8601 format "HH:mm"
         """
-        pulumi.set(__self__, "day_of_week", day_of_week)
+        if day_of_week is not None:
+            pulumi.set(__self__, "day_of_week", day_of_week)
         if scheduled_start_time is not None:
             pulumi.set(__self__, "scheduled_start_time", scheduled_start_time)
         if scheduled_stop_time is not None:
@@ -6529,14 +6530,14 @@ class AutonomousDatabaseScheduledOperationArgs:
 
     @property
     @pulumi.getter(name="dayOfWeek")
-    def day_of_week(self) -> pulumi.Input['AutonomousDatabaseScheduledOperationDayOfWeekArgs']:
+    def day_of_week(self) -> Optional[pulumi.Input['AutonomousDatabaseScheduledOperationDayOfWeekArgs']]:
         """
         (Updatable) Day of the week.
         """
         return pulumi.get(self, "day_of_week")
 
     @day_of_week.setter
-    def day_of_week(self, value: pulumi.Input['AutonomousDatabaseScheduledOperationDayOfWeekArgs']):
+    def day_of_week(self, value: Optional[pulumi.Input['AutonomousDatabaseScheduledOperationDayOfWeekArgs']]):
         pulumi.set(self, "day_of_week", value)
 
     @property