pulumi-spotinst 3.121.0a1750482125__py3-none-any.whl → 3.121.0a1751945899__py3-none-any.whl

pulumi_spotinst/gke/_inputs.py

@@ -18,6 +18,8 @@ from .. import _utilities
 __all__ = [
     'ElastigroupBackendServiceArgs',
     'ElastigroupBackendServiceArgsDict',
+    'ElastigroupBackendServiceBackendBalancingArgs',
+    'ElastigroupBackendServiceBackendBalancingArgsDict',
     'ElastigroupBackendServiceNamedPortArgs',
     'ElastigroupBackendServiceNamedPortArgsDict',
     'ElastigroupDiskArgs',
@@ -135,6 +137,7 @@ MYPY = False
 if not MYPY:
     class ElastigroupBackendServiceArgsDict(TypedDict):
         service_name: pulumi.Input[builtins.str]
+        backend_balancing: NotRequired[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgsDict']]
         location_type: NotRequired[pulumi.Input[builtins.str]]
         named_ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgsDict']]]]
         scheme: NotRequired[pulumi.Input[builtins.str]]
@@ -145,10 +148,13 @@ 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):
         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:
@@ -165,6 +171,15 @@ 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']]:
+        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]]:
@@ -193,6 +208,42 @@ class ElastigroupBackendServiceArgs:
         pulumi.set(self, "scheme", value)
 
 
+if not MYPY:
+    class ElastigroupBackendServiceBackendBalancingArgsDict(TypedDict):
+        backend_balancing_mode: NotRequired[pulumi.Input[builtins.str]]
+        max_rate_per_instance: NotRequired[pulumi.Input[builtins.int]]
+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):
+        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]]:
+        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]]:
+        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]

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")
+