aws-cdk-lib 2.172.0__py3-none-any.whl → 2.173.1__py3-none-any.whl

aws_cdk/aws_events/__init__.py

@@ -1576,6 +1576,8 @@ class CfnConnection(
 
     A connection defines the authorization type and credentials to use for authorization with an API destination HTTP endpoint.
 
+    For more information, see `Connections for endpoint targets <https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-target-connection.html>`_ in the *Amazon EventBridge User Guide* .
+
     :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-connection.html
     :cloudformationResource: AWS::Events::Connection
     :exampleMetadata: fixture=_generated
@@ -1690,7 +1692,7 @@ class CfnConnection(
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param authorization_type: The type of authorization to use for the connection. .. epigraph:: OAUTH tokens are refreshed when a 401 or 407 response is returned.
-        :param auth_parameters: A ``CreateConnectionAuthRequestParameters`` object that contains the authorization parameters to use to authorize with the endpoint.
+        :param auth_parameters: The authorization parameters to use to authorize with the endpoint. You must include only authorization parameters for the ``AuthorizationType`` you specify.
         :param description: A description for the connection to create.
         :param invocation_connectivity_parameters: The private resource the HTTP request will be sent to.
         :param name: The name for the connection to create.
@@ -1753,7 +1755,10 @@ class CfnConnection(
     def attr_auth_parameters_connectivity_parameters_resource_parameters_resource_association_arn(
         self,
     ) -> builtins.str:
-        '''
+        '''For connections to private APIs, the Amazon Resource Name (ARN) of the resource association EventBridge created between the connection and the private API's resource configuration.
+
+        For more information, see `Managing service network resource associations for connections <https://docs.aws.amazon.com/eventbridge/latest/userguide/connection-private.html#connection-private-snra>`_ in the **Amazon EventBridge User Guide** .
+
         :cloudformationAttribute: AuthParameters.ConnectivityParameters.ResourceParameters.ResourceAssociationArn
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrAuthParametersConnectivityParametersResourceParametersResourceAssociationArn"))
@@ -1763,7 +1768,10 @@ class CfnConnection(
     def attr_invocation_connectivity_parameters_resource_parameters_resource_association_arn(
         self,
     ) -> builtins.str:
-        '''
+        '''For connections to private APIs, the Amazon Resource Name (ARN) of the resource association EventBridge created between the connection and the private API's resource configuration.
+
+        For more information, see `Managing service network resource associations for connections <https://docs.aws.amazon.com/eventbridge/latest/userguide/connection-private.html#connection-private-snra>`_ in the **Amazon EventBridge User Guide** .
+
         :cloudformationAttribute: InvocationConnectivityParameters.ResourceParameters.ResourceAssociationArn
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrInvocationConnectivityParametersResourceParametersResourceAssociationArn"))
@@ -1800,7 +1808,7 @@ class CfnConnection(
     def auth_parameters(
         self,
     ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnConnection.AuthParametersProperty"]]:
-        '''A ``CreateConnectionAuthRequestParameters`` object that contains the authorization parameters to use to authorize with the endpoint.'''
+        '''The authorization parameters to use to authorize with the endpoint.'''
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnConnection.AuthParametersProperty"]], jsii.get(self, "authParameters"))
 
     @auth_parameters.setter
@@ -1869,7 +1877,7 @@ class CfnConnection(
             api_key_name: builtins.str,
             api_key_value: builtins.str,
         ) -> None:
-            '''Contains the API key authorization parameters for the connection.
+            '''The API key authorization parameters for the connection.
 
             :param api_key_name: The name of the API key to use for authorization.
             :param api_key_value: The value for the API key to use for authorization.
@@ -1949,7 +1957,7 @@ class CfnConnection(
             invocation_http_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnConnection.ConnectionHttpParametersProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             o_auth_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnConnection.OAuthParametersProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         ) -> None:
-            '''Contains the authorization parameters to use for the connection.
+            '''Tthe authorization parameters to use for the connection.
 
             :param api_key_auth_parameters: The API Key parameters to use for authorization.
             :param basic_auth_parameters: The authorization parameters for Basic authorization.
@@ -2132,7 +2140,7 @@ class CfnConnection(
     )
     class BasicAuthParametersProperty:
         def __init__(self, *, password: builtins.str, username: builtins.str) -> None:
-            '''Contains the Basic authorization parameters for the connection.
+            '''The Basic authorization parameters for the connection.
 
             :param password: The password associated with the user name to use for Basic authorization.
             :param username: The user name to use for Basic authorization.
@@ -2203,7 +2211,7 @@ class CfnConnection(
             client_id: builtins.str,
             client_secret: builtins.str,
         ) -> None:
-            '''Contains the OAuth authorization parameters to use for the connection.
+            '''The OAuth authorization parameters to use for the connection.
 
             :param client_id: The client ID to use for OAuth authorization.
             :param client_secret: The client secret assciated with the client ID to use for OAuth authorization.
@@ -2279,11 +2287,11 @@ class CfnConnection(
             header_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnConnection.ParameterProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             query_string_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnConnection.ParameterProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         ) -> None:
-            '''Contains additional parameters for the connection.
+            '''Any additional parameters for the connection.
 
-            :param body_parameters: Contains additional body string parameters for the connection.
-            :param header_parameters: Contains additional header parameters for the connection.
-            :param query_string_parameters: Contains additional query string parameters for the connection.
+            :param body_parameters: Any additional body string parameters for the connection.
+            :param header_parameters: Any additional header parameters for the connection.
+            :param query_string_parameters: Any additional query string parameters for the connection.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-connectionhttpparameters.html
             :exampleMetadata: fixture=_generated
@@ -2335,7 +2343,7 @@ class CfnConnection(
         def body_parameters(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnConnection.ParameterProperty"]]]]:
-            '''Contains additional body string parameters for the connection.
+            '''Any additional body string parameters for the connection.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-connectionhttpparameters.html#cfn-events-connection-connectionhttpparameters-bodyparameters
             '''
@@ -2346,7 +2354,7 @@ class CfnConnection(
         def header_parameters(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnConnection.ParameterProperty"]]]]:
-            '''Contains additional header parameters for the connection.
+            '''Any additional header parameters for the connection.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-connectionhttpparameters.html#cfn-events-connection-connectionhttpparameters-headerparameters
             '''
@@ -2357,7 +2365,7 @@ class CfnConnection(
         def query_string_parameters(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnConnection.ParameterProperty"]]]]:
-            '''Contains additional query string parameters for the connection.
+            '''Any additional query string parameters for the connection.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-connectionhttpparameters.html#cfn-events-connection-connectionhttpparameters-querystringparameters
             '''
@@ -2520,9 +2528,9 @@ class CfnConnection(
             '''Contains the OAuth authorization parameters to use for the connection.
 
             :param authorization_endpoint: The URL to the authorization endpoint when OAuth is specified as the authorization type.
-            :param client_parameters: A ``CreateConnectionOAuthClientRequestParameters`` object that contains the client parameters for OAuth authorization.
+            :param client_parameters: The client parameters for OAuth authorization.
             :param http_method: The method to use for the authorization request.
-            :param o_auth_http_parameters: A ``ConnectionHttpParameters`` object that contains details about the additional parameters to use for the connection.
+            :param o_auth_http_parameters: Details about the additional parameters to use for the connection.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-oauthparameters.html
             :exampleMetadata: fixture=_generated
@@ -2595,7 +2603,7 @@ class CfnConnection(
         def client_parameters(
             self,
         ) -> typing.Union[_IResolvable_da3f097b, "CfnConnection.ClientParametersProperty"]:
-            '''A ``CreateConnectionOAuthClientRequestParameters`` object that contains the client parameters for OAuth authorization.
+            '''The client parameters for OAuth authorization.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-oauthparameters.html#cfn-events-connection-oauthparameters-clientparameters
             '''
@@ -2617,7 +2625,7 @@ class CfnConnection(
         def o_auth_http_parameters(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnConnection.ConnectionHttpParametersProperty"]]:
-            '''A ``ConnectionHttpParameters`` object that contains details about the additional parameters to use for the connection.
+            '''Details about the additional parameters to use for the connection.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-oauthparameters.html#cfn-events-connection-oauthparameters-oauthhttpparameters
             '''
@@ -2652,7 +2660,7 @@ class CfnConnection(
             value: builtins.str,
             is_value_secret: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         ) -> None:
-            '''Additional query string parameter for the connection.
+            '''Any additional query string parameter for the connection.
 
             You can include up to 100 additional query string parameters per request. Each additional parameter counts towards the event payload size, which cannot exceed 64 KB.
 
@@ -2750,7 +2758,7 @@ class CfnConnection(
         ) -> None:
             '''
             :param resource_configuration_arn: 
-            :param resource_association_arn: 
+            :param resource_association_arn: For connections to private APIs, the Amazon Resource Name (ARN) of the resource association EventBridge created between the connection and the private API's resource configuration. For more information, see `Managing service network resource associations for connections <https://docs.aws.amazon.com/eventbridge/latest/userguide/connection-private.html#connection-private-snra>`_ in the **Amazon EventBridge User Guide** .
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-resourceparameters.html
             :exampleMetadata: fixture=_generated
@@ -2789,7 +2797,10 @@ class CfnConnection(
 
         @builtins.property
         def resource_association_arn(self) -> typing.Optional[builtins.str]:
-            '''
+            '''For connections to private APIs, the Amazon Resource Name (ARN) of the resource association EventBridge created between the connection and the private API's resource configuration.
+
+            For more information, see `Managing service network resource associations for connections <https://docs.aws.amazon.com/eventbridge/latest/userguide/connection-private.html#connection-private-snra>`_ in the **Amazon EventBridge User Guide** .
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-resourceparameters.html#cfn-events-connection-resourceparameters-resourceassociationarn
             '''
             result = self._values.get("resource_association_arn")
@@ -2831,7 +2842,7 @@ class CfnConnectionProps:
         '''Properties for defining a ``CfnConnection``.
 
         :param authorization_type: The type of authorization to use for the connection. .. epigraph:: OAUTH tokens are refreshed when a 401 or 407 response is returned.
-        :param auth_parameters: A ``CreateConnectionAuthRequestParameters`` object that contains the authorization parameters to use to authorize with the endpoint.
+        :param auth_parameters: The authorization parameters to use to authorize with the endpoint. You must include only authorization parameters for the ``AuthorizationType`` you specify.
         :param description: A description for the connection to create.
         :param invocation_connectivity_parameters: The private resource the HTTP request will be sent to.
         :param name: The name for the connection to create.
@@ -2969,7 +2980,9 @@ class CfnConnectionProps:
     def auth_parameters(
         self,
     ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnConnection.AuthParametersProperty]]:
-        '''A ``CreateConnectionAuthRequestParameters`` object that contains the authorization parameters to use to authorize with the endpoint.
+        '''The authorization parameters to use to authorize with the endpoint.
+
+        You must include only authorization parameters for the ``AuthorizationType`` you specify.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-connection.html#cfn-events-connection-authparameters
         '''
@@ -7186,7 +7199,7 @@ class CfnRule(
             :param input_transformer: Settings to enable you to provide custom input to a target based on certain event data. You can extract one or more key-value pairs from the event and then use that data to send customized input to the target.
             :param kinesis_parameters: The custom parameter you can use to control the shard assignment, when the target is a Kinesis data stream. If you do not include this parameter, the default is to use the ``eventId`` as the partition key.
             :param redshift_data_parameters: Contains the Amazon Redshift Data API parameters to use when the target is a Amazon Redshift cluster. If you specify a Amazon Redshift Cluster as a Target, you can use this to specify parameters to invoke the Amazon Redshift Data API ExecuteStatement based on EventBridge events.
-            :param retry_policy: The ``RetryPolicy`` object that contains the retry policy configuration to use for the dead-letter queue.
+            :param retry_policy: The retry policy configuration to use for the dead-letter queue.
             :param role_arn: The Amazon Resource Name (ARN) of the IAM role to be used for this target when the rule is triggered. If one rule triggers multiple targets, you can use a different IAM role for each target.
             :param run_command_parameters: Parameters used when you are using the rule to invoke Amazon EC2 Run Command.
             :param sage_maker_pipeline_parameters: Contains the SageMaker Model Building Pipeline parameters to start execution of a SageMaker Model Building Pipeline. If you specify a SageMaker Model Building Pipeline as a target, you can use this to specify parameters to start a pipeline execution based on EventBridge events.
@@ -7522,7 +7535,7 @@ class CfnRule(
         def retry_policy(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRule.RetryPolicyProperty"]]:
-            '''The ``RetryPolicy`` object that contains the retry policy configuration to use for the dead-letter queue.
+            '''The retry policy configuration to use for the dead-letter queue.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-target.html#cfn-events-rule-target-retrypolicy
             '''

aws_cdk/aws_fsx/__init__.py

@@ -1026,6 +1026,7 @@ class CfnFileSystem(
                 data_compression_type="dataCompressionType",
                 deployment_type="deploymentType",
                 drive_cache_type="driveCacheType",
+                efa_enabled=False,
                 export_path="exportPath",
                 imported_file_chunk_size=123,
                 import_path="importPath",
@@ -1070,6 +1071,10 @@ class CfnFileSystem(
                 endpoint_ip_address_range="endpointIpAddressRange",
                 options=["options"],
                 preferred_subnet_id="preferredSubnetId",
+                read_cache_configuration=fsx.CfnFileSystem.ReadCacheConfigurationProperty(
+                    size_gi_b=123,
+                    sizing_mode="sizingMode"
+                ),
                 root_volume_configuration=fsx.CfnFileSystem.RootVolumeConfigurationProperty(
                     copy_tags_to_snapshots=False,
                     data_compression_type="dataCompressionType",
@@ -1165,7 +1170,7 @@ class CfnFileSystem(
         :param open_zfs_configuration: The Amazon FSx for OpenZFS configuration properties for the file system that you are creating.
         :param security_group_ids: A list of IDs specifying the security groups to apply to all network interfaces created for file system access. This list isn't returned in later requests to describe the file system. .. epigraph:: You must specify a security group if you are creating a Multi-AZ FSx for ONTAP file system in a VPC subnet that has been shared with you.
         :param storage_capacity: Sets the storage capacity of the file system that you're creating. ``StorageCapacity`` is required if you are creating a new file system. It is not required if you are creating a file system by restoring a backup. *FSx for Lustre file systems* - The amount of storage capacity that you can configure depends on the value that you set for ``StorageType`` and the Lustre ``DeploymentType`` , as follows: - For ``SCRATCH_2`` , ``PERSISTENT_2`` and ``PERSISTENT_1`` deployment types using SSD storage type, the valid values are 1200 GiB, 2400 GiB, and increments of 2400 GiB. - For ``PERSISTENT_1`` HDD file systems, valid values are increments of 6000 GiB for 12 MB/s/TiB file systems and increments of 1800 GiB for 40 MB/s/TiB file systems. - For ``SCRATCH_1`` deployment type, valid values are 1200 GiB, 2400 GiB, and increments of 3600 GiB. *FSx for ONTAP file systems* - The amount of SSD storage capacity that you can configure depends on the value of the ``HAPairs`` property. The minimum value is calculated as 1,024 GiB * HAPairs and the maximum is calculated as 524,288 GiB * HAPairs, up to a maximum amount of SSD storage capacity of 1,048,576 GiB (1 pebibyte). *FSx for OpenZFS file systems* - The amount of storage capacity that you can configure is from 64 GiB up to 524,288 GiB (512 TiB). If you are creating a file system from a backup, you can specify a storage capacity equal to or greater than the original file system's storage capacity. *FSx for Windows File Server file systems* - The amount of storage capacity that you can configure depends on the value that you set for ``StorageType`` as follows: - For SSD storage, valid values are 32 GiB-65,536 GiB (64 TiB). - For HDD storage, valid values are 2000 GiB-65,536 GiB (64 TiB).
-        :param storage_type: Sets the storage type for the file system that you're creating. Valid values are ``SSD`` and ``HDD`` . - Set to ``SSD`` to use solid state drive storage. SSD is supported on all Windows, Lustre, ONTAP, and OpenZFS deployment types. - Set to ``HDD`` to use hard disk drive storage. HDD is supported on ``SINGLE_AZ_2`` and ``MULTI_AZ_1`` Windows file system deployment types, and on ``PERSISTENT_1`` Lustre file system deployment types. Default value is ``SSD`` . For more information, see `Storage type options <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/optimize-fsx-costs.html#storage-type-options>`_ in the *FSx for Windows File Server User Guide* and `Multiple storage options <https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html#storage-options>`_ in the *FSx for Lustre User Guide* .
+        :param storage_type: Sets the storage class for the file system that you're creating. Valid values are ``SSD`` , ``HDD`` , and ``INTELLIGENT_TIERING`` . - Set to ``SSD`` to use solid state drive storage. SSD is supported on all Windows, Lustre, ONTAP, and OpenZFS deployment types. - Set to ``HDD`` to use hard disk drive storage. HDD is supported on ``SINGLE_AZ_2`` and ``MULTI_AZ_1`` Windows file system deployment types, and on ``PERSISTENT_1`` Lustre file system deployment types. - Set to ``INTELLIGENT_TIERING`` to use fully elastic, intelligently-tiered storage. Intelligent-Tiering is only available for OpenZFS file systems with the Multi-AZ deployment type. Default value is ``SSD`` . For more information, see `Storage type options <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/optimize-fsx-costs.html#storage-type-options>`_ in the *FSx for Windows File Server User Guide* , `Multiple storage options <https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html#storage-options>`_ in the *FSx for Lustre User Guide* , and `Working with Intelligent-Tiering <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/performance-intelligent-tiering>`_ in the *Amazon FSx for OpenZFS User Guide* .
         :param tags: The tags to associate with the file system. For more information, see `Tagging your Amazon FSx resources <https://docs.aws.amazon.com/fsx/latest/LustreGuide/tag-resources.html>`_ in the *Amazon FSx for Lustre User Guide* .
         :param windows_configuration: The configuration object for the Microsoft Windows file system you are creating. This value is required if ``FileSystemType`` is set to ``WINDOWS`` .
         '''
@@ -1437,10 +1442,7 @@ class CfnFileSystem(
     @builtins.property
     @jsii.member(jsii_name="storageType")
     def storage_type(self) -> typing.Optional[builtins.str]:
-        '''Sets the storage type for the file system that you're creating.
-
-        Valid values are ``SSD`` and ``HDD`` .
-        '''
+        '''Sets the storage class for the file system that you're creating.'''
         return typing.cast(typing.Optional[builtins.str], jsii.get(self, "storageType"))
 
     @storage_type.setter
@@ -1753,6 +1755,7 @@ class CfnFileSystem(
             "data_compression_type": "dataCompressionType",
             "deployment_type": "deploymentType",
             "drive_cache_type": "driveCacheType",
+            "efa_enabled": "efaEnabled",
             "export_path": "exportPath",
             "imported_file_chunk_size": "importedFileChunkSize",
             "import_path": "importPath",
@@ -1772,6 +1775,7 @@ class CfnFileSystem(
             data_compression_type: typing.Optional[builtins.str] = None,
             deployment_type: typing.Optional[builtins.str] = None,
             drive_cache_type: typing.Optional[builtins.str] = None,
+            efa_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             export_path: typing.Optional[builtins.str] = None,
             imported_file_chunk_size: typing.Optional[jsii.Number] = None,
             import_path: typing.Optional[builtins.str] = None,
@@ -1788,6 +1792,7 @@ class CfnFileSystem(
             :param data_compression_type: Sets the data compression configuration for the file system. ``DataCompressionType`` can have the following values:. - ``NONE`` - (Default) Data compression is turned off when the file system is created. - ``LZ4`` - Data compression is turned on with the LZ4 algorithm. For more information, see `Lustre data compression <https://docs.aws.amazon.com/fsx/latest/LustreGuide/data-compression.html>`_ in the *Amazon FSx for Lustre User Guide* .
             :param deployment_type: (Optional) Choose ``SCRATCH_1`` and ``SCRATCH_2`` deployment types when you need temporary storage and shorter-term processing of data. The ``SCRATCH_2`` deployment type provides in-transit encryption of data and higher burst throughput capacity than ``SCRATCH_1`` . Choose ``PERSISTENT_1`` for longer-term storage and for throughput-focused workloads that aren’t latency-sensitive. ``PERSISTENT_1`` supports encryption of data in transit, and is available in all AWS Regions in which FSx for Lustre is available. Choose ``PERSISTENT_2`` for longer-term storage and for latency-sensitive workloads that require the highest levels of IOPS/throughput. ``PERSISTENT_2`` supports SSD storage, and offers higher ``PerUnitStorageThroughput`` (up to 1000 MB/s/TiB). You can optionally specify a metadata configuration mode for ``PERSISTENT_2`` which supports increasing metadata performance. ``PERSISTENT_2`` is available in a limited number of AWS Regions . For more information, and an up-to-date list of AWS Regions in which ``PERSISTENT_2`` is available, see `File system deployment options for FSx for Lustre <https://docs.aws.amazon.com/fsx/latest/LustreGuide/using-fsx-lustre.html#lustre-deployment-types>`_ in the *Amazon FSx for Lustre User Guide* . .. epigraph:: If you choose ``PERSISTENT_2`` , and you set ``FileSystemTypeVersion`` to ``2.10`` , the ``CreateFileSystem`` operation fails. Encryption of data in transit is automatically turned on when you access ``SCRATCH_2`` , ``PERSISTENT_1`` , and ``PERSISTENT_2`` file systems from Amazon EC2 instances that support automatic encryption in the AWS Regions where they are available. For more information about encryption in transit for FSx for Lustre file systems, see `Encrypting data in transit <https://docs.aws.amazon.com/fsx/latest/LustreGuide/encryption-in-transit-fsxl.html>`_ in the *Amazon FSx for Lustre User Guide* . (Default = ``SCRATCH_1`` )
             :param drive_cache_type: The type of drive cache used by ``PERSISTENT_1`` file systems that are provisioned with HDD storage devices. This parameter is required when storage type is HDD. Set this property to ``READ`` to improve the performance for frequently accessed files by caching up to 20% of the total storage capacity of the file system. This parameter is required when ``StorageType`` is set to ``HDD`` and ``DeploymentType`` is ``PERSISTENT_1`` .
+            :param efa_enabled: 
             :param export_path: (Optional) Specifies the path in the Amazon S3 bucket where the root of your Amazon FSx file system is exported. The path must use the same Amazon S3 bucket as specified in ImportPath. You can provide an optional prefix to which new and changed data is to be exported from your Amazon FSx for Lustre file system. If an ``ExportPath`` value is not provided, Amazon FSx sets a default export path, ``s3://import-bucket/FSxLustre[creation-timestamp]`` . The timestamp is in UTC format, for example ``s3://import-bucket/FSxLustre20181105T222312Z`` . The Amazon S3 export bucket must be the same as the import bucket specified by ``ImportPath`` . If you specify only a bucket name, such as ``s3://import-bucket`` , you get a 1:1 mapping of file system objects to S3 bucket objects. This mapping means that the input data in S3 is overwritten on export. If you provide a custom prefix in the export path, such as ``s3://import-bucket/[custom-optional-prefix]`` , Amazon FSx exports the contents of your file system to that export prefix in the Amazon S3 bucket. .. epigraph:: This parameter is not supported for file systems with a data repository association.
             :param imported_file_chunk_size: (Optional) For files imported from a data repository, this value determines the stripe count and maximum amount of data per file (in MiB) stored on a single physical disk. The maximum number of disks that a single file can be striped across is limited by the total number of disks that make up the file system. The default chunk size is 1,024 MiB (1 GiB) and can go as high as 512,000 MiB (500 GiB). Amazon S3 objects have a maximum size of 5 TB. .. epigraph:: This parameter is not supported for Lustre file systems with a data repository association.
             :param import_path: (Optional) The path to the Amazon S3 bucket (including the optional prefix) that you're using as the data repository for your Amazon FSx for Lustre file system. The root of your FSx for Lustre file system will be mapped to the root of the Amazon S3 bucket you select. An example is ``s3://import-bucket/optional-prefix`` . If you specify a prefix after the Amazon S3 bucket name, only object keys with that prefix are loaded into the file system. .. epigraph:: This parameter is not supported for Lustre file systems with a data repository association.
@@ -1812,6 +1817,7 @@ class CfnFileSystem(
                     data_compression_type="dataCompressionType",
                     deployment_type="deploymentType",
                     drive_cache_type="driveCacheType",
+                    efa_enabled=False,
                     export_path="exportPath",
                     imported_file_chunk_size=123,
                     import_path="importPath",
@@ -1832,6 +1838,7 @@ class CfnFileSystem(
                 check_type(argname="argument data_compression_type", value=data_compression_type, expected_type=type_hints["data_compression_type"])
                 check_type(argname="argument deployment_type", value=deployment_type, expected_type=type_hints["deployment_type"])
                 check_type(argname="argument drive_cache_type", value=drive_cache_type, expected_type=type_hints["drive_cache_type"])
+                check_type(argname="argument efa_enabled", value=efa_enabled, expected_type=type_hints["efa_enabled"])
                 check_type(argname="argument export_path", value=export_path, expected_type=type_hints["export_path"])
                 check_type(argname="argument imported_file_chunk_size", value=imported_file_chunk_size, expected_type=type_hints["imported_file_chunk_size"])
                 check_type(argname="argument import_path", value=import_path, expected_type=type_hints["import_path"])
@@ -1853,6 +1860,8 @@ class CfnFileSystem(
                 self._values["deployment_type"] = deployment_type
             if drive_cache_type is not None:
                 self._values["drive_cache_type"] = drive_cache_type
+            if efa_enabled is not None:
+                self._values["efa_enabled"] = efa_enabled
             if export_path is not None:
                 self._values["export_path"] = export_path
             if imported_file_chunk_size is not None:
@@ -1975,6 +1984,16 @@ class CfnFileSystem(
             result = self._values.get("drive_cache_type")
             return typing.cast(typing.Optional[builtins.str], result)
 
+        @builtins.property
+        def efa_enabled(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-filesystem-lustreconfiguration.html#cfn-fsx-filesystem-lustreconfiguration-efaenabled
+            '''
+            result = self._values.get("efa_enabled")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
         @builtins.property
         def export_path(self) -> typing.Optional[builtins.str]:
             '''(Optional) Specifies the path in the Amazon S3 bucket where the root of your Amazon FSx file system is exported.
@@ -2509,6 +2528,7 @@ class CfnFileSystem(
             "endpoint_ip_address_range": "endpointIpAddressRange",
             "options": "options",
             "preferred_subnet_id": "preferredSubnetId",
+            "read_cache_configuration": "readCacheConfiguration",
             "root_volume_configuration": "rootVolumeConfiguration",
             "route_table_ids": "routeTableIds",
             "throughput_capacity": "throughputCapacity",
@@ -2528,6 +2548,7 @@ class CfnFileSystem(
             endpoint_ip_address_range: typing.Optional[builtins.str] = None,
             options: typing.Optional[typing.Sequence[builtins.str]] = None,
             preferred_subnet_id: typing.Optional[builtins.str] = None,
+            read_cache_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFileSystem.ReadCacheConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             root_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnFileSystem.RootVolumeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
             throughput_capacity: typing.Optional[jsii.Number] = None,
@@ -2544,6 +2565,7 @@ class CfnFileSystem(
             :param endpoint_ip_address_range: (Multi-AZ only) Specifies the IP address range in which the endpoints to access your file system will be created. By default in the Amazon FSx API and Amazon FSx console, Amazon FSx selects an available /28 IP address range for you from one of the VPC's CIDR ranges. You can have overlapping endpoint IP addresses for file systems deployed in the same VPC/route tables.
             :param options: To delete a file system if there are child volumes present below the root volume, use the string ``DELETE_CHILD_VOLUMES_AND_SNAPSHOTS`` . If your file system has child volumes and you don't use this option, the delete request will fail.
             :param preferred_subnet_id: Required when ``DeploymentType`` is set to ``MULTI_AZ_1`` . This specifies the subnet in which you want the preferred file server to be located.
+            :param read_cache_configuration: 
             :param root_volume_configuration: The configuration Amazon FSx uses when creating the root value of the Amazon FSx for OpenZFS file system. All volumes are children of the root volume.
             :param route_table_ids: (Multi-AZ only) Specifies the route tables in which Amazon FSx creates the rules for routing traffic to the correct file server. You should specify all virtual private cloud (VPC) route tables associated with the subnets in which your clients are located. By default, Amazon FSx selects your VPC's default route table.
             :param throughput_capacity: Specifies the throughput of an Amazon FSx for OpenZFS file system, measured in megabytes per second (MBps). Valid values depend on the DeploymentType you choose, as follows: - For ``MULTI_AZ_1`` and ``SINGLE_AZ_2`` , valid values are 160, 320, 640, 1280, 2560, 3840, 5120, 7680, or 10240 MBps. - For ``SINGLE_AZ_1`` , valid values are 64, 128, 256, 512, 1024, 2048, 3072, or 4096 MBps. You pay for additional throughput capacity that you provision.
@@ -2573,6 +2595,10 @@ class CfnFileSystem(
                     endpoint_ip_address_range="endpointIpAddressRange",
                     options=["options"],
                     preferred_subnet_id="preferredSubnetId",
+                    read_cache_configuration=fsx.CfnFileSystem.ReadCacheConfigurationProperty(
+                        size_gi_b=123,
+                        sizing_mode="sizingMode"
+                    ),
                     root_volume_configuration=fsx.CfnFileSystem.RootVolumeConfigurationProperty(
                         copy_tags_to_snapshots=False,
                         data_compression_type="dataCompressionType",
@@ -2606,6 +2632,7 @@ class CfnFileSystem(
                 check_type(argname="argument endpoint_ip_address_range", value=endpoint_ip_address_range, expected_type=type_hints["endpoint_ip_address_range"])
                 check_type(argname="argument options", value=options, expected_type=type_hints["options"])
                 check_type(argname="argument preferred_subnet_id", value=preferred_subnet_id, expected_type=type_hints["preferred_subnet_id"])
+                check_type(argname="argument read_cache_configuration", value=read_cache_configuration, expected_type=type_hints["read_cache_configuration"])
                 check_type(argname="argument root_volume_configuration", value=root_volume_configuration, expected_type=type_hints["root_volume_configuration"])
                 check_type(argname="argument route_table_ids", value=route_table_ids, expected_type=type_hints["route_table_ids"])
                 check_type(argname="argument throughput_capacity", value=throughput_capacity, expected_type=type_hints["throughput_capacity"])
@@ -2629,6 +2656,8 @@ class CfnFileSystem(
                 self._values["options"] = options
             if preferred_subnet_id is not None:
                 self._values["preferred_subnet_id"] = preferred_subnet_id
+            if read_cache_configuration is not None:
+                self._values["read_cache_configuration"] = read_cache_configuration
             if root_volume_configuration is not None:
                 self._values["root_volume_configuration"] = root_volume_configuration
             if route_table_ids is not None:
@@ -2750,6 +2779,16 @@ class CfnFileSystem(
             result = self._values.get("preferred_subnet_id")
             return typing.cast(typing.Optional[builtins.str], result)
 
+        @builtins.property
+        def read_cache_configuration(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFileSystem.ReadCacheConfigurationProperty"]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-filesystem-openzfsconfiguration.html#cfn-fsx-filesystem-openzfsconfiguration-readcacheconfiguration
+            '''
+            result = self._values.get("read_cache_configuration")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnFileSystem.ReadCacheConfigurationProperty"]], result)
+
         @builtins.property
         def root_volume_configuration(
             self,
@@ -2816,6 +2855,73 @@ class CfnFileSystem(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_fsx.CfnFileSystem.ReadCacheConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"size_gib": "sizeGiB", "sizing_mode": "sizingMode"},
+    )
+    class ReadCacheConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            size_gib: typing.Optional[jsii.Number] = None,
+            sizing_mode: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''
+            :param size_gib: 
+            :param sizing_mode: 
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-filesystem-readcacheconfiguration.html
+            :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_fsx as fsx
+                
+                read_cache_configuration_property = fsx.CfnFileSystem.ReadCacheConfigurationProperty(
+                    size_gi_b=123,
+                    sizing_mode="sizingMode"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__5da424653f281066f7140c38ddd8b33a2fdb52a49e2f3ecfacac378ab1825ad9)
+                check_type(argname="argument size_gib", value=size_gib, expected_type=type_hints["size_gib"])
+                check_type(argname="argument sizing_mode", value=sizing_mode, expected_type=type_hints["sizing_mode"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if size_gib is not None:
+                self._values["size_gib"] = size_gib
+            if sizing_mode is not None:
+                self._values["sizing_mode"] = sizing_mode
+
+        @builtins.property
+        def size_gib(self) -> typing.Optional[jsii.Number]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-filesystem-readcacheconfiguration.html#cfn-fsx-filesystem-readcacheconfiguration-sizegib
+            '''
+            result = self._values.get("size_gib")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def sizing_mode(self) -> typing.Optional[builtins.str]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-filesystem-readcacheconfiguration.html#cfn-fsx-filesystem-readcacheconfiguration-sizingmode
+            '''
+            result = self._values.get("sizing_mode")
+            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 "ReadCacheConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_fsx.CfnFileSystem.RootVolumeConfigurationProperty",
         jsii_struct_bases=[],
@@ -3574,7 +3680,7 @@ class CfnFileSystemProps:
         :param open_zfs_configuration: The Amazon FSx for OpenZFS configuration properties for the file system that you are creating.
         :param security_group_ids: A list of IDs specifying the security groups to apply to all network interfaces created for file system access. This list isn't returned in later requests to describe the file system. .. epigraph:: You must specify a security group if you are creating a Multi-AZ FSx for ONTAP file system in a VPC subnet that has been shared with you.
         :param storage_capacity: Sets the storage capacity of the file system that you're creating. ``StorageCapacity`` is required if you are creating a new file system. It is not required if you are creating a file system by restoring a backup. *FSx for Lustre file systems* - The amount of storage capacity that you can configure depends on the value that you set for ``StorageType`` and the Lustre ``DeploymentType`` , as follows: - For ``SCRATCH_2`` , ``PERSISTENT_2`` and ``PERSISTENT_1`` deployment types using SSD storage type, the valid values are 1200 GiB, 2400 GiB, and increments of 2400 GiB. - For ``PERSISTENT_1`` HDD file systems, valid values are increments of 6000 GiB for 12 MB/s/TiB file systems and increments of 1800 GiB for 40 MB/s/TiB file systems. - For ``SCRATCH_1`` deployment type, valid values are 1200 GiB, 2400 GiB, and increments of 3600 GiB. *FSx for ONTAP file systems* - The amount of SSD storage capacity that you can configure depends on the value of the ``HAPairs`` property. The minimum value is calculated as 1,024 GiB * HAPairs and the maximum is calculated as 524,288 GiB * HAPairs, up to a maximum amount of SSD storage capacity of 1,048,576 GiB (1 pebibyte). *FSx for OpenZFS file systems* - The amount of storage capacity that you can configure is from 64 GiB up to 524,288 GiB (512 TiB). If you are creating a file system from a backup, you can specify a storage capacity equal to or greater than the original file system's storage capacity. *FSx for Windows File Server file systems* - The amount of storage capacity that you can configure depends on the value that you set for ``StorageType`` as follows: - For SSD storage, valid values are 32 GiB-65,536 GiB (64 TiB). - For HDD storage, valid values are 2000 GiB-65,536 GiB (64 TiB).
-        :param storage_type: Sets the storage type for the file system that you're creating. Valid values are ``SSD`` and ``HDD`` . - Set to ``SSD`` to use solid state drive storage. SSD is supported on all Windows, Lustre, ONTAP, and OpenZFS deployment types. - Set to ``HDD`` to use hard disk drive storage. HDD is supported on ``SINGLE_AZ_2`` and ``MULTI_AZ_1`` Windows file system deployment types, and on ``PERSISTENT_1`` Lustre file system deployment types. Default value is ``SSD`` . For more information, see `Storage type options <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/optimize-fsx-costs.html#storage-type-options>`_ in the *FSx for Windows File Server User Guide* and `Multiple storage options <https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html#storage-options>`_ in the *FSx for Lustre User Guide* .
+        :param storage_type: Sets the storage class for the file system that you're creating. Valid values are ``SSD`` , ``HDD`` , and ``INTELLIGENT_TIERING`` . - Set to ``SSD`` to use solid state drive storage. SSD is supported on all Windows, Lustre, ONTAP, and OpenZFS deployment types. - Set to ``HDD`` to use hard disk drive storage. HDD is supported on ``SINGLE_AZ_2`` and ``MULTI_AZ_1`` Windows file system deployment types, and on ``PERSISTENT_1`` Lustre file system deployment types. - Set to ``INTELLIGENT_TIERING`` to use fully elastic, intelligently-tiered storage. Intelligent-Tiering is only available for OpenZFS file systems with the Multi-AZ deployment type. Default value is ``SSD`` . For more information, see `Storage type options <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/optimize-fsx-costs.html#storage-type-options>`_ in the *FSx for Windows File Server User Guide* , `Multiple storage options <https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html#storage-options>`_ in the *FSx for Lustre User Guide* , and `Working with Intelligent-Tiering <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/performance-intelligent-tiering>`_ in the *Amazon FSx for OpenZFS User Guide* .
         :param tags: The tags to associate with the file system. For more information, see `Tagging your Amazon FSx resources <https://docs.aws.amazon.com/fsx/latest/LustreGuide/tag-resources.html>`_ in the *Amazon FSx for Lustre User Guide* .
         :param windows_configuration: The configuration object for the Microsoft Windows file system you are creating. This value is required if ``FileSystemType`` is set to ``WINDOWS`` .
 
@@ -3603,6 +3709,7 @@ class CfnFileSystemProps:
                     data_compression_type="dataCompressionType",
                     deployment_type="deploymentType",
                     drive_cache_type="driveCacheType",
+                    efa_enabled=False,
                     export_path="exportPath",
                     imported_file_chunk_size=123,
                     import_path="importPath",
@@ -3647,6 +3754,10 @@ class CfnFileSystemProps:
                     endpoint_ip_address_range="endpointIpAddressRange",
                     options=["options"],
                     preferred_subnet_id="preferredSubnetId",
+                    read_cache_configuration=fsx.CfnFileSystem.ReadCacheConfigurationProperty(
+                        size_gi_b=123,
+                        sizing_mode="sizingMode"
+                    ),
                     root_volume_configuration=fsx.CfnFileSystem.RootVolumeConfigurationProperty(
                         copy_tags_to_snapshots=False,
                         data_compression_type="dataCompressionType",
@@ -3909,12 +4020,15 @@ class CfnFileSystemProps:
 
     @builtins.property
     def storage_type(self) -> typing.Optional[builtins.str]:
-        '''Sets the storage type for the file system that you're creating. Valid values are ``SSD`` and ``HDD`` .
+        '''Sets the storage class for the file system that you're creating.
+
+        Valid values are ``SSD`` , ``HDD`` , and ``INTELLIGENT_TIERING`` .
 
         - Set to ``SSD`` to use solid state drive storage. SSD is supported on all Windows, Lustre, ONTAP, and OpenZFS deployment types.
         - Set to ``HDD`` to use hard disk drive storage. HDD is supported on ``SINGLE_AZ_2`` and ``MULTI_AZ_1`` Windows file system deployment types, and on ``PERSISTENT_1`` Lustre file system deployment types.
+        - Set to ``INTELLIGENT_TIERING`` to use fully elastic, intelligently-tiered storage. Intelligent-Tiering is only available for OpenZFS file systems with the Multi-AZ deployment type.
 
-        Default value is ``SSD`` . For more information, see `Storage type options <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/optimize-fsx-costs.html#storage-type-options>`_ in the *FSx for Windows File Server User Guide* and `Multiple storage options <https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html#storage-options>`_ in the *FSx for Lustre User Guide* .
+        Default value is ``SSD`` . For more information, see `Storage type options <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/optimize-fsx-costs.html#storage-type-options>`_ in the *FSx for Windows File Server User Guide* , `Multiple storage options <https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html#storage-options>`_ in the *FSx for Lustre User Guide* , and `Working with Intelligent-Tiering <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/performance-intelligent-tiering>`_ in the *Amazon FSx for OpenZFS User Guide* .
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-fsx-filesystem.html#cfn-fsx-filesystem-storagetype
         '''
@@ -5837,7 +5951,7 @@ class CfnVolume(
             :param options: To delete the volume's child volumes, snapshots, and clones, use the string ``DELETE_CHILD_VOLUMES_AND_SNAPSHOTS`` .
             :param origin_snapshot: The configuration object that specifies the snapshot to use as the origin of the data for the volume.
             :param read_only: A Boolean value indicating whether the volume is read-only.
-            :param record_size_kib: Specifies the suggested block size for a volume in a ZFS dataset, in kibibytes (KiB). Valid values are 4, 8, 16, 32, 64, 128, 256, 512, or 1024 KiB. The default is 128 KiB. We recommend using the default setting for the majority of use cases. Generally, workloads that write in fixed small or large record sizes may benefit from setting a custom record size, like database workloads (small record size) or media streaming workloads (large record size). For additional guidance on when to set a custom record size, see `ZFS Record size <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/performance.html#record-size-performance>`_ in the *Amazon FSx for OpenZFS User Guide* .
+            :param record_size_kib: Specifies the suggested block size for a volume in a ZFS dataset, in kibibytes (KiB). For file systems using the Intelligent-Tiering storage class, valid values are 128, 256, 512, 1024, 2048, or 4096 KiB, with a default of 1024 KiB. For all other file systems, valid values are 4, 8, 16, 32, 64, 128, 256, 512, or 1024 KiB, with a default of 128 KiB. We recommend using the default setting for the majority of use cases. Generally, workloads that write in fixed small or large record sizes may benefit from setting a custom record size, like database workloads (small record size) or media streaming workloads (large record size). For additional guidance on when to set a custom record size, see `ZFS Record size <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/performance.html#record-size-performance>`_ in the *Amazon FSx for OpenZFS User Guide* .
             :param storage_capacity_quota_gib: Sets the maximum storage size in gibibytes (GiB) for the volume. You can specify a quota that is larger than the storage on the parent volume. A volume quota limits the amount of storage that the volume can consume to the configured amount, but does not guarantee the space will be available on the parent volume. To guarantee quota space, you must also set ``StorageCapacityReservationGiB`` . To *not* specify a storage capacity quota, set this to ``-1`` . For more information, see `Volume properties <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/managing-volumes.html#volume-properties>`_ in the *Amazon FSx for OpenZFS User Guide* .
             :param storage_capacity_reservation_gib: Specifies the amount of storage in gibibytes (GiB) to reserve from the parent volume. Setting ``StorageCapacityReservationGiB`` guarantees that the specified amount of storage space on the parent volume will always be available for the volume. You can't reserve more storage than the parent volume has. To *not* specify a storage capacity reservation, set this to ``0`` or ``-1`` . For more information, see `Volume properties <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/managing-volumes.html#volume-properties>`_ in the *Amazon FSx for OpenZFS User Guide* .
             :param user_and_group_quotas: Configures how much storage users and groups can use on the volume.
@@ -5998,7 +6112,7 @@ class CfnVolume(
         def record_size_kib(self) -> typing.Optional[jsii.Number]:
             '''Specifies the suggested block size for a volume in a ZFS dataset, in kibibytes (KiB).
 
-            Valid values are 4, 8, 16, 32, 64, 128, 256, 512, or 1024 KiB. The default is 128 KiB. We recommend using the default setting for the majority of use cases. Generally, workloads that write in fixed small or large record sizes may benefit from setting a custom record size, like database workloads (small record size) or media streaming workloads (large record size). For additional guidance on when to set a custom record size, see `ZFS Record size <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/performance.html#record-size-performance>`_ in the *Amazon FSx for OpenZFS User Guide* .
+            For file systems using the Intelligent-Tiering storage class, valid values are 128, 256, 512, 1024, 2048, or 4096 KiB, with a default of 1024 KiB. For all other file systems, valid values are 4, 8, 16, 32, 64, 128, 256, 512, or 1024 KiB, with a default of 128 KiB. We recommend using the default setting for the majority of use cases. Generally, workloads that write in fixed small or large record sizes may benefit from setting a custom record size, like database workloads (small record size) or media streaming workloads (large record size). For additional guidance on when to set a custom record size, see `ZFS Record size <https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/performance.html#record-size-performance>`_ in the *Amazon FSx for OpenZFS User Guide* .
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-fsx-volume-openzfsconfiguration.html#cfn-fsx-volume-openzfsconfiguration-recordsizekib
             '''
@@ -8684,6 +8798,7 @@ def _typecheckingstub__8e1fe808b96f0eb1b8b6ed8eb3d551c8d995fe2c98c9be554bed33160
     data_compression_type: typing.Optional[builtins.str] = None,
     deployment_type: typing.Optional[builtins.str] = None,
     drive_cache_type: typing.Optional[builtins.str] = None,
+    efa_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     export_path: typing.Optional[builtins.str] = None,
     imported_file_chunk_size: typing.Optional[jsii.Number] = None,
     import_path: typing.Optional[builtins.str] = None,
@@ -8738,6 +8853,7 @@ def _typecheckingstub__5472f29690b088eacdf6c6853ffd8b23cd15c760dc30d812107be1280
     endpoint_ip_address_range: typing.Optional[builtins.str] = None,
     options: typing.Optional[typing.Sequence[builtins.str]] = None,
     preferred_subnet_id: typing.Optional[builtins.str] = None,
+    read_cache_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFileSystem.ReadCacheConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     root_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnFileSystem.RootVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
     throughput_capacity: typing.Optional[jsii.Number] = None,
@@ -8746,6 +8862,14 @@ def _typecheckingstub__5472f29690b088eacdf6c6853ffd8b23cd15c760dc30d812107be1280
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5da424653f281066f7140c38ddd8b33a2fdb52a49e2f3ecfacac378ab1825ad9(
+    *,
+    size_gib: typing.Optional[jsii.Number] = None,
+    sizing_mode: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__7c2a873402766c6577ffe7568330e8c952efaedecdfd993af4793d2ea6d69f8b(
     *,
     copy_tags_to_snapshots: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,