pulumi-spotinst 3.121.0a1750482125__tar.gz → 3.122.0__tar.gz

{pulumi_spotinst-3.121.0a1750482125 → pulumi_spotinst-3.122.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_spotinst
-Version: 3.121.0a1750482125
+Version: 3.122.0
 Summary: A Pulumi package for creating and managing spotinst cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_spotinst-3.121.0a1750482125 → pulumi_spotinst-3.122.0}/pulumi_spotinst/__init__.py

@@ -12,6 +12,7 @@ from .credentials_gcp import *
 from .data_integration import *
 from .elastigroup_azure_v3 import *
 from .health_check import *
+from .notification_center import *
 from .ocean_right_sizing_rule import *
 from .provider import *
 from .stateful_node_azure import *
@@ -253,6 +254,14 @@ _utilities.register(
    "spotinst:index/healthCheck:HealthCheck": "HealthCheck"
   }
  },
+ {
+  "pkg": "spotinst",
+  "mod": "index/notificationCenter",
+  "fqn": "pulumi_spotinst",
+  "classes": {
+   "spotinst:index/notificationCenter:NotificationCenter": "NotificationCenter"
+  }
+ },
  {
   "pkg": "spotinst",
   "mod": "index/oceanRightSizingRule",

{pulumi_spotinst-3.121.0a1750482125 → pulumi_spotinst-3.122.0}/pulumi_spotinst/_inputs.py

@@ -94,6 +94,18 @@ __all__ = [
     'ElastigroupAzureV3VmSizesSpotSizeAttributesArgsDict',
     'HealthCheckCheckArgs',
     'HealthCheckCheckArgsDict',
+    'NotificationCenterComputePolicyConfigArgs',
+    'NotificationCenterComputePolicyConfigArgsDict',
+    'NotificationCenterComputePolicyConfigDynamicRuleArgs',
+    'NotificationCenterComputePolicyConfigDynamicRuleArgsDict',
+    'NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs',
+    'NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgsDict',
+    'NotificationCenterComputePolicyConfigEventArgs',
+    'NotificationCenterComputePolicyConfigEventArgsDict',
+    'NotificationCenterRegisteredUserArgs',
+    'NotificationCenterRegisteredUserArgsDict',
+    'NotificationCenterSubscriptionArgs',
+    'NotificationCenterSubscriptionArgsDict',
     'OceanRightSizingRuleAttachWorkloadArgs',
     'OceanRightSizingRuleAttachWorkloadArgsDict',
     'OceanRightSizingRuleAttachWorkloadNamespaceArgs',
@@ -2688,6 +2700,247 @@ class HealthCheckCheckArgs:
         pulumi.set(self, "timeout", value)
 
 
+if not MYPY:
+    class NotificationCenterComputePolicyConfigArgsDict(TypedDict):
+        events: pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigEventArgsDict']]]
+        dynamic_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleArgsDict']]]]
+        resource_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
+        should_include_all_resources: NotRequired[pulumi.Input[builtins.bool]]
+elif False:
+    NotificationCenterComputePolicyConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterComputePolicyConfigArgs:
+    def __init__(__self__, *,
+                 events: pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigEventArgs']]],
+                 dynamic_rules: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleArgs']]]] = None,
+                 resource_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+                 should_include_all_resources: Optional[pulumi.Input[builtins.bool]] = None):
+        pulumi.set(__self__, "events", events)
+        if dynamic_rules is not None:
+            pulumi.set(__self__, "dynamic_rules", dynamic_rules)
+        if resource_ids is not None:
+            pulumi.set(__self__, "resource_ids", resource_ids)
+        if should_include_all_resources is not None:
+            pulumi.set(__self__, "should_include_all_resources", should_include_all_resources)
+
+    @property
+    @pulumi.getter
+    def events(self) -> pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigEventArgs']]]:
+        return pulumi.get(self, "events")
+
+    @events.setter
+    def events(self, value: pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigEventArgs']]]):
+        pulumi.set(self, "events", value)
+
+    @property
+    @pulumi.getter(name="dynamicRules")
+    def dynamic_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleArgs']]]]:
+        return pulumi.get(self, "dynamic_rules")
+
+    @dynamic_rules.setter
+    def dynamic_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleArgs']]]]):
+        pulumi.set(self, "dynamic_rules", value)
+
+    @property
+    @pulumi.getter(name="resourceIds")
+    def resource_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
+        return pulumi.get(self, "resource_ids")
+
+    @resource_ids.setter
+    def resource_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "resource_ids", value)
+
+    @property
+    @pulumi.getter(name="shouldIncludeAllResources")
+    def should_include_all_resources(self) -> Optional[pulumi.Input[builtins.bool]]:
+        return pulumi.get(self, "should_include_all_resources")
+
+    @should_include_all_resources.setter
+    def should_include_all_resources(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "should_include_all_resources", value)
+
+
+if not MYPY:
+    class NotificationCenterComputePolicyConfigDynamicRuleArgsDict(TypedDict):
+        filter_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgsDict']]]]
+elif False:
+    NotificationCenterComputePolicyConfigDynamicRuleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterComputePolicyConfigDynamicRuleArgs:
+    def __init__(__self__, *,
+                 filter_conditions: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs']]]] = None):
+        if filter_conditions is not None:
+            pulumi.set(__self__, "filter_conditions", filter_conditions)
+
+    @property
+    @pulumi.getter(name="filterConditions")
+    def filter_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs']]]]:
+        return pulumi.get(self, "filter_conditions")
+
+    @filter_conditions.setter
+    def filter_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs']]]]):
+        pulumi.set(self, "filter_conditions", value)
+
+
+if not MYPY:
+    class NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgsDict(TypedDict):
+        expression: NotRequired[pulumi.Input[builtins.str]]
+        identifier: NotRequired[pulumi.Input[builtins.str]]
+        operator: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs:
+    def __init__(__self__, *,
+                 expression: Optional[pulumi.Input[builtins.str]] = None,
+                 identifier: Optional[pulumi.Input[builtins.str]] = None,
+                 operator: Optional[pulumi.Input[builtins.str]] = None):
+        if expression is not None:
+            pulumi.set(__self__, "expression", expression)
+        if identifier is not None:
+            pulumi.set(__self__, "identifier", identifier)
+        if operator is not None:
+            pulumi.set(__self__, "operator", operator)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def identifier(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "identifier")
+
+    @identifier.setter
+    def identifier(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "identifier", value)
+
+    @property
+    @pulumi.getter
+    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "operator")
+
+    @operator.setter
+    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "operator", value)
+
+
+if not MYPY:
+    class NotificationCenterComputePolicyConfigEventArgsDict(TypedDict):
+        event: NotRequired[pulumi.Input[builtins.str]]
+        event_type: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    NotificationCenterComputePolicyConfigEventArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterComputePolicyConfigEventArgs:
+    def __init__(__self__, *,
+                 event: Optional[pulumi.Input[builtins.str]] = None,
+                 event_type: Optional[pulumi.Input[builtins.str]] = None):
+        if event is not None:
+            pulumi.set(__self__, "event", event)
+        if event_type is not None:
+            pulumi.set(__self__, "event_type", event_type)
+
+    @property
+    @pulumi.getter
+    def event(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "event")
+
+    @event.setter
+    def event(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "event", value)
+
+    @property
+    @pulumi.getter(name="eventType")
+    def event_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "event_type")
+
+    @event_type.setter
+    def event_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "event_type", value)
+
+
+if not MYPY:
+    class NotificationCenterRegisteredUserArgsDict(TypedDict):
+        subscription_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
+        user_email: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    NotificationCenterRegisteredUserArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterRegisteredUserArgs:
+    def __init__(__self__, *,
+                 subscription_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+                 user_email: Optional[pulumi.Input[builtins.str]] = None):
+        if subscription_types is not None:
+            pulumi.set(__self__, "subscription_types", subscription_types)
+        if user_email is not None:
+            pulumi.set(__self__, "user_email", user_email)
+
+    @property
+    @pulumi.getter(name="subscriptionTypes")
+    def subscription_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
+        return pulumi.get(self, "subscription_types")
+
+    @subscription_types.setter
+    def subscription_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "subscription_types", value)
+
+    @property
+    @pulumi.getter(name="userEmail")
+    def user_email(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "user_email")
+
+    @user_email.setter
+    def user_email(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "user_email", value)
+
+
+if not MYPY:
+    class NotificationCenterSubscriptionArgsDict(TypedDict):
+        endpoint: NotRequired[pulumi.Input[builtins.str]]
+        subscription_type: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    NotificationCenterSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterSubscriptionArgs:
+    def __init__(__self__, *,
+                 endpoint: Optional[pulumi.Input[builtins.str]] = None,
+                 subscription_type: Optional[pulumi.Input[builtins.str]] = None):
+        if endpoint is not None:
+            pulumi.set(__self__, "endpoint", endpoint)
+        if subscription_type is not None:
+            pulumi.set(__self__, "subscription_type", subscription_type)
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "endpoint")
+
+    @endpoint.setter
+    def endpoint(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "endpoint", value)
+
+    @property
+    @pulumi.getter(name="subscriptionType")
+    def subscription_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "subscription_type")
+
+    @subscription_type.setter
+    def subscription_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "subscription_type", value)
+
+
 if not MYPY:
     class OceanRightSizingRuleAttachWorkloadArgsDict(TypedDict):
         namespaces: pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAttachWorkloadNamespaceArgsDict']]]
@@ -4863,7 +5116,7 @@ class StatefulNodeAzureSecretVaultCertificateArgs:
 
 if not MYPY:
     class StatefulNodeAzureSecurityArgsDict(TypedDict):
-        confidential_os_disk_encryption: NotRequired[pulumi.Input[builtins.bool]]
+        confidential_os_disk_encryption: NotRequired[pulumi.Input[builtins.str]]
         encryption_at_host: NotRequired[pulumi.Input[builtins.bool]]
         secure_boot_enabled: NotRequired[pulumi.Input[builtins.bool]]
         security_type: NotRequired[pulumi.Input[builtins.str]]
@@ -4874,7 +5127,7 @@ elif False:
 @pulumi.input_type
 class StatefulNodeAzureSecurityArgs:
     def __init__(__self__, *,
-                 confidential_os_disk_encryption: Optional[pulumi.Input[builtins.bool]] = None,
+                 confidential_os_disk_encryption: Optional[pulumi.Input[builtins.str]] = None,
                  encryption_at_host: Optional[pulumi.Input[builtins.bool]] = None,
                  secure_boot_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                  security_type: Optional[pulumi.Input[builtins.str]] = None,
@@ -4892,11 +5145,11 @@ class StatefulNodeAzureSecurityArgs:
 
     @property
     @pulumi.getter(name="confidentialOsDiskEncryption")
-    def confidential_os_disk_encryption(self) -> Optional[pulumi.Input[builtins.bool]]:
+    def confidential_os_disk_encryption(self) -> Optional[pulumi.Input[builtins.str]]:
         return pulumi.get(self, "confidential_os_disk_encryption")
 
     @confidential_os_disk_encryption.setter
-    def confidential_os_disk_encryption(self, value: Optional[pulumi.Input[builtins.bool]]):
+    def confidential_os_disk_encryption(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "confidential_os_disk_encryption", value)
 
     @property

{pulumi_spotinst-3.121.0a1750482125 → pulumi_spotinst-3.122.0}/pulumi_spotinst/aws/_inputs.py

@@ -318,6 +318,8 @@ __all__ = [
     'OceanLaunchSpecStartupTaintArgsDict',
     'OceanLaunchSpecStrategyArgs',
     'OceanLaunchSpecStrategyArgsDict',
+    'OceanLaunchSpecStrategyOrientationArgs',
+    'OceanLaunchSpecStrategyOrientationArgsDict',
     'OceanLaunchSpecTagArgs',
     'OceanLaunchSpecTagArgsDict',
     'OceanLaunchSpecTaintArgs',
@@ -13210,6 +13212,10 @@ if not MYPY:
         """
         The configurable amount of time that Ocean will wait for the draining process to complete before terminating an instance. If you have not defined a draining timeout, the default of 300 seconds will be used.
         """
+        orientation: NotRequired[pulumi.Input['OceanLaunchSpecStrategyOrientationArgsDict']]
+        """
+        Vng orientation configuration.
+        """
         spot_percentage: NotRequired[pulumi.Input[builtins.int]]
         """
         The desired percentage of the Spot instances out of all running instances for this VNG. Only available when the field is not set in the cluster directly (cluster.strategy.spotPercentage).
@@ -13229,17 +13235,21 @@ elif False:
 class OceanLaunchSpecStrategyArgs:
     def __init__(__self__, *,
                  draining_timeout: Optional[pulumi.Input[builtins.int]] = None,
+                 orientation: Optional[pulumi.Input['OceanLaunchSpecStrategyOrientationArgs']] = None,
                  spot_percentage: Optional[pulumi.Input[builtins.int]] = None,
                  utilize_commitments: Optional[pulumi.Input[builtins.bool]] = None,
                  utilize_reserved_instances: Optional[pulumi.Input[builtins.bool]] = None):
         """
         :param pulumi.Input[builtins.int] draining_timeout: The configurable amount of time that Ocean will wait for the draining process to complete before terminating an instance. If you have not defined a draining timeout, the default of 300 seconds will be used.
+        :param pulumi.Input['OceanLaunchSpecStrategyOrientationArgs'] orientation: Vng orientation configuration.
         :param pulumi.Input[builtins.int] spot_percentage: The desired percentage of the Spot instances out of all running instances for this VNG. Only available when the field is not set in the cluster directly (cluster.strategy.spotPercentage).
         :param pulumi.Input[builtins.bool] utilize_commitments: When set as ‘true’, if savings plans commitments have available capacity, Ocean will utilize them alongside RIs (if exist) to maximize cost efficiency. If the value is set as 'null', it will automatically be inherited from the cluster level.
         :param pulumi.Input[builtins.bool] utilize_reserved_instances: When set as ‘true’, if reserved instances exist, Ocean will utilize them before launching spot instances. If the value is set as 'null', it will automatically be inherited from the cluster level.
         """
         if draining_timeout is not None:
             pulumi.set(__self__, "draining_timeout", draining_timeout)
+        if orientation is not None:
+            pulumi.set(__self__, "orientation", orientation)
         if spot_percentage is not None:
             pulumi.set(__self__, "spot_percentage", spot_percentage)
         if utilize_commitments is not None:
@@ -13259,6 +13269,18 @@ class OceanLaunchSpecStrategyArgs:
     def draining_timeout(self, value: Optional[pulumi.Input[builtins.int]]):
         pulumi.set(self, "draining_timeout", value)
 
+    @property
+    @pulumi.getter
+    def orientation(self) -> Optional[pulumi.Input['OceanLaunchSpecStrategyOrientationArgs']]:
+        """
+        Vng orientation configuration.
+        """
+        return pulumi.get(self, "orientation")
+
+    @orientation.setter
+    def orientation(self, value: Optional[pulumi.Input['OceanLaunchSpecStrategyOrientationArgs']]):
+        pulumi.set(self, "orientation", value)
+
     @property
     @pulumi.getter(name="spotPercentage")
     def spot_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
@@ -13296,6 +13318,38 @@ class OceanLaunchSpecStrategyArgs:
         pulumi.set(self, "utilize_reserved_instances", value)
 
 
+if not MYPY:
+    class OceanLaunchSpecStrategyOrientationArgsDict(TypedDict):
+        availability_vs_cost: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Set this value to control the approach that Ocean takes while launching nodes. Valid values: `"costOriented"`, `"cheapest"`, `"balanced"`.
+        """
+elif False:
+    OceanLaunchSpecStrategyOrientationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class OceanLaunchSpecStrategyOrientationArgs:
+    def __init__(__self__, *,
+                 availability_vs_cost: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] availability_vs_cost: Set this value to control the approach that Ocean takes while launching nodes. Valid values: `"costOriented"`, `"cheapest"`, `"balanced"`.
+        """
+        if availability_vs_cost is not None:
+            pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
+
+    @property
+    @pulumi.getter(name="availabilityVsCost")
+    def availability_vs_cost(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Set this value to control the approach that Ocean takes while launching nodes. Valid values: `"costOriented"`, `"cheapest"`, `"balanced"`.
+        """
+        return pulumi.get(self, "availability_vs_cost")
+
+    @availability_vs_cost.setter
+    def availability_vs_cost(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "availability_vs_cost", value)
+
+
 if not MYPY:
     class OceanLaunchSpecTagArgsDict(TypedDict):
         key: pulumi.Input[builtins.str]

{pulumi_spotinst-3.121.0a1750482125 → pulumi_spotinst-3.122.0}/pulumi_spotinst/aws/outputs.py

@@ -168,6 +168,7 @@ __all__ = [
     'OceanLaunchSpecSchedulingTaskTaskHeadroom',
     'OceanLaunchSpecStartupTaint',
     'OceanLaunchSpecStrategy',
+    'OceanLaunchSpecStrategyOrientation',
     'OceanLaunchSpecTag',
     'OceanLaunchSpecTaint',
     'OceanLaunchSpecUpdatePolicy',
@@ -10384,17 +10385,21 @@ class OceanLaunchSpecStrategy(dict):
 
     def __init__(__self__, *,
                  draining_timeout: Optional[builtins.int] = None,
+                 orientation: Optional['outputs.OceanLaunchSpecStrategyOrientation'] = None,
                  spot_percentage: Optional[builtins.int] = None,
                  utilize_commitments: Optional[builtins.bool] = None,
                  utilize_reserved_instances: Optional[builtins.bool] = None):
         """
         :param builtins.int draining_timeout: The configurable amount of time that Ocean will wait for the draining process to complete before terminating an instance. If you have not defined a draining timeout, the default of 300 seconds will be used.
+        :param 'OceanLaunchSpecStrategyOrientationArgs' orientation: Vng orientation configuration.
         :param builtins.int spot_percentage: The desired percentage of the Spot instances out of all running instances for this VNG. Only available when the field is not set in the cluster directly (cluster.strategy.spotPercentage).
         :param builtins.bool utilize_commitments: When set as ‘true’, if savings plans commitments have available capacity, Ocean will utilize them alongside RIs (if exist) to maximize cost efficiency. If the value is set as 'null', it will automatically be inherited from the cluster level.
         :param builtins.bool utilize_reserved_instances: When set as ‘true’, if reserved instances exist, Ocean will utilize them before launching spot instances. If the value is set as 'null', it will automatically be inherited from the cluster level.
         """
         if draining_timeout is not None:
             pulumi.set(__self__, "draining_timeout", draining_timeout)
+        if orientation is not None:
+            pulumi.set(__self__, "orientation", orientation)
         if spot_percentage is not None:
             pulumi.set(__self__, "spot_percentage", spot_percentage)
         if utilize_commitments is not None:
@@ -10410,6 +10415,14 @@ class OceanLaunchSpecStrategy(dict):
         """
         return pulumi.get(self, "draining_timeout")
 
+    @property
+    @pulumi.getter
+    def orientation(self) -> Optional['outputs.OceanLaunchSpecStrategyOrientation']:
+        """
+        Vng orientation configuration.
+        """
+        return pulumi.get(self, "orientation")
+
     @property
     @pulumi.getter(name="spotPercentage")
     def spot_percentage(self) -> Optional[builtins.int]:
@@ -10435,6 +10448,42 @@ class OceanLaunchSpecStrategy(dict):
         return pulumi.get(self, "utilize_reserved_instances")
 
 
+@pulumi.output_type
+class OceanLaunchSpecStrategyOrientation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "availabilityVsCost":
+            suggest = "availability_vs_cost"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OceanLaunchSpecStrategyOrientation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OceanLaunchSpecStrategyOrientation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OceanLaunchSpecStrategyOrientation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 availability_vs_cost: Optional[builtins.str] = None):
+        """
+        :param builtins.str availability_vs_cost: Set this value to control the approach that Ocean takes while launching nodes. Valid values: `"costOriented"`, `"cheapest"`, `"balanced"`.
+        """
+        if availability_vs_cost is not None:
+            pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
+
+    @property
+    @pulumi.getter(name="availabilityVsCost")
+    def availability_vs_cost(self) -> Optional[builtins.str]:
+        """
+        Set this value to control the approach that Ocean takes while launching nodes. Valid values: `"costOriented"`, `"cheapest"`, `"balanced"`.
+        """
+        return pulumi.get(self, "availability_vs_cost")
+
+
 @pulumi.output_type
 class OceanLaunchSpecTag(dict):
     def __init__(__self__, *,

{pulumi_spotinst-3.121.0a1750482125 → pulumi_spotinst-3.122.0}/pulumi_spotinst/gcp/_inputs.py

@@ -18,6 +18,8 @@ from .. import _utilities
 __all__ = [
     'ElastigroupBackendServiceArgs',
     'ElastigroupBackendServiceArgsDict',
+    'ElastigroupBackendServiceBackendBalancingArgs',
+    'ElastigroupBackendServiceBackendBalancingArgsDict',
     'ElastigroupBackendServiceNamedPortArgs',
     'ElastigroupBackendServiceNamedPortArgsDict',
     'ElastigroupDiskArgs',
@@ -74,6 +76,10 @@ if not MYPY:
         """
         The name of the backend service.
         """
+        backend_balancing: NotRequired[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgsDict']]
+        """
+        Configure how traffic is distributed across instance groups.
+        """
         location_type: NotRequired[pulumi.Input[builtins.str]]
         """
         Sets which location the backend services will be active. Valid values: `regional`, `global`.
@@ -93,16 +99,20 @@ elif False:
 class ElastigroupBackendServiceArgs:
     def __init__(__self__, *,
                  service_name: pulumi.Input[builtins.str],
+                 backend_balancing: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']] = None,
                  location_type: Optional[pulumi.Input[builtins.str]] = None,
                  named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]] = None,
                  scheme: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] service_name: The name of the backend service.
+        :param pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs'] backend_balancing: Configure how traffic is distributed across instance groups.
         :param pulumi.Input[builtins.str] location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
         :param pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]] named_ports: Describes a named port and a list of ports.
         :param pulumi.Input[builtins.str] scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
         """
         pulumi.set(__self__, "service_name", service_name)
+        if backend_balancing is not None:
+            pulumi.set(__self__, "backend_balancing", backend_balancing)
         if location_type is not None:
             pulumi.set(__self__, "location_type", location_type)
         if named_ports is not None:
@@ -122,6 +132,18 @@ class ElastigroupBackendServiceArgs:
     def service_name(self, value: pulumi.Input[builtins.str]):
         pulumi.set(self, "service_name", value)
 
+    @property
+    @pulumi.getter(name="backendBalancing")
+    def backend_balancing(self) -> Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]:
+        """
+        Configure how traffic is distributed across instance groups.
+        """
+        return pulumi.get(self, "backend_balancing")
+
+    @backend_balancing.setter
+    def backend_balancing(self, value: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]):
+        pulumi.set(self, "backend_balancing", value)
+
     @property
     @pulumi.getter(name="locationType")
     def location_type(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -159,6 +181,64 @@ class ElastigroupBackendServiceArgs:
         pulumi.set(self, "scheme", value)
 
 
+if not MYPY:
+    class ElastigroupBackendServiceBackendBalancingArgsDict(TypedDict):
+        backend_balancing_mode: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        """
+        max_rate_per_instance: NotRequired[pulumi.Input[builtins.int]]
+        """
+        If the backendBalancingMode is set to RATE, this field is required.
+
+        Usage:
+        """
+elif False:
+    ElastigroupBackendServiceBackendBalancingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ElastigroupBackendServiceBackendBalancingArgs:
+    def __init__(__self__, *,
+                 backend_balancing_mode: Optional[pulumi.Input[builtins.str]] = None,
+                 max_rate_per_instance: Optional[pulumi.Input[builtins.int]] = None):
+        """
+        :param pulumi.Input[builtins.str] backend_balancing_mode: The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        :param pulumi.Input[builtins.int] max_rate_per_instance: If the backendBalancingMode is set to RATE, this field is required.
+               
+               Usage:
+        """
+        if backend_balancing_mode is not None:
+            pulumi.set(__self__, "backend_balancing_mode", backend_balancing_mode)
+        if max_rate_per_instance is not None:
+            pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
+
+    @property
+    @pulumi.getter(name="backendBalancingMode")
+    def backend_balancing_mode(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        """
+        return pulumi.get(self, "backend_balancing_mode")
+
+    @backend_balancing_mode.setter
+    def backend_balancing_mode(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "backend_balancing_mode", value)
+
+    @property
+    @pulumi.getter(name="maxRatePerInstance")
+    def max_rate_per_instance(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        If the backendBalancingMode is set to RATE, this field is required.
+
+        Usage:
+        """
+        return pulumi.get(self, "max_rate_per_instance")
+
+    @max_rate_per_instance.setter
+    def max_rate_per_instance(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "max_rate_per_instance", value)
+
+
 if not MYPY:
     class ElastigroupBackendServiceNamedPortArgsDict(TypedDict):
         name: pulumi.Input[builtins.str]
@@ -168,8 +248,6 @@ if not MYPY:
         ports: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
         """
         A list of ports.
-
-        Usage:
         """
 elif False:
     ElastigroupBackendServiceNamedPortArgsDict: TypeAlias = Mapping[str, Any]
@@ -182,8 +260,6 @@ class ElastigroupBackendServiceNamedPortArgs:
         """
         :param pulumi.Input[builtins.str] name: The name of the port.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ports: A list of ports.
-               
-               Usage:
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "ports", ports)
@@ -205,8 +281,6 @@ class ElastigroupBackendServiceNamedPortArgs:
     def ports(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
         """
         A list of ports.
-
-        Usage:
         """
         return pulumi.get(self, "ports")