pulumi-spotinst 3.120.2a1750995428__py3-none-any.whl → 3.121.0__py3-none-any.whl

pulumi_spotinst/gke/outputs.py

@@ -18,6 +18,7 @@ from . import outputs
 
 __all__ = [
     'ElastigroupBackendService',
+    'ElastigroupBackendServiceBackendBalancing',
     'ElastigroupBackendServiceNamedPort',
     'ElastigroupDisk',
     'ElastigroupDiskInitializeParam',
@@ -82,6 +83,8 @@ class ElastigroupBackendService(dict):
         suggest = None
         if key == "serviceName":
             suggest = "service_name"
+        elif key == "backendBalancing":
+            suggest = "backend_balancing"
         elif key == "locationType":
             suggest = "location_type"
         elif key == "namedPorts":
@@ -100,10 +103,13 @@ class ElastigroupBackendService(dict):
 
     def __init__(__self__, *,
                  service_name: builtins.str,
+                 backend_balancing: Optional['outputs.ElastigroupBackendServiceBackendBalancing'] = None,
                  location_type: Optional[builtins.str] = None,
                  named_ports: Optional[Sequence['outputs.ElastigroupBackendServiceNamedPort']] = None,
                  scheme: Optional[builtins.str] = None):
         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:
@@ -116,6 +122,11 @@ class ElastigroupBackendService(dict):
     def service_name(self) -> builtins.str:
         return pulumi.get(self, "service_name")
 
+    @property
+    @pulumi.getter(name="backendBalancing")
+    def backend_balancing(self) -> Optional['outputs.ElastigroupBackendServiceBackendBalancing']:
+        return pulumi.get(self, "backend_balancing")
+
     @property
     @pulumi.getter(name="locationType")
     def location_type(self) -> Optional[builtins.str]:
@@ -132,6 +143,46 @@ class ElastigroupBackendService(dict):
         return pulumi.get(self, "scheme")
 
 
+@pulumi.output_type
+class ElastigroupBackendServiceBackendBalancing(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backendBalancingMode":
+            suggest = "backend_balancing_mode"
+        elif key == "maxRatePerInstance":
+            suggest = "max_rate_per_instance"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ElastigroupBackendServiceBackendBalancing. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ElastigroupBackendServiceBackendBalancing.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ElastigroupBackendServiceBackendBalancing.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 backend_balancing_mode: Optional[builtins.str] = None,
+                 max_rate_per_instance: Optional[builtins.int] = None):
+        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[builtins.str]:
+        return pulumi.get(self, "backend_balancing_mode")
+
+    @property
+    @pulumi.getter(name="maxRatePerInstance")
+    def max_rate_per_instance(self) -> Optional[builtins.int]:
+        return pulumi.get(self, "max_rate_per_instance")
+
+
 @pulumi.output_type
 class ElastigroupBackendServiceNamedPort(dict):
     def __init__(__self__, *,

pulumi_spotinst/notification_center.py

@@ -0,0 +1,345 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+from . import outputs
+from ._inputs import *
+
+__all__ = ['NotificationCenterArgs', 'NotificationCenter']
+
+@pulumi.input_type
+class NotificationCenterArgs:
+    def __init__(__self__, *,
+                 compute_policy_config: pulumi.Input['NotificationCenterComputePolicyConfigArgs'],
+                 privacy_level: pulumi.Input[builtins.str],
+                 description: Optional[pulumi.Input[builtins.str]] = None,
+                 is_active: Optional[pulumi.Input[builtins.bool]] = None,
+                 name: Optional[pulumi.Input[builtins.str]] = None,
+                 registered_users: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterRegisteredUserArgs']]]] = None,
+                 subscriptions: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterSubscriptionArgs']]]] = None):
+        """
+        The set of arguments for constructing a NotificationCenter resource.
+        """
+        pulumi.set(__self__, "compute_policy_config", compute_policy_config)
+        pulumi.set(__self__, "privacy_level", privacy_level)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if is_active is not None:
+            pulumi.set(__self__, "is_active", is_active)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if registered_users is not None:
+            pulumi.set(__self__, "registered_users", registered_users)
+        if subscriptions is not None:
+            pulumi.set(__self__, "subscriptions", subscriptions)
+
+    @property
+    @pulumi.getter(name="computePolicyConfig")
+    def compute_policy_config(self) -> pulumi.Input['NotificationCenterComputePolicyConfigArgs']:
+        return pulumi.get(self, "compute_policy_config")
+
+    @compute_policy_config.setter
+    def compute_policy_config(self, value: pulumi.Input['NotificationCenterComputePolicyConfigArgs']):
+        pulumi.set(self, "compute_policy_config", value)
+
+    @property
+    @pulumi.getter(name="privacyLevel")
+    def privacy_level(self) -> pulumi.Input[builtins.str]:
+        return pulumi.get(self, "privacy_level")
+
+    @privacy_level.setter
+    def privacy_level(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "privacy_level", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter(name="isActive")
+    def is_active(self) -> Optional[pulumi.Input[builtins.bool]]:
+        return pulumi.get(self, "is_active")
+
+    @is_active.setter
+    def is_active(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "is_active", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="registeredUsers")
+    def registered_users(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterRegisteredUserArgs']]]]:
+        return pulumi.get(self, "registered_users")
+
+    @registered_users.setter
+    def registered_users(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterRegisteredUserArgs']]]]):
+        pulumi.set(self, "registered_users", value)
+
+    @property
+    @pulumi.getter
+    def subscriptions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterSubscriptionArgs']]]]:
+        return pulumi.get(self, "subscriptions")
+
+    @subscriptions.setter
+    def subscriptions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterSubscriptionArgs']]]]):
+        pulumi.set(self, "subscriptions", value)
+
+
+@pulumi.input_type
+class _NotificationCenterState:
+    def __init__(__self__, *,
+                 compute_policy_config: Optional[pulumi.Input['NotificationCenterComputePolicyConfigArgs']] = None,
+                 description: Optional[pulumi.Input[builtins.str]] = None,
+                 is_active: Optional[pulumi.Input[builtins.bool]] = None,
+                 name: Optional[pulumi.Input[builtins.str]] = None,
+                 privacy_level: Optional[pulumi.Input[builtins.str]] = None,
+                 registered_users: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterRegisteredUserArgs']]]] = None,
+                 subscriptions: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterSubscriptionArgs']]]] = None):
+        """
+        Input properties used for looking up and filtering NotificationCenter resources.
+        """
+        if compute_policy_config is not None:
+            pulumi.set(__self__, "compute_policy_config", compute_policy_config)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if is_active is not None:
+            pulumi.set(__self__, "is_active", is_active)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if privacy_level is not None:
+            pulumi.set(__self__, "privacy_level", privacy_level)
+        if registered_users is not None:
+            pulumi.set(__self__, "registered_users", registered_users)
+        if subscriptions is not None:
+            pulumi.set(__self__, "subscriptions", subscriptions)
+
+    @property
+    @pulumi.getter(name="computePolicyConfig")
+    def compute_policy_config(self) -> Optional[pulumi.Input['NotificationCenterComputePolicyConfigArgs']]:
+        return pulumi.get(self, "compute_policy_config")
+
+    @compute_policy_config.setter
+    def compute_policy_config(self, value: Optional[pulumi.Input['NotificationCenterComputePolicyConfigArgs']]):
+        pulumi.set(self, "compute_policy_config", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter(name="isActive")
+    def is_active(self) -> Optional[pulumi.Input[builtins.bool]]:
+        return pulumi.get(self, "is_active")
+
+    @is_active.setter
+    def is_active(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "is_active", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="privacyLevel")
+    def privacy_level(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "privacy_level")
+
+    @privacy_level.setter
+    def privacy_level(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "privacy_level", value)
+
+    @property
+    @pulumi.getter(name="registeredUsers")
+    def registered_users(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterRegisteredUserArgs']]]]:
+        return pulumi.get(self, "registered_users")
+
+    @registered_users.setter
+    def registered_users(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterRegisteredUserArgs']]]]):
+        pulumi.set(self, "registered_users", value)
+
+    @property
+    @pulumi.getter
+    def subscriptions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterSubscriptionArgs']]]]:
+        return pulumi.get(self, "subscriptions")
+
+    @subscriptions.setter
+    def subscriptions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterSubscriptionArgs']]]]):
+        pulumi.set(self, "subscriptions", value)
+
+
+@pulumi.type_token("spotinst:index/notificationCenter:NotificationCenter")
+class NotificationCenter(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 compute_policy_config: Optional[pulumi.Input[Union['NotificationCenterComputePolicyConfigArgs', 'NotificationCenterComputePolicyConfigArgsDict']]] = None,
+                 description: Optional[pulumi.Input[builtins.str]] = None,
+                 is_active: Optional[pulumi.Input[builtins.bool]] = None,
+                 name: Optional[pulumi.Input[builtins.str]] = None,
+                 privacy_level: Optional[pulumi.Input[builtins.str]] = None,
+                 registered_users: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NotificationCenterRegisteredUserArgs', 'NotificationCenterRegisteredUserArgsDict']]]]] = None,
+                 subscriptions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NotificationCenterSubscriptionArgs', 'NotificationCenterSubscriptionArgsDict']]]]] = None,
+                 __props__=None):
+        """
+        Create a NotificationCenter resource with the given unique name, props, and options.
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: NotificationCenterArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        Create a NotificationCenter resource with the given unique name, props, and options.
+        :param str resource_name: The name of the resource.
+        :param NotificationCenterArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(NotificationCenterArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 compute_policy_config: Optional[pulumi.Input[Union['NotificationCenterComputePolicyConfigArgs', 'NotificationCenterComputePolicyConfigArgsDict']]] = None,
+                 description: Optional[pulumi.Input[builtins.str]] = None,
+                 is_active: Optional[pulumi.Input[builtins.bool]] = None,
+                 name: Optional[pulumi.Input[builtins.str]] = None,
+                 privacy_level: Optional[pulumi.Input[builtins.str]] = None,
+                 registered_users: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NotificationCenterRegisteredUserArgs', 'NotificationCenterRegisteredUserArgsDict']]]]] = None,
+                 subscriptions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NotificationCenterSubscriptionArgs', 'NotificationCenterSubscriptionArgsDict']]]]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = NotificationCenterArgs.__new__(NotificationCenterArgs)
+
+            if compute_policy_config is None and not opts.urn:
+                raise TypeError("Missing required property 'compute_policy_config'")
+            __props__.__dict__["compute_policy_config"] = compute_policy_config
+            __props__.__dict__["description"] = description
+            __props__.__dict__["is_active"] = is_active
+            __props__.__dict__["name"] = name
+            if privacy_level is None and not opts.urn:
+                raise TypeError("Missing required property 'privacy_level'")
+            __props__.__dict__["privacy_level"] = privacy_level
+            __props__.__dict__["registered_users"] = registered_users
+            __props__.__dict__["subscriptions"] = subscriptions
+        super(NotificationCenter, __self__).__init__(
+            'spotinst:index/notificationCenter:NotificationCenter',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            compute_policy_config: Optional[pulumi.Input[Union['NotificationCenterComputePolicyConfigArgs', 'NotificationCenterComputePolicyConfigArgsDict']]] = None,
+            description: Optional[pulumi.Input[builtins.str]] = None,
+            is_active: Optional[pulumi.Input[builtins.bool]] = None,
+            name: Optional[pulumi.Input[builtins.str]] = None,
+            privacy_level: Optional[pulumi.Input[builtins.str]] = None,
+            registered_users: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NotificationCenterRegisteredUserArgs', 'NotificationCenterRegisteredUserArgsDict']]]]] = None,
+            subscriptions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NotificationCenterSubscriptionArgs', 'NotificationCenterSubscriptionArgsDict']]]]] = None) -> 'NotificationCenter':
+        """
+        Get an existing NotificationCenter resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _NotificationCenterState.__new__(_NotificationCenterState)
+
+        __props__.__dict__["compute_policy_config"] = compute_policy_config
+        __props__.__dict__["description"] = description
+        __props__.__dict__["is_active"] = is_active
+        __props__.__dict__["name"] = name
+        __props__.__dict__["privacy_level"] = privacy_level
+        __props__.__dict__["registered_users"] = registered_users
+        __props__.__dict__["subscriptions"] = subscriptions
+        return NotificationCenter(resource_name, opts=opts, __props__=__props__)
+
+    @property
+    @pulumi.getter(name="computePolicyConfig")
+    def compute_policy_config(self) -> pulumi.Output['outputs.NotificationCenterComputePolicyConfig']:
+        return pulumi.get(self, "compute_policy_config")
+
+    @property
+    @pulumi.getter
+    def description(self) -> pulumi.Output[Optional[builtins.str]]:
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="isActive")
+    def is_active(self) -> pulumi.Output[Optional[builtins.bool]]:
+        return pulumi.get(self, "is_active")
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Output[builtins.str]:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="privacyLevel")
+    def privacy_level(self) -> pulumi.Output[builtins.str]:
+        return pulumi.get(self, "privacy_level")
+
+    @property
+    @pulumi.getter(name="registeredUsers")
+    def registered_users(self) -> pulumi.Output[Optional[Sequence['outputs.NotificationCenterRegisteredUser']]]:
+        return pulumi.get(self, "registered_users")
+
+    @property
+    @pulumi.getter
+    def subscriptions(self) -> pulumi.Output[Optional[Sequence['outputs.NotificationCenterSubscription']]]:
+        return pulumi.get(self, "subscriptions")
+

pulumi_spotinst/outputs.py

@@ -56,6 +56,12 @@ __all__ = [
     'ElastigroupAzureV3VmSizes',
     'ElastigroupAzureV3VmSizesSpotSizeAttributes',
     'HealthCheckCheck',
+    'NotificationCenterComputePolicyConfig',
+    'NotificationCenterComputePolicyConfigDynamicRule',
+    'NotificationCenterComputePolicyConfigDynamicRuleFilterCondition',
+    'NotificationCenterComputePolicyConfigEvent',
+    'NotificationCenterRegisteredUser',
+    'NotificationCenterSubscription',
     'OceanRightSizingRuleAttachWorkload',
     'OceanRightSizingRuleAttachWorkloadNamespace',
     'OceanRightSizingRuleAttachWorkloadNamespaceLabel',
@@ -2223,6 +2229,238 @@ class HealthCheckCheck(dict):
         return pulumi.get(self, "timeout")
 
 
+@pulumi.output_type
+class NotificationCenterComputePolicyConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dynamicRules":
+            suggest = "dynamic_rules"
+        elif key == "resourceIds":
+            suggest = "resource_ids"
+        elif key == "shouldIncludeAllResources":
+            suggest = "should_include_all_resources"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NotificationCenterComputePolicyConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NotificationCenterComputePolicyConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NotificationCenterComputePolicyConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 events: Sequence['outputs.NotificationCenterComputePolicyConfigEvent'],
+                 dynamic_rules: Optional[Sequence['outputs.NotificationCenterComputePolicyConfigDynamicRule']] = None,
+                 resource_ids: Optional[Sequence[builtins.str]] = None,
+                 should_include_all_resources: Optional[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) -> Sequence['outputs.NotificationCenterComputePolicyConfigEvent']:
+        return pulumi.get(self, "events")
+
+    @property
+    @pulumi.getter(name="dynamicRules")
+    def dynamic_rules(self) -> Optional[Sequence['outputs.NotificationCenterComputePolicyConfigDynamicRule']]:
+        return pulumi.get(self, "dynamic_rules")
+
+    @property
+    @pulumi.getter(name="resourceIds")
+    def resource_ids(self) -> Optional[Sequence[builtins.str]]:
+        return pulumi.get(self, "resource_ids")
+
+    @property
+    @pulumi.getter(name="shouldIncludeAllResources")
+    def should_include_all_resources(self) -> Optional[builtins.bool]:
+        return pulumi.get(self, "should_include_all_resources")
+
+
+@pulumi.output_type
+class NotificationCenterComputePolicyConfigDynamicRule(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "filterConditions":
+            suggest = "filter_conditions"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NotificationCenterComputePolicyConfigDynamicRule. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NotificationCenterComputePolicyConfigDynamicRule.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NotificationCenterComputePolicyConfigDynamicRule.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 filter_conditions: Optional[Sequence['outputs.NotificationCenterComputePolicyConfigDynamicRuleFilterCondition']] = None):
+        if filter_conditions is not None:
+            pulumi.set(__self__, "filter_conditions", filter_conditions)
+
+    @property
+    @pulumi.getter(name="filterConditions")
+    def filter_conditions(self) -> Optional[Sequence['outputs.NotificationCenterComputePolicyConfigDynamicRuleFilterCondition']]:
+        return pulumi.get(self, "filter_conditions")
+
+
+@pulumi.output_type
+class NotificationCenterComputePolicyConfigDynamicRuleFilterCondition(dict):
+    def __init__(__self__, *,
+                 expression: Optional[builtins.str] = None,
+                 identifier: Optional[builtins.str] = None,
+                 operator: Optional[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[builtins.str]:
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def identifier(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "identifier")
+
+    @property
+    @pulumi.getter
+    def operator(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "operator")
+
+
+@pulumi.output_type
+class NotificationCenterComputePolicyConfigEvent(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "eventType":
+            suggest = "event_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NotificationCenterComputePolicyConfigEvent. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NotificationCenterComputePolicyConfigEvent.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NotificationCenterComputePolicyConfigEvent.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 event: Optional[builtins.str] = None,
+                 event_type: Optional[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[builtins.str]:
+        return pulumi.get(self, "event")
+
+    @property
+    @pulumi.getter(name="eventType")
+    def event_type(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "event_type")
+
+
+@pulumi.output_type
+class NotificationCenterRegisteredUser(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "subscriptionTypes":
+            suggest = "subscription_types"
+        elif key == "userEmail":
+            suggest = "user_email"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NotificationCenterRegisteredUser. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NotificationCenterRegisteredUser.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NotificationCenterRegisteredUser.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 subscription_types: Optional[Sequence[builtins.str]] = None,
+                 user_email: Optional[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[Sequence[builtins.str]]:
+        return pulumi.get(self, "subscription_types")
+
+    @property
+    @pulumi.getter(name="userEmail")
+    def user_email(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "user_email")
+
+
+@pulumi.output_type
+class NotificationCenterSubscription(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "subscriptionType":
+            suggest = "subscription_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NotificationCenterSubscription. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NotificationCenterSubscription.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NotificationCenterSubscription.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 endpoint: Optional[builtins.str] = None,
+                 subscription_type: Optional[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[builtins.str]:
+        return pulumi.get(self, "endpoint")
+
+    @property
+    @pulumi.getter(name="subscriptionType")
+    def subscription_type(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "subscription_type")
+
+
 @pulumi.output_type
 class OceanRightSizingRuleAttachWorkload(dict):
     def __init__(__self__, *,