pulumi-aws 7.11.1__py3-none-any.whl → 7.12.0__py3-none-any.whl

pulumi_aws/elasticache/_inputs.py

@@ -25,6 +25,8 @@ __all__ = [
     'ParameterGroupParameterArgsDict',
     'ReplicationGroupLogDeliveryConfigurationArgs',
     'ReplicationGroupLogDeliveryConfigurationArgsDict',
+    'ReplicationGroupNodeGroupConfigurationArgs',
+    'ReplicationGroupNodeGroupConfigurationArgsDict',
     'ReservedCacheNodeRecurringChargeArgs',
     'ReservedCacheNodeRecurringChargeArgsDict',
     'ReservedCacheNodeTimeoutsArgs',
@@ -418,6 +420,158 @@ class ReplicationGroupLogDeliveryConfigurationArgs:
         pulumi.set(self, "log_type", value)
 
 
+if not MYPY:
+    class ReplicationGroupNodeGroupConfigurationArgsDict(TypedDict):
+        node_group_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        ID for the node group. Redis (cluster mode disabled) replication groups don't have node group IDs, so this value is ignored. For Redis (cluster mode enabled) replication groups, the node group ID is a 1 to 4 character alphanumeric string.
+        """
+        primary_availability_zone: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Availability zone for the primary node.
+        """
+        primary_outpost_arn: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        ARN of the Outpost for the primary node.
+        """
+        replica_availability_zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        List of availability zones for the replica nodes.
+        """
+        replica_count: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Number of replica nodes in this node group.
+        """
+        replica_outpost_arns: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        List of ARNs of the Outposts for the replica nodes.
+        """
+        slots: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Keyspace for this node group. Format is `start-end` (e.g., `0-5460`). For Redis (cluster mode disabled) replication groups, this value is ignored.
+        """
+elif False:
+    ReplicationGroupNodeGroupConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ReplicationGroupNodeGroupConfigurationArgs:
+    def __init__(__self__, *,
+                 node_group_id: Optional[pulumi.Input[_builtins.str]] = None,
+                 primary_availability_zone: Optional[pulumi.Input[_builtins.str]] = None,
+                 primary_outpost_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 replica_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 replica_count: Optional[pulumi.Input[_builtins.int]] = None,
+                 replica_outpost_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 slots: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] node_group_id: ID for the node group. Redis (cluster mode disabled) replication groups don't have node group IDs, so this value is ignored. For Redis (cluster mode enabled) replication groups, the node group ID is a 1 to 4 character alphanumeric string.
+        :param pulumi.Input[_builtins.str] primary_availability_zone: Availability zone for the primary node.
+        :param pulumi.Input[_builtins.str] primary_outpost_arn: ARN of the Outpost for the primary node.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] replica_availability_zones: List of availability zones for the replica nodes.
+        :param pulumi.Input[_builtins.int] replica_count: Number of replica nodes in this node group.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] replica_outpost_arns: List of ARNs of the Outposts for the replica nodes.
+        :param pulumi.Input[_builtins.str] slots: Keyspace for this node group. Format is `start-end` (e.g., `0-5460`). For Redis (cluster mode disabled) replication groups, this value is ignored.
+        """
+        if node_group_id is not None:
+            pulumi.set(__self__, "node_group_id", node_group_id)
+        if primary_availability_zone is not None:
+            pulumi.set(__self__, "primary_availability_zone", primary_availability_zone)
+        if primary_outpost_arn is not None:
+            pulumi.set(__self__, "primary_outpost_arn", primary_outpost_arn)
+        if replica_availability_zones is not None:
+            pulumi.set(__self__, "replica_availability_zones", replica_availability_zones)
+        if replica_count is not None:
+            pulumi.set(__self__, "replica_count", replica_count)
+        if replica_outpost_arns is not None:
+            pulumi.set(__self__, "replica_outpost_arns", replica_outpost_arns)
+        if slots is not None:
+            pulumi.set(__self__, "slots", slots)
+
+    @_builtins.property
+    @pulumi.getter(name="nodeGroupId")
+    def node_group_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        ID for the node group. Redis (cluster mode disabled) replication groups don't have node group IDs, so this value is ignored. For Redis (cluster mode enabled) replication groups, the node group ID is a 1 to 4 character alphanumeric string.
+        """
+        return pulumi.get(self, "node_group_id")
+
+    @node_group_id.setter
+    def node_group_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "node_group_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="primaryAvailabilityZone")
+    def primary_availability_zone(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Availability zone for the primary node.
+        """
+        return pulumi.get(self, "primary_availability_zone")
+
+    @primary_availability_zone.setter
+    def primary_availability_zone(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "primary_availability_zone", value)
+
+    @_builtins.property
+    @pulumi.getter(name="primaryOutpostArn")
+    def primary_outpost_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        ARN of the Outpost for the primary node.
+        """
+        return pulumi.get(self, "primary_outpost_arn")
+
+    @primary_outpost_arn.setter
+    def primary_outpost_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "primary_outpost_arn", value)
+
+    @_builtins.property
+    @pulumi.getter(name="replicaAvailabilityZones")
+    def replica_availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        List of availability zones for the replica nodes.
+        """
+        return pulumi.get(self, "replica_availability_zones")
+
+    @replica_availability_zones.setter
+    def replica_availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "replica_availability_zones", value)
+
+    @_builtins.property
+    @pulumi.getter(name="replicaCount")
+    def replica_count(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Number of replica nodes in this node group.
+        """
+        return pulumi.get(self, "replica_count")
+
+    @replica_count.setter
+    def replica_count(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "replica_count", value)
+
+    @_builtins.property
+    @pulumi.getter(name="replicaOutpostArns")
+    def replica_outpost_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        List of ARNs of the Outposts for the replica nodes.
+        """
+        return pulumi.get(self, "replica_outpost_arns")
+
+    @replica_outpost_arns.setter
+    def replica_outpost_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "replica_outpost_arns", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def slots(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Keyspace for this node group. Format is `start-end` (e.g., `0-5460`). For Redis (cluster mode disabled) replication groups, this value is ignored.
+        """
+        return pulumi.get(self, "slots")
+
+    @slots.setter
+    def slots(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "slots", value)
+
+
 if not MYPY:
     class ReservedCacheNodeRecurringChargeArgsDict(TypedDict):
         recurring_charge_amount: pulumi.Input[_builtins.float]

pulumi_aws/elasticache/get_replication_group.py

@@ -27,7 +27,7 @@ class GetReplicationGroupResult:
     """
     A collection of values returned by getReplicationGroup.
     """
-    def __init__(__self__, arn=None, auth_token_enabled=None, automatic_failover_enabled=None, cluster_mode=None, configuration_endpoint_address=None, description=None, id=None, log_delivery_configurations=None, member_clusters=None, multi_az_enabled=None, node_type=None, num_cache_clusters=None, num_node_groups=None, port=None, primary_endpoint_address=None, reader_endpoint_address=None, region=None, replicas_per_node_group=None, replication_group_id=None, snapshot_retention_limit=None, snapshot_window=None):
+    def __init__(__self__, arn=None, auth_token_enabled=None, automatic_failover_enabled=None, cluster_mode=None, configuration_endpoint_address=None, description=None, id=None, log_delivery_configurations=None, member_clusters=None, multi_az_enabled=None, node_group_configurations=None, node_type=None, num_cache_clusters=None, num_node_groups=None, port=None, primary_endpoint_address=None, reader_endpoint_address=None, region=None, replicas_per_node_group=None, replication_group_id=None, snapshot_retention_limit=None, snapshot_window=None):
         if arn and not isinstance(arn, str):
             raise TypeError("Expected argument 'arn' to be a str")
         pulumi.set(__self__, "arn", arn)
@@ -58,6 +58,9 @@ class GetReplicationGroupResult:
         if multi_az_enabled and not isinstance(multi_az_enabled, bool):
             raise TypeError("Expected argument 'multi_az_enabled' to be a bool")
         pulumi.set(__self__, "multi_az_enabled", multi_az_enabled)
+        if node_group_configurations and not isinstance(node_group_configurations, list):
+            raise TypeError("Expected argument 'node_group_configurations' to be a list")
+        pulumi.set(__self__, "node_group_configurations", node_group_configurations)
         if node_type and not isinstance(node_type, str):
             raise TypeError("Expected argument 'node_type' to be a str")
         pulumi.set(__self__, "node_type", node_type)
@@ -112,7 +115,7 @@ class GetReplicationGroupResult:
     @pulumi.getter(name="automaticFailoverEnabled")
     def automatic_failover_enabled(self) -> _builtins.bool:
         """
-        A flag whether a read-only replica will be automatically promoted to read/write primary if the existing primary fails.
+        Whether a read-only replica will be automatically promoted to read/write primary if the existing primary fails.
         """
         return pulumi.get(self, "automatic_failover_enabled")
 
@@ -128,7 +131,7 @@ class GetReplicationGroupResult:
     @pulumi.getter(name="configurationEndpointAddress")
     def configuration_endpoint_address(self) -> _builtins.str:
         """
-        The configuration endpoint address to allow host discovery.
+        Configuration endpoint address to allow host discovery.
         """
         return pulumi.get(self, "configuration_endpoint_address")
 
@@ -172,11 +175,19 @@ class GetReplicationGroupResult:
         """
         return pulumi.get(self, "multi_az_enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="nodeGroupConfigurations")
+    def node_group_configurations(self) -> Sequence['outputs.GetReplicationGroupNodeGroupConfigurationResult']:
+        """
+        Configuration of the node groups (shards). See below.
+        """
+        return pulumi.get(self, "node_group_configurations")
+
     @_builtins.property
     @pulumi.getter(name="nodeType")
     def node_type(self) -> _builtins.str:
         """
-        The cluster node type.
+        Cluster node type.
         """
         return pulumi.get(self, "node_type")
 
@@ -184,7 +195,7 @@ class GetReplicationGroupResult:
     @pulumi.getter(name="numCacheClusters")
     def num_cache_clusters(self) -> _builtins.int:
         """
-        The number of cache clusters that the replication group has.
+        Number of cache clusters that the replication group has.
         """
         return pulumi.get(self, "num_cache_clusters")
 
@@ -200,7 +211,7 @@ class GetReplicationGroupResult:
     @pulumi.getter
     def port(self) -> _builtins.int:
         """
-        The port number on which the configuration endpoint will accept connections.
+        Port number on which the configuration endpoint will accept connections.
         """
         return pulumi.get(self, "port")
 
@@ -208,7 +219,7 @@ class GetReplicationGroupResult:
     @pulumi.getter(name="primaryEndpointAddress")
     def primary_endpoint_address(self) -> _builtins.str:
         """
-        The endpoint of the primary node in this node group (shard).
+        Endpoint of the primary node in this node group (shard).
         """
         return pulumi.get(self, "primary_endpoint_address")
 
@@ -216,7 +227,7 @@ class GetReplicationGroupResult:
     @pulumi.getter(name="readerEndpointAddress")
     def reader_endpoint_address(self) -> _builtins.str:
         """
-        The endpoint of the reader node in this node group (shard).
+        Endpoint of the reader node in this node group (shard).
         """
         return pulumi.get(self, "reader_endpoint_address")
 
@@ -242,7 +253,7 @@ class GetReplicationGroupResult:
     @pulumi.getter(name="snapshotRetentionLimit")
     def snapshot_retention_limit(self) -> _builtins.int:
         """
-        The number of days for which ElastiCache retains automatic cache cluster snapshots before deleting them.
+        Number of days for which ElastiCache retains automatic cache cluster snapshots before deleting them.
         """
         return pulumi.get(self, "snapshot_retention_limit")
 
@@ -271,6 +282,7 @@ class AwaitableGetReplicationGroupResult(GetReplicationGroupResult):
             log_delivery_configurations=self.log_delivery_configurations,
             member_clusters=self.member_clusters,
             multi_az_enabled=self.multi_az_enabled,
+            node_group_configurations=self.node_group_configurations,
             node_type=self.node_type,
             num_cache_clusters=self.num_cache_clusters,
             num_node_groups=self.num_node_groups,
@@ -320,6 +332,7 @@ def get_replication_group(region: Optional[_builtins.str] = None,
         log_delivery_configurations=pulumi.get(__ret__, 'log_delivery_configurations'),
         member_clusters=pulumi.get(__ret__, 'member_clusters'),
         multi_az_enabled=pulumi.get(__ret__, 'multi_az_enabled'),
+        node_group_configurations=pulumi.get(__ret__, 'node_group_configurations'),
         node_type=pulumi.get(__ret__, 'node_type'),
         num_cache_clusters=pulumi.get(__ret__, 'num_cache_clusters'),
         num_node_groups=pulumi.get(__ret__, 'num_node_groups'),
@@ -366,6 +379,7 @@ def get_replication_group_output(region: Optional[pulumi.Input[Optional[_builtin
         log_delivery_configurations=pulumi.get(__response__, 'log_delivery_configurations'),
         member_clusters=pulumi.get(__response__, 'member_clusters'),
         multi_az_enabled=pulumi.get(__response__, 'multi_az_enabled'),
+        node_group_configurations=pulumi.get(__response__, 'node_group_configurations'),
         node_type=pulumi.get(__response__, 'node_type'),
         num_cache_clusters=pulumi.get(__response__, 'num_cache_clusters'),
         num_node_groups=pulumi.get(__response__, 'num_node_groups'),

pulumi_aws/elasticache/outputs.py

@@ -21,6 +21,7 @@ __all__ = [
     'GlobalReplicationGroupGlobalNodeGroup',
     'ParameterGroupParameter',
     'ReplicationGroupLogDeliveryConfiguration',
+    'ReplicationGroupNodeGroupConfiguration',
     'ReservedCacheNodeRecurringCharge',
     'ReservedCacheNodeTimeouts',
     'ServerlessCacheCacheUsageLimits',
@@ -33,6 +34,7 @@ __all__ = [
     'GetClusterCacheNodeResult',
     'GetClusterLogDeliveryConfigurationResult',
     'GetReplicationGroupLogDeliveryConfigurationResult',
+    'GetReplicationGroupNodeGroupConfigurationResult',
     'GetServerlessCacheCacheUsageLimitsResult',
     'GetServerlessCacheCacheUsageLimitsDataStorageResult',
     'GetServerlessCacheCacheUsageLimitsEcpuPerSecondResult',
@@ -336,6 +338,124 @@ class ReplicationGroupLogDeliveryConfiguration(dict):
         return pulumi.get(self, "log_type")
 
 
+@pulumi.output_type
+class ReplicationGroupNodeGroupConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "nodeGroupId":
+            suggest = "node_group_id"
+        elif key == "primaryAvailabilityZone":
+            suggest = "primary_availability_zone"
+        elif key == "primaryOutpostArn":
+            suggest = "primary_outpost_arn"
+        elif key == "replicaAvailabilityZones":
+            suggest = "replica_availability_zones"
+        elif key == "replicaCount":
+            suggest = "replica_count"
+        elif key == "replicaOutpostArns":
+            suggest = "replica_outpost_arns"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ReplicationGroupNodeGroupConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ReplicationGroupNodeGroupConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ReplicationGroupNodeGroupConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 node_group_id: Optional[_builtins.str] = None,
+                 primary_availability_zone: Optional[_builtins.str] = None,
+                 primary_outpost_arn: Optional[_builtins.str] = None,
+                 replica_availability_zones: Optional[Sequence[_builtins.str]] = None,
+                 replica_count: Optional[_builtins.int] = None,
+                 replica_outpost_arns: Optional[Sequence[_builtins.str]] = None,
+                 slots: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str node_group_id: ID for the node group. Redis (cluster mode disabled) replication groups don't have node group IDs, so this value is ignored. For Redis (cluster mode enabled) replication groups, the node group ID is a 1 to 4 character alphanumeric string.
+        :param _builtins.str primary_availability_zone: Availability zone for the primary node.
+        :param _builtins.str primary_outpost_arn: ARN of the Outpost for the primary node.
+        :param Sequence[_builtins.str] replica_availability_zones: List of availability zones for the replica nodes.
+        :param _builtins.int replica_count: Number of replica nodes in this node group.
+        :param Sequence[_builtins.str] replica_outpost_arns: List of ARNs of the Outposts for the replica nodes.
+        :param _builtins.str slots: Keyspace for this node group. Format is `start-end` (e.g., `0-5460`). For Redis (cluster mode disabled) replication groups, this value is ignored.
+        """
+        if node_group_id is not None:
+            pulumi.set(__self__, "node_group_id", node_group_id)
+        if primary_availability_zone is not None:
+            pulumi.set(__self__, "primary_availability_zone", primary_availability_zone)
+        if primary_outpost_arn is not None:
+            pulumi.set(__self__, "primary_outpost_arn", primary_outpost_arn)
+        if replica_availability_zones is not None:
+            pulumi.set(__self__, "replica_availability_zones", replica_availability_zones)
+        if replica_count is not None:
+            pulumi.set(__self__, "replica_count", replica_count)
+        if replica_outpost_arns is not None:
+            pulumi.set(__self__, "replica_outpost_arns", replica_outpost_arns)
+        if slots is not None:
+            pulumi.set(__self__, "slots", slots)
+
+    @_builtins.property
+    @pulumi.getter(name="nodeGroupId")
+    def node_group_id(self) -> Optional[_builtins.str]:
+        """
+        ID for the node group. Redis (cluster mode disabled) replication groups don't have node group IDs, so this value is ignored. For Redis (cluster mode enabled) replication groups, the node group ID is a 1 to 4 character alphanumeric string.
+        """
+        return pulumi.get(self, "node_group_id")
+
+    @_builtins.property
+    @pulumi.getter(name="primaryAvailabilityZone")
+    def primary_availability_zone(self) -> Optional[_builtins.str]:
+        """
+        Availability zone for the primary node.
+        """
+        return pulumi.get(self, "primary_availability_zone")
+
+    @_builtins.property
+    @pulumi.getter(name="primaryOutpostArn")
+    def primary_outpost_arn(self) -> Optional[_builtins.str]:
+        """
+        ARN of the Outpost for the primary node.
+        """
+        return pulumi.get(self, "primary_outpost_arn")
+
+    @_builtins.property
+    @pulumi.getter(name="replicaAvailabilityZones")
+    def replica_availability_zones(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        List of availability zones for the replica nodes.
+        """
+        return pulumi.get(self, "replica_availability_zones")
+
+    @_builtins.property
+    @pulumi.getter(name="replicaCount")
+    def replica_count(self) -> Optional[_builtins.int]:
+        """
+        Number of replica nodes in this node group.
+        """
+        return pulumi.get(self, "replica_count")
+
+    @_builtins.property
+    @pulumi.getter(name="replicaOutpostArns")
+    def replica_outpost_arns(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        List of ARNs of the Outposts for the replica nodes.
+        """
+        return pulumi.get(self, "replica_outpost_arns")
+
+    @_builtins.property
+    @pulumi.getter
+    def slots(self) -> Optional[_builtins.str]:
+        """
+        Keyspace for this node group. Format is `start-end` (e.g., `0-5460`). For Redis (cluster mode disabled) replication groups, this value is ignored.
+        """
+        return pulumi.get(self, "slots")
+
+
 @pulumi.output_type
 class ReservedCacheNodeRecurringCharge(dict):
     @staticmethod
@@ -814,6 +934,90 @@ class GetReplicationGroupLogDeliveryConfigurationResult(dict):
         return pulumi.get(self, "log_type")
 
 
+@pulumi.output_type
+class GetReplicationGroupNodeGroupConfigurationResult(dict):
+    def __init__(__self__, *,
+                 node_group_id: _builtins.str,
+                 primary_availability_zone: _builtins.str,
+                 primary_outpost_arn: _builtins.str,
+                 replica_availability_zones: Sequence[_builtins.str],
+                 replica_count: _builtins.int,
+                 replica_outpost_arns: Sequence[_builtins.str],
+                 slots: _builtins.str):
+        """
+        :param _builtins.str node_group_id: ID of the node group.
+        :param _builtins.str primary_availability_zone: Availability Zone for the primary node.
+        :param _builtins.str primary_outpost_arn: Outpost ARN of the primary node.
+        :param Sequence[_builtins.str] replica_availability_zones: List of Availability Zones for the replica nodes.
+        :param _builtins.int replica_count: Number of replica nodes in this node group.
+        :param Sequence[_builtins.str] replica_outpost_arns: List of outpost ARNs for the replica nodes.
+        :param _builtins.str slots: Keyspace for this node group (shard).
+        """
+        pulumi.set(__self__, "node_group_id", node_group_id)
+        pulumi.set(__self__, "primary_availability_zone", primary_availability_zone)
+        pulumi.set(__self__, "primary_outpost_arn", primary_outpost_arn)
+        pulumi.set(__self__, "replica_availability_zones", replica_availability_zones)
+        pulumi.set(__self__, "replica_count", replica_count)
+        pulumi.set(__self__, "replica_outpost_arns", replica_outpost_arns)
+        pulumi.set(__self__, "slots", slots)
+
+    @_builtins.property
+    @pulumi.getter(name="nodeGroupId")
+    def node_group_id(self) -> _builtins.str:
+        """
+        ID of the node group.
+        """
+        return pulumi.get(self, "node_group_id")
+
+    @_builtins.property
+    @pulumi.getter(name="primaryAvailabilityZone")
+    def primary_availability_zone(self) -> _builtins.str:
+        """
+        Availability Zone for the primary node.
+        """
+        return pulumi.get(self, "primary_availability_zone")
+
+    @_builtins.property
+    @pulumi.getter(name="primaryOutpostArn")
+    def primary_outpost_arn(self) -> _builtins.str:
+        """
+        Outpost ARN of the primary node.
+        """
+        return pulumi.get(self, "primary_outpost_arn")
+
+    @_builtins.property
+    @pulumi.getter(name="replicaAvailabilityZones")
+    def replica_availability_zones(self) -> Sequence[_builtins.str]:
+        """
+        List of Availability Zones for the replica nodes.
+        """
+        return pulumi.get(self, "replica_availability_zones")
+
+    @_builtins.property
+    @pulumi.getter(name="replicaCount")
+    def replica_count(self) -> _builtins.int:
+        """
+        Number of replica nodes in this node group.
+        """
+        return pulumi.get(self, "replica_count")
+
+    @_builtins.property
+    @pulumi.getter(name="replicaOutpostArns")
+    def replica_outpost_arns(self) -> Sequence[_builtins.str]:
+        """
+        List of outpost ARNs for the replica nodes.
+        """
+        return pulumi.get(self, "replica_outpost_arns")
+
+    @_builtins.property
+    @pulumi.getter
+    def slots(self) -> _builtins.str:
+        """
+        Keyspace for this node group (shard).
+        """
+        return pulumi.get(self, "slots")
+
+
 @pulumi.output_type
 class GetServerlessCacheCacheUsageLimitsResult(dict):
     def __init__(__self__, *,