# WARNING ABOUT GENERATED CODE
#
# This file is generated. See the contributing guide for more information:
# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
#
# WARNING ABOUT GENERATED CODE

module Aws
  module ElastiCache
    class Client < ::Seahorse::Client::Base
      include ::Aws::ClientStubs

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#initialize-instance_method
      def self.new: (
                      ?credentials: untyped,
                      ?region: String,
                      ?access_key_id: String,
                      ?account_id: String,
                      ?active_endpoint_cache: bool,
                      ?adaptive_retry_wait_to_fill: bool,
                      ?client_side_monitoring: bool,
                      ?client_side_monitoring_client_id: String,
                      ?client_side_monitoring_host: String,
                      ?client_side_monitoring_port: Integer,
                      ?client_side_monitoring_publisher: untyped,
                      ?convert_params: bool,
                      ?correct_clock_skew: bool,
                      ?defaults_mode: String,
                      ?disable_host_prefix_injection: bool,
                      ?disable_request_compression: bool,
                      ?endpoint: String,
                      ?endpoint_cache_max_entries: Integer,
                      ?endpoint_cache_max_threads: Integer,
                      ?endpoint_cache_poll_interval: Integer,
                      ?endpoint_discovery: bool,
                      ?ignore_configured_endpoint_urls: bool,
                      ?log_formatter: untyped,
                      ?log_level: Symbol,
                      ?logger: untyped,
                      ?max_attempts: Integer,
                      ?profile: String,
                      ?request_min_compression_size_bytes: Integer,
                      ?retry_backoff: Proc,
                      ?retry_base_delay: Float,
                      ?retry_jitter: (:none | :equal | :full | ^(Integer) -> Integer),
                      ?retry_limit: Integer,
                      ?retry_max_delay: Integer,
                      ?retry_mode: ("legacy" | "standard" | "adaptive"),
                      ?sdk_ua_app_id: String,
                      ?secret_access_key: String,
                      ?session_token: String,
                      ?sigv4a_signing_region_set: Array[String],
                      ?stub_responses: untyped,
                      ?telemetry_provider: Aws::Telemetry::TelemetryProviderBase,
                      ?token_provider: untyped,
                      ?use_dualstack_endpoint: bool,
                      ?use_fips_endpoint: bool,
                      ?validate_params: bool,
                      ?endpoint_provider: untyped,
                      ?http_proxy: String,
                      ?http_open_timeout: (Float | Integer),
                      ?http_read_timeout: (Float | Integer),
                      ?http_idle_timeout: (Float | Integer),
                      ?http_continue_timeout: (Float | Integer),
                      ?ssl_timeout: (Float | Integer | nil),
                      ?http_wire_trace: bool,
                      ?ssl_verify_peer: bool,
                      ?ssl_ca_bundle: String,
                      ?ssl_ca_directory: String,
                      ?ssl_ca_store: String,
                      ?on_chunk_received: Proc,
                      ?on_chunk_sent: Proc,
                      ?raise_response_errors: bool
                    ) -> instance
                  | (?Hash[Symbol, untyped]) -> instance


      interface _AddTagsToResourceResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TagListMessage]
        def tag_list: () -> ::Array[Types::Tag]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#add_tags_to_resource-instance_method
      def add_tags_to_resource: (
                                  resource_name: ::String,
                                  tags: Array[
                                    {
                                      key: ::String?,
                                      value: ::String?
                                    },
                                  ]
                                ) -> _AddTagsToResourceResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AddTagsToResourceResponseSuccess

      interface _AuthorizeCacheSecurityGroupIngressResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AuthorizeCacheSecurityGroupIngressResult]
        def cache_security_group: () -> Types::CacheSecurityGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#authorize_cache_security_group_ingress-instance_method
      def authorize_cache_security_group_ingress: (
                                                    cache_security_group_name: ::String,
                                                    ec2_security_group_name: ::String,
                                                    ec2_security_group_owner_id: ::String
                                                  ) -> _AuthorizeCacheSecurityGroupIngressResponseSuccess
                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AuthorizeCacheSecurityGroupIngressResponseSuccess

      interface _BatchApplyUpdateActionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateActionResultsMessage]
        def processed_update_actions: () -> ::Array[Types::ProcessedUpdateAction]
        def unprocessed_update_actions: () -> ::Array[Types::UnprocessedUpdateAction]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#batch_apply_update_action-instance_method
      def batch_apply_update_action: (
                                       ?replication_group_ids: Array[::String],
                                       ?cache_cluster_ids: Array[::String],
                                       service_update_name: ::String
                                     ) -> _BatchApplyUpdateActionResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchApplyUpdateActionResponseSuccess

      interface _BatchStopUpdateActionResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateActionResultsMessage]
        def processed_update_actions: () -> ::Array[Types::ProcessedUpdateAction]
        def unprocessed_update_actions: () -> ::Array[Types::UnprocessedUpdateAction]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#batch_stop_update_action-instance_method
      def batch_stop_update_action: (
                                      ?replication_group_ids: Array[::String],
                                      ?cache_cluster_ids: Array[::String],
                                      service_update_name: ::String
                                    ) -> _BatchStopUpdateActionResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _BatchStopUpdateActionResponseSuccess

      interface _CompleteMigrationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CompleteMigrationResponse]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#complete_migration-instance_method
      def complete_migration: (
                                replication_group_id: ::String,
                                ?force: bool
                              ) -> _CompleteMigrationResponseSuccess
                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CompleteMigrationResponseSuccess

      interface _CopyServerlessCacheSnapshotResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CopyServerlessCacheSnapshotResponse]
        def serverless_cache_snapshot: () -> Types::ServerlessCacheSnapshot
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#copy_serverless_cache_snapshot-instance_method
      def copy_serverless_cache_snapshot: (
                                            source_serverless_cache_snapshot_name: ::String,
                                            target_serverless_cache_snapshot_name: ::String,
                                            ?kms_key_id: ::String,
                                            ?tags: Array[
                                              {
                                                key: ::String?,
                                                value: ::String?
                                              },
                                            ]
                                          ) -> _CopyServerlessCacheSnapshotResponseSuccess
                                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CopyServerlessCacheSnapshotResponseSuccess

      interface _CopySnapshotResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CopySnapshotResult]
        def snapshot: () -> Types::Snapshot
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#copy_snapshot-instance_method
      def copy_snapshot: (
                           source_snapshot_name: ::String,
                           target_snapshot_name: ::String,
                           ?target_bucket: ::String,
                           ?kms_key_id: ::String,
                           ?tags: Array[
                             {
                               key: ::String?,
                               value: ::String?
                             },
                           ]
                         ) -> _CopySnapshotResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CopySnapshotResponseSuccess

      interface _CreateCacheClusterResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCacheClusterResult]
        def cache_cluster: () -> Types::CacheCluster
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_cache_cluster-instance_method
      def create_cache_cluster: (
                                  cache_cluster_id: ::String,
                                  ?replication_group_id: ::String,
                                  ?az_mode: ("single-az" | "cross-az"),
                                  ?preferred_availability_zone: ::String,
                                  ?preferred_availability_zones: Array[::String],
                                  ?num_cache_nodes: ::Integer,
                                  ?cache_node_type: ::String,
                                  ?engine: ::String,
                                  ?engine_version: ::String,
                                  ?cache_parameter_group_name: ::String,
                                  ?cache_subnet_group_name: ::String,
                                  ?cache_security_group_names: Array[::String],
                                  ?security_group_ids: Array[::String],
                                  ?tags: Array[
                                    {
                                      key: ::String?,
                                      value: ::String?
                                    },
                                  ],
                                  ?snapshot_arns: Array[::String],
                                  ?snapshot_name: ::String,
                                  ?preferred_maintenance_window: ::String,
                                  ?port: ::Integer,
                                  ?notification_topic_arn: ::String,
                                  ?auto_minor_version_upgrade: bool,
                                  ?snapshot_retention_limit: ::Integer,
                                  ?snapshot_window: ::String,
                                  ?auth_token: ::String,
                                  ?outpost_mode: ("single-outpost" | "cross-outpost"),
                                  ?preferred_outpost_arn: ::String,
                                  ?preferred_outpost_arns: Array[::String],
                                  ?log_delivery_configurations: Array[
                                    {
                                      log_type: ("slow-log" | "engine-log")?,
                                      destination_type: ("cloudwatch-logs" | "kinesis-firehose")?,
                                      destination_details: {
                                        cloud_watch_logs_details: {
                                          log_group: ::String?
                                        }?,
                                        kinesis_firehose_details: {
                                          delivery_stream: ::String?
                                        }?
                                      }?,
                                      log_format: ("text" | "json")?,
                                      enabled: bool?
                                    },
                                  ],
                                  ?transit_encryption_enabled: bool,
                                  ?network_type: ("ipv4" | "ipv6" | "dual_stack"),
                                  ?ip_discovery: ("ipv4" | "ipv6")
                                ) -> _CreateCacheClusterResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCacheClusterResponseSuccess

      interface _CreateCacheParameterGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCacheParameterGroupResult]
        def cache_parameter_group: () -> Types::CacheParameterGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_cache_parameter_group-instance_method
      def create_cache_parameter_group: (
                                          cache_parameter_group_name: ::String,
                                          cache_parameter_group_family: ::String,
                                          description: ::String,
                                          ?tags: Array[
                                            {
                                              key: ::String?,
                                              value: ::String?
                                            },
                                          ]
                                        ) -> _CreateCacheParameterGroupResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCacheParameterGroupResponseSuccess

      interface _CreateCacheSecurityGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCacheSecurityGroupResult]
        def cache_security_group: () -> Types::CacheSecurityGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_cache_security_group-instance_method
      def create_cache_security_group: (
                                         cache_security_group_name: ::String,
                                         description: ::String,
                                         ?tags: Array[
                                           {
                                             key: ::String?,
                                             value: ::String?
                                           },
                                         ]
                                       ) -> _CreateCacheSecurityGroupResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCacheSecurityGroupResponseSuccess

      interface _CreateCacheSubnetGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateCacheSubnetGroupResult]
        def cache_subnet_group: () -> Types::CacheSubnetGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_cache_subnet_group-instance_method
      def create_cache_subnet_group: (
                                       cache_subnet_group_name: ::String,
                                       cache_subnet_group_description: ::String,
                                       subnet_ids: Array[::String],
                                       ?tags: Array[
                                         {
                                           key: ::String?,
                                           value: ::String?
                                         },
                                       ]
                                     ) -> _CreateCacheSubnetGroupResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateCacheSubnetGroupResponseSuccess

      interface _CreateGlobalReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateGlobalReplicationGroupResult]
        def global_replication_group: () -> Types::GlobalReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_global_replication_group-instance_method
      def create_global_replication_group: (
                                             global_replication_group_id_suffix: ::String,
                                             ?global_replication_group_description: ::String,
                                             primary_replication_group_id: ::String
                                           ) -> _CreateGlobalReplicationGroupResponseSuccess
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateGlobalReplicationGroupResponseSuccess

      interface _CreateReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateReplicationGroupResult]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_replication_group-instance_method
      def create_replication_group: (
                                      replication_group_id: ::String,
                                      replication_group_description: ::String,
                                      ?global_replication_group_id: ::String,
                                      ?primary_cluster_id: ::String,
                                      ?automatic_failover_enabled: bool,
                                      ?multi_az_enabled: bool,
                                      ?num_cache_clusters: ::Integer,
                                      ?preferred_cache_cluster_a_zs: Array[::String],
                                      ?num_node_groups: ::Integer,
                                      ?replicas_per_node_group: ::Integer,
                                      ?node_group_configuration: Array[
                                        {
                                          node_group_id: ::String?,
                                          slots: ::String?,
                                          replica_count: ::Integer?,
                                          primary_availability_zone: ::String?,
                                          replica_availability_zones: Array[::String]?,
                                          primary_outpost_arn: ::String?,
                                          replica_outpost_arns: Array[::String]?
                                        },
                                      ],
                                      ?cache_node_type: ::String,
                                      ?engine: ::String,
                                      ?engine_version: ::String,
                                      ?cache_parameter_group_name: ::String,
                                      ?cache_subnet_group_name: ::String,
                                      ?cache_security_group_names: Array[::String],
                                      ?security_group_ids: Array[::String],
                                      ?tags: Array[
                                        {
                                          key: ::String?,
                                          value: ::String?
                                        },
                                      ],
                                      ?snapshot_arns: Array[::String],
                                      ?snapshot_name: ::String,
                                      ?preferred_maintenance_window: ::String,
                                      ?port: ::Integer,
                                      ?notification_topic_arn: ::String,
                                      ?auto_minor_version_upgrade: bool,
                                      ?snapshot_retention_limit: ::Integer,
                                      ?snapshot_window: ::String,
                                      ?auth_token: ::String,
                                      ?transit_encryption_enabled: bool,
                                      ?at_rest_encryption_enabled: bool,
                                      ?kms_key_id: ::String,
                                      ?user_group_ids: Array[::String],
                                      ?log_delivery_configurations: Array[
                                        {
                                          log_type: ("slow-log" | "engine-log")?,
                                          destination_type: ("cloudwatch-logs" | "kinesis-firehose")?,
                                          destination_details: {
                                            cloud_watch_logs_details: {
                                              log_group: ::String?
                                            }?,
                                            kinesis_firehose_details: {
                                              delivery_stream: ::String?
                                            }?
                                          }?,
                                          log_format: ("text" | "json")?,
                                          enabled: bool?
                                        },
                                      ],
                                      ?data_tiering_enabled: bool,
                                      ?network_type: ("ipv4" | "ipv6" | "dual_stack"),
                                      ?ip_discovery: ("ipv4" | "ipv6"),
                                      ?transit_encryption_mode: ("preferred" | "required"),
                                      ?cluster_mode: ("enabled" | "disabled" | "compatible"),
                                      ?serverless_cache_snapshot_name: ::String
                                    ) -> _CreateReplicationGroupResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateReplicationGroupResponseSuccess

      interface _CreateServerlessCacheResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateServerlessCacheResponse]
        def serverless_cache: () -> Types::ServerlessCache
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_serverless_cache-instance_method
      def create_serverless_cache: (
                                     serverless_cache_name: ::String,
                                     ?description: ::String,
                                     engine: ::String,
                                     ?major_engine_version: ::String,
                                     ?cache_usage_limits: {
                                       data_storage: {
                                         maximum: ::Integer?,
                                         minimum: ::Integer?,
                                         unit: ("GB")
                                       }?,
                                       ecpu_per_second: {
                                         maximum: ::Integer?,
                                         minimum: ::Integer?
                                       }?
                                     },
                                     ?kms_key_id: ::String,
                                     ?security_group_ids: Array[::String],
                                     ?snapshot_arns_to_restore: Array[::String],
                                     ?tags: Array[
                                       {
                                         key: ::String?,
                                         value: ::String?
                                       },
                                     ],
                                     ?user_group_id: ::String,
                                     ?subnet_ids: Array[::String],
                                     ?snapshot_retention_limit: ::Integer,
                                     ?daily_snapshot_time: ::String
                                   ) -> _CreateServerlessCacheResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateServerlessCacheResponseSuccess

      interface _CreateServerlessCacheSnapshotResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateServerlessCacheSnapshotResponse]
        def serverless_cache_snapshot: () -> Types::ServerlessCacheSnapshot
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_serverless_cache_snapshot-instance_method
      def create_serverless_cache_snapshot: (
                                              serverless_cache_snapshot_name: ::String,
                                              serverless_cache_name: ::String,
                                              ?kms_key_id: ::String,
                                              ?tags: Array[
                                                {
                                                  key: ::String?,
                                                  value: ::String?
                                                },
                                              ]
                                            ) -> _CreateServerlessCacheSnapshotResponseSuccess
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateServerlessCacheSnapshotResponseSuccess

      interface _CreateSnapshotResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CreateSnapshotResult]
        def snapshot: () -> Types::Snapshot
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_snapshot-instance_method
      def create_snapshot: (
                             ?replication_group_id: ::String,
                             ?cache_cluster_id: ::String,
                             snapshot_name: ::String,
                             ?kms_key_id: ::String,
                             ?tags: Array[
                               {
                                 key: ::String?,
                                 value: ::String?
                               },
                             ]
                           ) -> _CreateSnapshotResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateSnapshotResponseSuccess

      interface _CreateUserResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::User]
        def user_id: () -> ::String
        def user_name: () -> ::String
        def status: () -> ::String
        def engine: () -> ::String
        def minimum_engine_version: () -> ::String
        def access_string: () -> ::String
        def user_group_ids: () -> ::Array[::String]
        def authentication: () -> Types::Authentication
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_user-instance_method
      def create_user: (
                         user_id: ::String,
                         user_name: ::String,
                         engine: ::String,
                         ?passwords: Array[::String],
                         access_string: ::String,
                         ?no_password_required: bool,
                         ?tags: Array[
                           {
                             key: ::String?,
                             value: ::String?
                           },
                         ],
                         ?authentication_mode: {
                           type: ("password" | "no-password-required" | "iam")?,
                           passwords: Array[::String]?
                         }
                       ) -> _CreateUserResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateUserResponseSuccess

      interface _CreateUserGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UserGroup]
        def user_group_id: () -> ::String
        def status: () -> ::String
        def engine: () -> ::String
        def user_ids: () -> ::Array[::String]
        def minimum_engine_version: () -> ::String
        def pending_changes: () -> Types::UserGroupPendingChanges
        def replication_groups: () -> ::Array[::String]
        def serverless_caches: () -> ::Array[::String]
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#create_user_group-instance_method
      def create_user_group: (
                               user_group_id: ::String,
                               engine: ::String,
                               ?user_ids: Array[::String],
                               ?tags: Array[
                                 {
                                   key: ::String?,
                                   value: ::String?
                                 },
                               ]
                             ) -> _CreateUserGroupResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateUserGroupResponseSuccess

      interface _DecreaseNodeGroupsInGlobalReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DecreaseNodeGroupsInGlobalReplicationGroupResult]
        def global_replication_group: () -> Types::GlobalReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#decrease_node_groups_in_global_replication_group-instance_method
      def decrease_node_groups_in_global_replication_group: (
                                                              global_replication_group_id: ::String,
                                                              node_group_count: ::Integer,
                                                              ?global_node_groups_to_remove: Array[::String],
                                                              ?global_node_groups_to_retain: Array[::String],
                                                              apply_immediately: bool
                                                            ) -> _DecreaseNodeGroupsInGlobalReplicationGroupResponseSuccess
                                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DecreaseNodeGroupsInGlobalReplicationGroupResponseSuccess

      interface _DecreaseReplicaCountResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DecreaseReplicaCountResult]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#decrease_replica_count-instance_method
      def decrease_replica_count: (
                                    replication_group_id: ::String,
                                    ?new_replica_count: ::Integer,
                                    ?replica_configuration: Array[
                                      {
                                        node_group_id: ::String,
                                        new_replica_count: ::Integer,
                                        preferred_availability_zones: Array[::String]?,
                                        preferred_outpost_arns: Array[::String]?
                                      },
                                    ],
                                    ?replicas_to_remove: Array[::String],
                                    apply_immediately: bool
                                  ) -> _DecreaseReplicaCountResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DecreaseReplicaCountResponseSuccess

      interface _DeleteCacheClusterResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteCacheClusterResult]
        def cache_cluster: () -> Types::CacheCluster
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_cache_cluster-instance_method
      def delete_cache_cluster: (
                                  cache_cluster_id: ::String,
                                  ?final_snapshot_identifier: ::String
                                ) -> _DeleteCacheClusterResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteCacheClusterResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_cache_parameter_group-instance_method
      def delete_cache_parameter_group: (
                                          cache_parameter_group_name: ::String
                                        ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_cache_security_group-instance_method
      def delete_cache_security_group: (
                                         cache_security_group_name: ::String
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_cache_subnet_group-instance_method
      def delete_cache_subnet_group: (
                                       cache_subnet_group_name: ::String
                                     ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]

      interface _DeleteGlobalReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteGlobalReplicationGroupResult]
        def global_replication_group: () -> Types::GlobalReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_global_replication_group-instance_method
      def delete_global_replication_group: (
                                             global_replication_group_id: ::String,
                                             retain_primary_replication_group: bool
                                           ) -> _DeleteGlobalReplicationGroupResponseSuccess
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteGlobalReplicationGroupResponseSuccess

      interface _DeleteReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteReplicationGroupResult]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_replication_group-instance_method
      def delete_replication_group: (
                                      replication_group_id: ::String,
                                      ?retain_primary_cluster: bool,
                                      ?final_snapshot_identifier: ::String
                                    ) -> _DeleteReplicationGroupResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteReplicationGroupResponseSuccess

      interface _DeleteServerlessCacheResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteServerlessCacheResponse]
        def serverless_cache: () -> Types::ServerlessCache
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_serverless_cache-instance_method
      def delete_serverless_cache: (
                                     serverless_cache_name: ::String,
                                     ?final_snapshot_name: ::String
                                   ) -> _DeleteServerlessCacheResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteServerlessCacheResponseSuccess

      interface _DeleteServerlessCacheSnapshotResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteServerlessCacheSnapshotResponse]
        def serverless_cache_snapshot: () -> Types::ServerlessCacheSnapshot
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_serverless_cache_snapshot-instance_method
      def delete_serverless_cache_snapshot: (
                                              serverless_cache_snapshot_name: ::String
                                            ) -> _DeleteServerlessCacheSnapshotResponseSuccess
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteServerlessCacheSnapshotResponseSuccess

      interface _DeleteSnapshotResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DeleteSnapshotResult]
        def snapshot: () -> Types::Snapshot
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_snapshot-instance_method
      def delete_snapshot: (
                             snapshot_name: ::String
                           ) -> _DeleteSnapshotResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteSnapshotResponseSuccess

      interface _DeleteUserResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::User]
        def user_id: () -> ::String
        def user_name: () -> ::String
        def status: () -> ::String
        def engine: () -> ::String
        def minimum_engine_version: () -> ::String
        def access_string: () -> ::String
        def user_group_ids: () -> ::Array[::String]
        def authentication: () -> Types::Authentication
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_user-instance_method
      def delete_user: (
                         user_id: ::String
                       ) -> _DeleteUserResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteUserResponseSuccess

      interface _DeleteUserGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UserGroup]
        def user_group_id: () -> ::String
        def status: () -> ::String
        def engine: () -> ::String
        def user_ids: () -> ::Array[::String]
        def minimum_engine_version: () -> ::String
        def pending_changes: () -> Types::UserGroupPendingChanges
        def replication_groups: () -> ::Array[::String]
        def serverless_caches: () -> ::Array[::String]
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#delete_user_group-instance_method
      def delete_user_group: (
                               user_group_id: ::String
                             ) -> _DeleteUserGroupResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteUserGroupResponseSuccess

      interface _DescribeCacheClustersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CacheClusterMessage]
        def marker: () -> ::String
        def cache_clusters: () -> ::Array[Types::CacheCluster]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_cache_clusters-instance_method
      def describe_cache_clusters: (
                                     ?cache_cluster_id: ::String,
                                     ?max_records: ::Integer,
                                     ?marker: ::String,
                                     ?show_cache_node_info: bool,
                                     ?show_cache_clusters_not_in_replication_groups: bool
                                   ) -> _DescribeCacheClustersResponseSuccess
                                 | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCacheClustersResponseSuccess

      interface _DescribeCacheEngineVersionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CacheEngineVersionMessage]
        def marker: () -> ::String
        def cache_engine_versions: () -> ::Array[Types::CacheEngineVersion]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_cache_engine_versions-instance_method
      def describe_cache_engine_versions: (
                                            ?engine: ::String,
                                            ?engine_version: ::String,
                                            ?cache_parameter_group_family: ::String,
                                            ?max_records: ::Integer,
                                            ?marker: ::String,
                                            ?default_only: bool
                                          ) -> _DescribeCacheEngineVersionsResponseSuccess
                                        | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCacheEngineVersionsResponseSuccess

      interface _DescribeCacheParameterGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CacheParameterGroupsMessage]
        def marker: () -> ::String
        def cache_parameter_groups: () -> ::Array[Types::CacheParameterGroup]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_cache_parameter_groups-instance_method
      def describe_cache_parameter_groups: (
                                             ?cache_parameter_group_name: ::String,
                                             ?max_records: ::Integer,
                                             ?marker: ::String
                                           ) -> _DescribeCacheParameterGroupsResponseSuccess
                                         | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCacheParameterGroupsResponseSuccess

      interface _DescribeCacheParametersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CacheParameterGroupDetails]
        def marker: () -> ::String
        def parameters: () -> ::Array[Types::Parameter]
        def cache_node_type_specific_parameters: () -> ::Array[Types::CacheNodeTypeSpecificParameter]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_cache_parameters-instance_method
      def describe_cache_parameters: (
                                       cache_parameter_group_name: ::String,
                                       ?source: ::String,
                                       ?max_records: ::Integer,
                                       ?marker: ::String
                                     ) -> _DescribeCacheParametersResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCacheParametersResponseSuccess

      interface _DescribeCacheSecurityGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CacheSecurityGroupMessage]
        def marker: () -> ::String
        def cache_security_groups: () -> ::Array[Types::CacheSecurityGroup]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_cache_security_groups-instance_method
      def describe_cache_security_groups: (
                                            ?cache_security_group_name: ::String,
                                            ?max_records: ::Integer,
                                            ?marker: ::String
                                          ) -> _DescribeCacheSecurityGroupsResponseSuccess
                                        | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCacheSecurityGroupsResponseSuccess

      interface _DescribeCacheSubnetGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CacheSubnetGroupMessage]
        def marker: () -> ::String
        def cache_subnet_groups: () -> ::Array[Types::CacheSubnetGroup]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_cache_subnet_groups-instance_method
      def describe_cache_subnet_groups: (
                                          ?cache_subnet_group_name: ::String,
                                          ?max_records: ::Integer,
                                          ?marker: ::String
                                        ) -> _DescribeCacheSubnetGroupsResponseSuccess
                                      | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeCacheSubnetGroupsResponseSuccess

      interface _DescribeEngineDefaultParametersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeEngineDefaultParametersResult]
        def engine_defaults: () -> Types::EngineDefaults
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_engine_default_parameters-instance_method
      def describe_engine_default_parameters: (
                                                cache_parameter_group_family: ::String,
                                                ?max_records: ::Integer,
                                                ?marker: ::String
                                              ) -> _DescribeEngineDefaultParametersResponseSuccess
                                            | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeEngineDefaultParametersResponseSuccess

      interface _DescribeEventsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::EventsMessage]
        def marker: () -> ::String
        def events: () -> ::Array[Types::Event]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_events-instance_method
      def describe_events: (
                             ?source_identifier: ::String,
                             ?source_type: ("cache-cluster" | "cache-parameter-group" | "cache-security-group" | "cache-subnet-group" | "replication-group" | "serverless-cache" | "serverless-cache-snapshot" | "user" | "user-group"),
                             ?start_time: ::Time,
                             ?end_time: ::Time,
                             ?duration: ::Integer,
                             ?max_records: ::Integer,
                             ?marker: ::String
                           ) -> _DescribeEventsResponseSuccess
                         | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeEventsResponseSuccess

      interface _DescribeGlobalReplicationGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeGlobalReplicationGroupsResult]
        def marker: () -> ::String
        def global_replication_groups: () -> ::Array[Types::GlobalReplicationGroup]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_global_replication_groups-instance_method
      def describe_global_replication_groups: (
                                                ?global_replication_group_id: ::String,
                                                ?max_records: ::Integer,
                                                ?marker: ::String,
                                                ?show_member_info: bool
                                              ) -> _DescribeGlobalReplicationGroupsResponseSuccess
                                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeGlobalReplicationGroupsResponseSuccess

      interface _DescribeReplicationGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ReplicationGroupMessage]
        def marker: () -> ::String
        def replication_groups: () -> ::Array[Types::ReplicationGroup]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_replication_groups-instance_method
      def describe_replication_groups: (
                                         ?replication_group_id: ::String,
                                         ?max_records: ::Integer,
                                         ?marker: ::String
                                       ) -> _DescribeReplicationGroupsResponseSuccess
                                     | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeReplicationGroupsResponseSuccess

      interface _DescribeReservedCacheNodesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ReservedCacheNodeMessage]
        def marker: () -> ::String
        def reserved_cache_nodes: () -> ::Array[Types::ReservedCacheNode]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_reserved_cache_nodes-instance_method
      def describe_reserved_cache_nodes: (
                                           ?reserved_cache_node_id: ::String,
                                           ?reserved_cache_nodes_offering_id: ::String,
                                           ?cache_node_type: ::String,
                                           ?duration: ::String,
                                           ?product_description: ::String,
                                           ?offering_type: ::String,
                                           ?max_records: ::Integer,
                                           ?marker: ::String
                                         ) -> _DescribeReservedCacheNodesResponseSuccess
                                       | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeReservedCacheNodesResponseSuccess

      interface _DescribeReservedCacheNodesOfferingsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ReservedCacheNodesOfferingMessage]
        def marker: () -> ::String
        def reserved_cache_nodes_offerings: () -> ::Array[Types::ReservedCacheNodesOffering]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_reserved_cache_nodes_offerings-instance_method
      def describe_reserved_cache_nodes_offerings: (
                                                     ?reserved_cache_nodes_offering_id: ::String,
                                                     ?cache_node_type: ::String,
                                                     ?duration: ::String,
                                                     ?product_description: ::String,
                                                     ?offering_type: ::String,
                                                     ?max_records: ::Integer,
                                                     ?marker: ::String
                                                   ) -> _DescribeReservedCacheNodesOfferingsResponseSuccess
                                                 | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeReservedCacheNodesOfferingsResponseSuccess

      interface _DescribeServerlessCacheSnapshotsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeServerlessCacheSnapshotsResponse]
        def next_token: () -> ::String
        def serverless_cache_snapshots: () -> ::Array[Types::ServerlessCacheSnapshot]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_serverless_cache_snapshots-instance_method
      def describe_serverless_cache_snapshots: (
                                                 ?serverless_cache_name: ::String,
                                                 ?serverless_cache_snapshot_name: ::String,
                                                 ?snapshot_type: ::String,
                                                 ?next_token: ::String,
                                                 ?max_results: ::Integer
                                               ) -> _DescribeServerlessCacheSnapshotsResponseSuccess
                                             | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeServerlessCacheSnapshotsResponseSuccess

      interface _DescribeServerlessCachesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeServerlessCachesResponse]
        def next_token: () -> ::String
        def serverless_caches: () -> ::Array[Types::ServerlessCache]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_serverless_caches-instance_method
      def describe_serverless_caches: (
                                        ?serverless_cache_name: ::String,
                                        ?max_results: ::Integer,
                                        ?next_token: ::String
                                      ) -> _DescribeServerlessCachesResponseSuccess
                                    | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeServerlessCachesResponseSuccess

      interface _DescribeServiceUpdatesResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ServiceUpdatesMessage]
        def marker: () -> ::String
        def service_updates: () -> ::Array[Types::ServiceUpdate]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_service_updates-instance_method
      def describe_service_updates: (
                                      ?service_update_name: ::String,
                                      ?service_update_status: Array[("available" | "cancelled" | "expired")],
                                      ?max_records: ::Integer,
                                      ?marker: ::String
                                    ) -> _DescribeServiceUpdatesResponseSuccess
                                  | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeServiceUpdatesResponseSuccess

      interface _DescribeSnapshotsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeSnapshotsListMessage]
        def marker: () -> ::String
        def snapshots: () -> ::Array[Types::Snapshot]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_snapshots-instance_method
      def describe_snapshots: (
                                ?replication_group_id: ::String,
                                ?cache_cluster_id: ::String,
                                ?snapshot_name: ::String,
                                ?snapshot_source: ::String,
                                ?marker: ::String,
                                ?max_records: ::Integer,
                                ?show_node_group_config: bool
                              ) -> _DescribeSnapshotsResponseSuccess
                            | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeSnapshotsResponseSuccess

      interface _DescribeUpdateActionsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateActionsMessage]
        def marker: () -> ::String
        def update_actions: () -> ::Array[Types::UpdateAction]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_update_actions-instance_method
      def describe_update_actions: (
                                     ?service_update_name: ::String,
                                     ?replication_group_ids: Array[::String],
                                     ?cache_cluster_ids: Array[::String],
                                     ?engine: ::String,
                                     ?service_update_status: Array[("available" | "cancelled" | "expired")],
                                     ?service_update_time_range: {
                                       start_time: ::Time?,
                                       end_time: ::Time?
                                     },
                                     ?update_action_status: Array[("not-applied" | "waiting-to-start" | "in-progress" | "stopping" | "stopped" | "complete" | "scheduling" | "scheduled" | "not-applicable")],
                                     ?show_node_level_update_status: bool,
                                     ?max_records: ::Integer,
                                     ?marker: ::String
                                   ) -> _DescribeUpdateActionsResponseSuccess
                                 | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeUpdateActionsResponseSuccess

      interface _DescribeUserGroupsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeUserGroupsResult]
        def user_groups: () -> ::Array[Types::UserGroup]
        def marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_user_groups-instance_method
      def describe_user_groups: (
                                  ?user_group_id: ::String,
                                  ?max_records: ::Integer,
                                  ?marker: ::String
                                ) -> _DescribeUserGroupsResponseSuccess
                              | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeUserGroupsResponseSuccess

      interface _DescribeUsersResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeUsersResult]
        def users: () -> ::Array[Types::User]
        def marker: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#describe_users-instance_method
      def describe_users: (
                            ?engine: ::String,
                            ?user_id: ::String,
                            ?filters: Array[
                              {
                                name: ::String,
                                values: Array[::String]
                              },
                            ],
                            ?max_records: ::Integer,
                            ?marker: ::String
                          ) -> _DescribeUsersResponseSuccess
                        | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeUsersResponseSuccess

      interface _DisassociateGlobalReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::DisassociateGlobalReplicationGroupResult]
        def global_replication_group: () -> Types::GlobalReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#disassociate_global_replication_group-instance_method
      def disassociate_global_replication_group: (
                                                   global_replication_group_id: ::String,
                                                   replication_group_id: ::String,
                                                   replication_group_region: ::String
                                                 ) -> _DisassociateGlobalReplicationGroupResponseSuccess
                                               | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DisassociateGlobalReplicationGroupResponseSuccess

      interface _ExportServerlessCacheSnapshotResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ExportServerlessCacheSnapshotResponse]
        def serverless_cache_snapshot: () -> Types::ServerlessCacheSnapshot
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#export_serverless_cache_snapshot-instance_method
      def export_serverless_cache_snapshot: (
                                              serverless_cache_snapshot_name: ::String,
                                              s3_bucket_name: ::String
                                            ) -> _ExportServerlessCacheSnapshotResponseSuccess
                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ExportServerlessCacheSnapshotResponseSuccess

      interface _FailoverGlobalReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::FailoverGlobalReplicationGroupResult]
        def global_replication_group: () -> Types::GlobalReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#failover_global_replication_group-instance_method
      def failover_global_replication_group: (
                                               global_replication_group_id: ::String,
                                               primary_region: ::String,
                                               primary_replication_group_id: ::String
                                             ) -> _FailoverGlobalReplicationGroupResponseSuccess
                                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _FailoverGlobalReplicationGroupResponseSuccess

      interface _IncreaseNodeGroupsInGlobalReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::IncreaseNodeGroupsInGlobalReplicationGroupResult]
        def global_replication_group: () -> Types::GlobalReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#increase_node_groups_in_global_replication_group-instance_method
      def increase_node_groups_in_global_replication_group: (
                                                              global_replication_group_id: ::String,
                                                              node_group_count: ::Integer,
                                                              ?regional_configurations: Array[
                                                                {
                                                                  replication_group_id: ::String,
                                                                  replication_group_region: ::String,
                                                                  resharding_configuration: Array[
                                                                    {
                                                                      node_group_id: ::String?,
                                                                      preferred_availability_zones: Array[::String]?
                                                                    },
                                                                  ]
                                                                },
                                                              ],
                                                              apply_immediately: bool
                                                            ) -> _IncreaseNodeGroupsInGlobalReplicationGroupResponseSuccess
                                                          | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _IncreaseNodeGroupsInGlobalReplicationGroupResponseSuccess

      interface _IncreaseReplicaCountResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::IncreaseReplicaCountResult]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#increase_replica_count-instance_method
      def increase_replica_count: (
                                    replication_group_id: ::String,
                                    ?new_replica_count: ::Integer,
                                    ?replica_configuration: Array[
                                      {
                                        node_group_id: ::String,
                                        new_replica_count: ::Integer,
                                        preferred_availability_zones: Array[::String]?,
                                        preferred_outpost_arns: Array[::String]?
                                      },
                                    ],
                                    apply_immediately: bool
                                  ) -> _IncreaseReplicaCountResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _IncreaseReplicaCountResponseSuccess

      interface _ListAllowedNodeTypeModificationsResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::AllowedNodeTypeModificationsMessage]
        def scale_up_modifications: () -> ::Array[::String]
        def scale_down_modifications: () -> ::Array[::String]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#list_allowed_node_type_modifications-instance_method
      def list_allowed_node_type_modifications: (
                                                  ?cache_cluster_id: ::String,
                                                  ?replication_group_id: ::String
                                                ) -> _ListAllowedNodeTypeModificationsResponseSuccess
                                              | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListAllowedNodeTypeModificationsResponseSuccess

      interface _ListTagsForResourceResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TagListMessage]
        def tag_list: () -> ::Array[Types::Tag]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#list_tags_for_resource-instance_method
      def list_tags_for_resource: (
                                    resource_name: ::String
                                  ) -> _ListTagsForResourceResponseSuccess
                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ListTagsForResourceResponseSuccess

      interface _ModifyCacheClusterResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ModifyCacheClusterResult]
        def cache_cluster: () -> Types::CacheCluster
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_cache_cluster-instance_method
      def modify_cache_cluster: (
                                  cache_cluster_id: ::String,
                                  ?num_cache_nodes: ::Integer,
                                  ?cache_node_ids_to_remove: Array[::String],
                                  ?az_mode: ("single-az" | "cross-az"),
                                  ?new_availability_zones: Array[::String],
                                  ?cache_security_group_names: Array[::String],
                                  ?security_group_ids: Array[::String],
                                  ?preferred_maintenance_window: ::String,
                                  ?notification_topic_arn: ::String,
                                  ?cache_parameter_group_name: ::String,
                                  ?notification_topic_status: ::String,
                                  ?apply_immediately: bool,
                                  ?engine: ::String,
                                  ?engine_version: ::String,
                                  ?auto_minor_version_upgrade: bool,
                                  ?snapshot_retention_limit: ::Integer,
                                  ?snapshot_window: ::String,
                                  ?cache_node_type: ::String,
                                  ?auth_token: ::String,
                                  ?auth_token_update_strategy: ("SET" | "ROTATE" | "DELETE"),
                                  ?log_delivery_configurations: Array[
                                    {
                                      log_type: ("slow-log" | "engine-log")?,
                                      destination_type: ("cloudwatch-logs" | "kinesis-firehose")?,
                                      destination_details: {
                                        cloud_watch_logs_details: {
                                          log_group: ::String?
                                        }?,
                                        kinesis_firehose_details: {
                                          delivery_stream: ::String?
                                        }?
                                      }?,
                                      log_format: ("text" | "json")?,
                                      enabled: bool?
                                    },
                                  ],
                                  ?ip_discovery: ("ipv4" | "ipv6")
                                ) -> _ModifyCacheClusterResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyCacheClusterResponseSuccess

      interface _ModifyCacheParameterGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CacheParameterGroupNameMessage]
        def cache_parameter_group_name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_cache_parameter_group-instance_method
      def modify_cache_parameter_group: (
                                          cache_parameter_group_name: ::String,
                                          parameter_name_values: Array[
                                            {
                                              parameter_name: ::String?,
                                              parameter_value: ::String?
                                            },
                                          ]
                                        ) -> _ModifyCacheParameterGroupResponseSuccess
                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyCacheParameterGroupResponseSuccess

      interface _ModifyCacheSubnetGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ModifyCacheSubnetGroupResult]
        def cache_subnet_group: () -> Types::CacheSubnetGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_cache_subnet_group-instance_method
      def modify_cache_subnet_group: (
                                       cache_subnet_group_name: ::String,
                                       ?cache_subnet_group_description: ::String,
                                       ?subnet_ids: Array[::String]
                                     ) -> _ModifyCacheSubnetGroupResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyCacheSubnetGroupResponseSuccess

      interface _ModifyGlobalReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ModifyGlobalReplicationGroupResult]
        def global_replication_group: () -> Types::GlobalReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_global_replication_group-instance_method
      def modify_global_replication_group: (
                                             global_replication_group_id: ::String,
                                             apply_immediately: bool,
                                             ?cache_node_type: ::String,
                                             ?engine: ::String,
                                             ?engine_version: ::String,
                                             ?cache_parameter_group_name: ::String,
                                             ?global_replication_group_description: ::String,
                                             ?automatic_failover_enabled: bool
                                           ) -> _ModifyGlobalReplicationGroupResponseSuccess
                                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyGlobalReplicationGroupResponseSuccess

      interface _ModifyReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ModifyReplicationGroupResult]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_replication_group-instance_method
      def modify_replication_group: (
                                      replication_group_id: ::String,
                                      ?replication_group_description: ::String,
                                      ?primary_cluster_id: ::String,
                                      ?snapshotting_cluster_id: ::String,
                                      ?automatic_failover_enabled: bool,
                                      ?multi_az_enabled: bool,
                                      ?node_group_id: ::String,
                                      ?cache_security_group_names: Array[::String],
                                      ?security_group_ids: Array[::String],
                                      ?preferred_maintenance_window: ::String,
                                      ?notification_topic_arn: ::String,
                                      ?cache_parameter_group_name: ::String,
                                      ?notification_topic_status: ::String,
                                      ?apply_immediately: bool,
                                      ?engine: ::String,
                                      ?engine_version: ::String,
                                      ?auto_minor_version_upgrade: bool,
                                      ?snapshot_retention_limit: ::Integer,
                                      ?snapshot_window: ::String,
                                      ?cache_node_type: ::String,
                                      ?auth_token: ::String,
                                      ?auth_token_update_strategy: ("SET" | "ROTATE" | "DELETE"),
                                      ?user_group_ids_to_add: Array[::String],
                                      ?user_group_ids_to_remove: Array[::String],
                                      ?remove_user_groups: bool,
                                      ?log_delivery_configurations: Array[
                                        {
                                          log_type: ("slow-log" | "engine-log")?,
                                          destination_type: ("cloudwatch-logs" | "kinesis-firehose")?,
                                          destination_details: {
                                            cloud_watch_logs_details: {
                                              log_group: ::String?
                                            }?,
                                            kinesis_firehose_details: {
                                              delivery_stream: ::String?
                                            }?
                                          }?,
                                          log_format: ("text" | "json")?,
                                          enabled: bool?
                                        },
                                      ],
                                      ?ip_discovery: ("ipv4" | "ipv6"),
                                      ?transit_encryption_enabled: bool,
                                      ?transit_encryption_mode: ("preferred" | "required"),
                                      ?cluster_mode: ("enabled" | "disabled" | "compatible")
                                    ) -> _ModifyReplicationGroupResponseSuccess
                                  | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyReplicationGroupResponseSuccess

      interface _ModifyReplicationGroupShardConfigurationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ModifyReplicationGroupShardConfigurationResult]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_replication_group_shard_configuration-instance_method
      def modify_replication_group_shard_configuration: (
                                                          replication_group_id: ::String,
                                                          node_group_count: ::Integer,
                                                          apply_immediately: bool,
                                                          ?resharding_configuration: Array[
                                                            {
                                                              node_group_id: ::String?,
                                                              preferred_availability_zones: Array[::String]?
                                                            },
                                                          ],
                                                          ?node_groups_to_remove: Array[::String],
                                                          ?node_groups_to_retain: Array[::String]
                                                        ) -> _ModifyReplicationGroupShardConfigurationResponseSuccess
                                                      | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyReplicationGroupShardConfigurationResponseSuccess

      interface _ModifyServerlessCacheResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::ModifyServerlessCacheResponse]
        def serverless_cache: () -> Types::ServerlessCache
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_serverless_cache-instance_method
      def modify_serverless_cache: (
                                     serverless_cache_name: ::String,
                                     ?description: ::String,
                                     ?cache_usage_limits: {
                                       data_storage: {
                                         maximum: ::Integer?,
                                         minimum: ::Integer?,
                                         unit: ("GB")
                                       }?,
                                       ecpu_per_second: {
                                         maximum: ::Integer?,
                                         minimum: ::Integer?
                                       }?
                                     },
                                     ?remove_user_group: bool,
                                     ?user_group_id: ::String,
                                     ?security_group_ids: Array[::String],
                                     ?snapshot_retention_limit: ::Integer,
                                     ?daily_snapshot_time: ::String,
                                     ?engine: ::String,
                                     ?major_engine_version: ::String
                                   ) -> _ModifyServerlessCacheResponseSuccess
                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyServerlessCacheResponseSuccess

      interface _ModifyUserResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::User]
        def user_id: () -> ::String
        def user_name: () -> ::String
        def status: () -> ::String
        def engine: () -> ::String
        def minimum_engine_version: () -> ::String
        def access_string: () -> ::String
        def user_group_ids: () -> ::Array[::String]
        def authentication: () -> Types::Authentication
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_user-instance_method
      def modify_user: (
                         user_id: ::String,
                         ?access_string: ::String,
                         ?append_access_string: ::String,
                         ?passwords: Array[::String],
                         ?no_password_required: bool,
                         ?authentication_mode: {
                           type: ("password" | "no-password-required" | "iam")?,
                           passwords: Array[::String]?
                         }
                       ) -> _ModifyUserResponseSuccess
                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyUserResponseSuccess

      interface _ModifyUserGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::UserGroup]
        def user_group_id: () -> ::String
        def status: () -> ::String
        def engine: () -> ::String
        def user_ids: () -> ::Array[::String]
        def minimum_engine_version: () -> ::String
        def pending_changes: () -> Types::UserGroupPendingChanges
        def replication_groups: () -> ::Array[::String]
        def serverless_caches: () -> ::Array[::String]
        def arn: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#modify_user_group-instance_method
      def modify_user_group: (
                               user_group_id: ::String,
                               ?user_ids_to_add: Array[::String],
                               ?user_ids_to_remove: Array[::String]
                             ) -> _ModifyUserGroupResponseSuccess
                           | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyUserGroupResponseSuccess

      interface _PurchaseReservedCacheNodesOfferingResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::PurchaseReservedCacheNodesOfferingResult]
        def reserved_cache_node: () -> Types::ReservedCacheNode
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#purchase_reserved_cache_nodes_offering-instance_method
      def purchase_reserved_cache_nodes_offering: (
                                                    reserved_cache_nodes_offering_id: ::String,
                                                    ?reserved_cache_node_id: ::String,
                                                    ?cache_node_count: ::Integer,
                                                    ?tags: Array[
                                                      {
                                                        key: ::String?,
                                                        value: ::String?
                                                      },
                                                    ]
                                                  ) -> _PurchaseReservedCacheNodesOfferingResponseSuccess
                                                | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _PurchaseReservedCacheNodesOfferingResponseSuccess

      interface _RebalanceSlotsInGlobalReplicationGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RebalanceSlotsInGlobalReplicationGroupResult]
        def global_replication_group: () -> Types::GlobalReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#rebalance_slots_in_global_replication_group-instance_method
      def rebalance_slots_in_global_replication_group: (
                                                         global_replication_group_id: ::String,
                                                         apply_immediately: bool
                                                       ) -> _RebalanceSlotsInGlobalReplicationGroupResponseSuccess
                                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RebalanceSlotsInGlobalReplicationGroupResponseSuccess

      interface _RebootCacheClusterResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RebootCacheClusterResult]
        def cache_cluster: () -> Types::CacheCluster
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#reboot_cache_cluster-instance_method
      def reboot_cache_cluster: (
                                  cache_cluster_id: ::String,
                                  cache_node_ids_to_reboot: Array[::String]
                                ) -> _RebootCacheClusterResponseSuccess
                              | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RebootCacheClusterResponseSuccess

      interface _RemoveTagsFromResourceResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TagListMessage]
        def tag_list: () -> ::Array[Types::Tag]
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#remove_tags_from_resource-instance_method
      def remove_tags_from_resource: (
                                       resource_name: ::String,
                                       tag_keys: Array[::String]
                                     ) -> _RemoveTagsFromResourceResponseSuccess
                                   | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RemoveTagsFromResourceResponseSuccess

      interface _ResetCacheParameterGroupResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::CacheParameterGroupNameMessage]
        def cache_parameter_group_name: () -> ::String
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#reset_cache_parameter_group-instance_method
      def reset_cache_parameter_group: (
                                         cache_parameter_group_name: ::String,
                                         ?reset_all_parameters: bool,
                                         ?parameter_name_values: Array[
                                           {
                                             parameter_name: ::String?,
                                             parameter_value: ::String?
                                           },
                                         ]
                                       ) -> _ResetCacheParameterGroupResponseSuccess
                                     | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ResetCacheParameterGroupResponseSuccess

      interface _RevokeCacheSecurityGroupIngressResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::RevokeCacheSecurityGroupIngressResult]
        def cache_security_group: () -> Types::CacheSecurityGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#revoke_cache_security_group_ingress-instance_method
      def revoke_cache_security_group_ingress: (
                                                 cache_security_group_name: ::String,
                                                 ec2_security_group_name: ::String,
                                                 ec2_security_group_owner_id: ::String
                                               ) -> _RevokeCacheSecurityGroupIngressResponseSuccess
                                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RevokeCacheSecurityGroupIngressResponseSuccess

      interface _StartMigrationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::StartMigrationResponse]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#start_migration-instance_method
      def start_migration: (
                             replication_group_id: ::String,
                             customer_node_endpoint_list: Array[
                               {
                                 address: ::String?,
                                 port: ::Integer?
                               },
                             ]
                           ) -> _StartMigrationResponseSuccess
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _StartMigrationResponseSuccess

      interface _TestFailoverResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TestFailoverResult]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#test_failover-instance_method
      def test_failover: (
                           replication_group_id: ::String,
                           node_group_id: ::String
                         ) -> _TestFailoverResponseSuccess
                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TestFailoverResponseSuccess

      interface _TestMigrationResponseSuccess
        include ::Seahorse::Client::_ResponseSuccess[Types::TestMigrationResponse]
        def replication_group: () -> Types::ReplicationGroup
      end
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#test_migration-instance_method
      def test_migration: (
                            replication_group_id: ::String,
                            customer_node_endpoint_list: Array[
                              {
                                address: ::String?,
                                port: ::Integer?
                              },
                            ]
                          ) -> _TestMigrationResponseSuccess
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _TestMigrationResponseSuccess

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElastiCache/Client.html#wait_until-instance_method
      def wait_until: (:cache_cluster_available waiter_name, 
                    ?cache_cluster_id: ::String,
                    ?max_records: ::Integer,
                    ?marker: ::String,
                    ?show_cache_node_info: bool,
                    ?show_cache_clusters_not_in_replication_groups: bool
                  ) -> Client::_DescribeCacheClustersResponseSuccess
                    | (:cache_cluster_available waiter_name, ?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> Client::_DescribeCacheClustersResponseSuccess
                    | (:cache_cluster_deleted waiter_name, 
                    ?cache_cluster_id: ::String,
                    ?max_records: ::Integer,
                    ?marker: ::String,
                    ?show_cache_node_info: bool,
                    ?show_cache_clusters_not_in_replication_groups: bool
                  ) -> Client::_DescribeCacheClustersResponseSuccess
                    | (:cache_cluster_deleted waiter_name, ?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> Client::_DescribeCacheClustersResponseSuccess
                    | (:replication_group_available waiter_name, 
                    ?replication_group_id: ::String,
                    ?max_records: ::Integer,
                    ?marker: ::String
                  ) -> Client::_DescribeReplicationGroupsResponseSuccess
                    | (:replication_group_available waiter_name, ?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> Client::_DescribeReplicationGroupsResponseSuccess
                    | (:replication_group_deleted waiter_name, 
                    ?replication_group_id: ::String,
                    ?max_records: ::Integer,
                    ?marker: ::String
                  ) -> Client::_DescribeReplicationGroupsResponseSuccess
                    | (:replication_group_deleted waiter_name, ?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> Client::_DescribeReplicationGroupsResponseSuccess
    end
  end
end