aws-cdk-lib 2.181.1__py3-none-any.whl → 2.183.0__py3-none-any.whl

aws_cdk/aws_opensearchservice/__init__.py

@@ -524,6 +524,32 @@ domain = Domain(self, "Domain",
     ip_address_type=IpAddressType.DUAL_STACK
 )
 ```
+
+## Using Coordinator node with NodeOptions
+
+You can specify coordinator as a valid value for node type.
+
+> Visit [Dedicated coordinator nodes in Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/Dedicated-coordinator-nodes.html) for more details.
+
+```python
+import aws_cdk.aws_opensearchservice as opensearch
+
+
+domain = Domain(self, "Domain",
+    version=EngineVersion.OPENSEARCH_1_3,
+    capacity=opensearch.CapacityConfig(
+        node_options=[opensearch.NodeOptions(
+            node_type=opensearch.NodeType.COORDINATOR,
+            node_config=opensearch.NodeConfig(
+                enabled=True,
+                count=2,
+                type="m5.large.search"
+            )
+        )
+        ]
+    )
+)
+```
 '''
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)
@@ -719,7 +745,7 @@ class AdvancedSecurityOptions:
     def saml_authentication_options(self) -> typing.Optional["SAMLOptionsProperty"]:
         '''Container for information about the SAML configuration for OpenSearch Dashboards.
 
-        If set, ``samlAuthenticationEnabled`` will be enabled.
+        If set, ``samlAuthenticationEnabled`` will be enabled.
 
         :default: - no SAML authentication options
         '''
@@ -747,6 +773,7 @@ class AdvancedSecurityOptions:
         "master_node_instance_type": "masterNodeInstanceType",
         "master_nodes": "masterNodes",
         "multi_az_with_standby_enabled": "multiAzWithStandbyEnabled",
+        "node_options": "nodeOptions",
         "warm_instance_type": "warmInstanceType",
         "warm_nodes": "warmNodes",
     },
@@ -760,6 +787,7 @@ class CapacityConfig:
         master_node_instance_type: typing.Optional[builtins.str] = None,
         master_nodes: typing.Optional[jsii.Number] = None,
         multi_az_with_standby_enabled: typing.Optional[builtins.bool] = None,
+        node_options: typing.Optional[typing.Sequence[typing.Union["NodeOptions", typing.Dict[builtins.str, typing.Any]]]] = None,
         warm_instance_type: typing.Optional[builtins.str] = None,
         warm_nodes: typing.Optional[jsii.Number] = None,
     ) -> None:
@@ -770,6 +798,7 @@ class CapacityConfig:
         :param master_node_instance_type: The hardware configuration of the computer that hosts the dedicated master node, such as ``m3.medium.search``. For valid values, see `Supported Instance Types <https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-instance-types.html>`_ in the Amazon OpenSearch Service Developer Guide. Default: - r5.large.search
         :param master_nodes: The number of instances to use for the master node. Default: - no dedicated master nodes
         :param multi_az_with_standby_enabled: Indicates whether Multi-AZ with Standby deployment option is enabled. For more information, see `Multi-AZ with Standby <https://docs.aws.amazon.com/opensearch-service/latest/developerguide/managedomains-multiaz.html#managedomains-za-standby>`_ Default: - multi-az with standby if the feature flag ``ENABLE_OPENSEARCH_MULTIAZ_WITH_STANDBY`` is true, no multi-az with standby otherwise
+        :param node_options: Additional node options for the domain. Default: - no additional node options
         :param warm_instance_type: The instance type for your UltraWarm node, such as ``ultrawarm1.medium.search``. For valid values, see `UltraWarm Storage Limits <https://docs.aws.amazon.com/opensearch-service/latest/developerguide/limits.html#limits-ultrawarm>`_ in the Amazon OpenSearch Service Developer Guide. Default: - ultrawarm1.medium.search
         :param warm_nodes: The number of UltraWarm nodes (instances) to use in the Amazon OpenSearch Service domain. Default: - no UltraWarm nodes
 
@@ -794,6 +823,7 @@ class CapacityConfig:
             check_type(argname="argument master_node_instance_type", value=master_node_instance_type, expected_type=type_hints["master_node_instance_type"])
             check_type(argname="argument master_nodes", value=master_nodes, expected_type=type_hints["master_nodes"])
             check_type(argname="argument multi_az_with_standby_enabled", value=multi_az_with_standby_enabled, expected_type=type_hints["multi_az_with_standby_enabled"])
+            check_type(argname="argument node_options", value=node_options, expected_type=type_hints["node_options"])
             check_type(argname="argument warm_instance_type", value=warm_instance_type, expected_type=type_hints["warm_instance_type"])
             check_type(argname="argument warm_nodes", value=warm_nodes, expected_type=type_hints["warm_nodes"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
@@ -807,6 +837,8 @@ class CapacityConfig:
             self._values["master_nodes"] = master_nodes
         if multi_az_with_standby_enabled is not None:
             self._values["multi_az_with_standby_enabled"] = multi_az_with_standby_enabled
+        if node_options is not None:
+            self._values["node_options"] = node_options
         if warm_instance_type is not None:
             self._values["warm_instance_type"] = warm_instance_type
         if warm_nodes is not None:
@@ -863,6 +895,15 @@ class CapacityConfig:
         result = self._values.get("multi_az_with_standby_enabled")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def node_options(self) -> typing.Optional[typing.List["NodeOptions"]]:
+        '''Additional node options for the domain.
+
+        :default: - no additional node options
+        '''
+        result = self._values.get("node_options")
+        return typing.cast(typing.Optional[typing.List["NodeOptions"]], result)
+
     @builtins.property
     def warm_instance_type(self) -> typing.Optional[builtins.str]:
         '''The instance type for your UltraWarm node, such as ``ultrawarm1.medium.search``. For valid values, see `UltraWarm Storage Limits <https://docs.aws.amazon.com/opensearch-service/latest/developerguide/limits.html#limits-ultrawarm>`_ in the Amazon OpenSearch Service Developer Guide.
@@ -8419,6 +8460,204 @@ class LoggingOptions:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_opensearchservice.NodeConfig",
+    jsii_struct_bases=[],
+    name_mapping={"count": "count", "enabled": "enabled", "type": "type"},
+)
+class NodeConfig:
+    def __init__(
+        self,
+        *,
+        count: typing.Optional[jsii.Number] = None,
+        enabled: typing.Optional[builtins.bool] = None,
+        type: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Configuration for a specific node type in OpenSearch domain.
+
+        :param count: The number of nodes of this type. Default: - 1
+        :param enabled: Whether this node type is enabled. Default: - false
+        :param type: The instance type for the nodes. Default: - m5.large.search
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_opensearchservice as opensearch
+            
+            
+            domain = Domain(self, "Domain",
+                version=EngineVersion.OPENSEARCH_1_3,
+                capacity=opensearch.CapacityConfig(
+                    node_options=[opensearch.NodeOptions(
+                        node_type=opensearch.NodeType.COORDINATOR,
+                        node_config=opensearch.NodeConfig(
+                            enabled=True,
+                            count=2,
+                            type="m5.large.search"
+                        )
+                    )
+                    ]
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__9d92d70efc2a427615d6de37a81d3ff2c726d0fd24398a9df21354f08be99abc)
+            check_type(argname="argument count", value=count, expected_type=type_hints["count"])
+            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
+            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if count is not None:
+            self._values["count"] = count
+        if enabled is not None:
+            self._values["enabled"] = enabled
+        if type is not None:
+            self._values["type"] = type
+
+    @builtins.property
+    def count(self) -> typing.Optional[jsii.Number]:
+        '''The number of nodes of this type.
+
+        :default: - 1
+        '''
+        result = self._values.get("count")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def enabled(self) -> typing.Optional[builtins.bool]:
+        '''Whether this node type is enabled.
+
+        :default: - false
+        '''
+        result = self._values.get("enabled")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def type(self) -> typing.Optional[builtins.str]:
+        '''The instance type for the nodes.
+
+        :default: - m5.large.search
+        '''
+        result = self._values.get("type")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "NodeConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_opensearchservice.NodeOptions",
+    jsii_struct_bases=[],
+    name_mapping={"node_config": "nodeConfig", "node_type": "nodeType"},
+)
+class NodeOptions:
+    def __init__(
+        self,
+        *,
+        node_config: typing.Union[NodeConfig, typing.Dict[builtins.str, typing.Any]],
+        node_type: "NodeType",
+    ) -> None:
+        '''Configuration for node options in OpenSearch domain.
+
+        :param node_config: Configuration for the node type.
+        :param node_type: The type of node. Currently only 'coordinator' is supported.
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_opensearchservice as opensearchservice
+            
+            node_options = opensearchservice.NodeOptions(
+                node_config=opensearchservice.NodeConfig(
+                    count=123,
+                    enabled=False,
+                    type="type"
+                ),
+                node_type=opensearchservice.NodeType.COORDINATOR
+            )
+        '''
+        if isinstance(node_config, dict):
+            node_config = NodeConfig(**node_config)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__3d93a945029ecbafb99f19123588beaba83f5fe71312bf7447834a1f6fa42c42)
+            check_type(argname="argument node_config", value=node_config, expected_type=type_hints["node_config"])
+            check_type(argname="argument node_type", value=node_type, expected_type=type_hints["node_type"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "node_config": node_config,
+            "node_type": node_type,
+        }
+
+    @builtins.property
+    def node_config(self) -> NodeConfig:
+        '''Configuration for the node type.'''
+        result = self._values.get("node_config")
+        assert result is not None, "Required property 'node_config' is missing"
+        return typing.cast(NodeConfig, result)
+
+    @builtins.property
+    def node_type(self) -> "NodeType":
+        '''The type of node.
+
+        Currently only 'coordinator' is supported.
+        '''
+        result = self._values.get("node_type")
+        assert result is not None, "Required property 'node_type' is missing"
+        return typing.cast("NodeType", result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "NodeOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_opensearchservice.NodeType")
+class NodeType(enum.Enum):
+    '''NodeType is a string enum of the node types in OpenSearch domain.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_opensearchservice as opensearch
+        
+        
+        domain = Domain(self, "Domain",
+            version=EngineVersion.OPENSEARCH_1_3,
+            capacity=opensearch.CapacityConfig(
+                node_options=[opensearch.NodeOptions(
+                    node_type=opensearch.NodeType.COORDINATOR,
+                    node_config=opensearch.NodeConfig(
+                        enabled=True,
+                        count=2,
+                        type="m5.large.search"
+                    )
+                )
+                ]
+            )
+        )
+    '''
+
+    COORDINATOR = "COORDINATOR"
+    '''Coordinator node type.'''
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_opensearchservice.SAMLOptionsProperty",
     jsii_struct_bases=[],
@@ -9889,6 +10128,9 @@ __all__ = [
     "IDomain",
     "IpAddressType",
     "LoggingOptions",
+    "NodeConfig",
+    "NodeOptions",
+    "NodeType",
     "SAMLOptionsProperty",
     "TLSSecurityPolicy",
     "WindowStartTime",
@@ -9915,6 +10157,7 @@ def _typecheckingstub__48cdec23c4ecd3d168ddd937e9295b924cdea583f9951d98aacce1c1c
     master_node_instance_type: typing.Optional[builtins.str] = None,
     master_nodes: typing.Optional[jsii.Number] = None,
     multi_az_with_standby_enabled: typing.Optional[builtins.bool] = None,
+    node_options: typing.Optional[typing.Sequence[typing.Union[NodeOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
     warm_instance_type: typing.Optional[builtins.str] = None,
     warm_nodes: typing.Optional[jsii.Number] = None,
 ) -> None:
@@ -10625,6 +10868,23 @@ def _typecheckingstub__6f2efbcf1fc757504a748851740a44deb59ed98ee9c1d8c213d60960f
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__9d92d70efc2a427615d6de37a81d3ff2c726d0fd24398a9df21354f08be99abc(
+    *,
+    count: typing.Optional[jsii.Number] = None,
+    enabled: typing.Optional[builtins.bool] = None,
+    type: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__3d93a945029ecbafb99f19123588beaba83f5fe71312bf7447834a1f6fa42c42(
+    *,
+    node_config: typing.Union[NodeConfig, typing.Dict[builtins.str, typing.Any]],
+    node_type: NodeType,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__3971b3c73627d57587c667b1ede64fbba4de4fd4a086af959dc2d0f812f8e36b(
     *,
     idp_entity_id: builtins.str,

aws_cdk/aws_pcaconnectorad/__init__.py

@@ -102,7 +102,10 @@ class CfnConnector(
             certificate_authority_arn="certificateAuthorityArn",
             directory_id="directoryId",
             vpc_information=pcaconnectorad.CfnConnector.VpcInformationProperty(
-                security_group_ids=["securityGroupIds"]
+                security_group_ids=["securityGroupIds"],
+        
+                # the properties below are optional
+                ip_address_type="ipAddressType"
             ),
         
             # the properties below are optional
@@ -256,17 +259,22 @@ class CfnConnector(
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_pcaconnectorad.CfnConnector.VpcInformationProperty",
         jsii_struct_bases=[],
-        name_mapping={"security_group_ids": "securityGroupIds"},
+        name_mapping={
+            "security_group_ids": "securityGroupIds",
+            "ip_address_type": "ipAddressType",
+        },
     )
     class VpcInformationProperty:
         def __init__(
             self,
             *,
             security_group_ids: typing.Sequence[builtins.str],
+            ip_address_type: typing.Optional[builtins.str] = None,
         ) -> None:
             '''Information about your VPC and security groups used with the connector.
 
             :param security_group_ids: The security groups used with the connector. You can use a maximum of 4 security groups with a connector.
+            :param ip_address_type: 
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-pcaconnectorad-connector-vpcinformation.html
             :exampleMetadata: fixture=_generated
@@ -278,15 +286,21 @@ class CfnConnector(
                 from aws_cdk import aws_pcaconnectorad as pcaconnectorad
                 
                 vpc_information_property = pcaconnectorad.CfnConnector.VpcInformationProperty(
-                    security_group_ids=["securityGroupIds"]
+                    security_group_ids=["securityGroupIds"],
+                
+                    # the properties below are optional
+                    ip_address_type="ipAddressType"
                 )
             '''
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__8b9f29305eaa60cc155622de83a9fdb695e29e88cecf7960456609a9a375b153)
                 check_type(argname="argument security_group_ids", value=security_group_ids, expected_type=type_hints["security_group_ids"])
+                check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
                 "security_group_ids": security_group_ids,
             }
+            if ip_address_type is not None:
+                self._values["ip_address_type"] = ip_address_type
 
         @builtins.property
         def security_group_ids(self) -> typing.List[builtins.str]:
@@ -300,6 +314,14 @@ class CfnConnector(
             assert result is not None, "Required property 'security_group_ids' is missing"
             return typing.cast(typing.List[builtins.str], result)
 
+        @builtins.property
+        def ip_address_type(self) -> typing.Optional[builtins.str]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-pcaconnectorad-connector-vpcinformation.html#cfn-pcaconnectorad-connector-vpcinformation-ipaddresstype
+            '''
+            result = self._values.get("ip_address_type")
+            return typing.cast(typing.Optional[builtins.str], result)
+
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -351,7 +373,10 @@ class CfnConnectorProps:
                 certificate_authority_arn="certificateAuthorityArn",
                 directory_id="directoryId",
                 vpc_information=pcaconnectorad.CfnConnector.VpcInformationProperty(
-                    security_group_ids=["securityGroupIds"]
+                    security_group_ids=["securityGroupIds"],
+            
+                    # the properties below are optional
+                    ip_address_type="ipAddressType"
                 ),
             
                 # the properties below are optional
@@ -6285,6 +6310,7 @@ def _typecheckingstub__c6278c4b97c0032befb9608a0699c8b6bccf6e756f23518e9cd72e345
 def _typecheckingstub__8b9f29305eaa60cc155622de83a9fdb695e29e88cecf7960456609a9a375b153(
     *,
     security_group_ids: typing.Sequence[builtins.str],
+    ip_address_type: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass

aws_cdk/aws_pipes/__init__.py

@@ -4807,7 +4807,7 @@ class CfnPipe(
             '''The parameters for using an CloudWatch Logs log stream as a target.
 
             :param log_stream_name: The name of the log stream.
-            :param timestamp: The time the event occurred, expressed as the number of milliseconds after Jan 1, 1970 00:00:00 UTC.
+            :param timestamp: A `dynamic path parameter <https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-pipes-event-target.html>`_ to a field in the payload containing the time the event occurred, expressed as the number of milliseconds after Jan 1, 1970 00:00:00 UTC. The value cannot be a static timestamp as the provided timestamp would be applied to all events delivered by the Pipe, regardless of when they are actually delivered. If no dynamic path parameter is provided, the default value is the time the invocation is processed by the Pipe.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-pipes-pipe-pipetargetcloudwatchlogsparameters.html
             :exampleMetadata: fixture=_generated
@@ -4844,7 +4844,11 @@ class CfnPipe(
 
         @builtins.property
         def timestamp(self) -> typing.Optional[builtins.str]:
-            '''The time the event occurred, expressed as the number of milliseconds after Jan 1, 1970 00:00:00 UTC.
+            '''A `dynamic path parameter <https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-pipes-event-target.html>`_ to a field in the payload containing the time the event occurred, expressed as the number of milliseconds after Jan 1, 1970 00:00:00 UTC.
+
+            The value cannot be a static timestamp as the provided timestamp would be applied to all events delivered by the Pipe, regardless of when they are actually delivered.
+
+            If no dynamic path parameter is provided, the default value is the time the invocation is processed by the Pipe.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-pipes-pipe-pipetargetcloudwatchlogsparameters.html#cfn-pipes-pipe-pipetargetcloudwatchlogsparameters-timestamp
             '''