RubyGems - pangea - Versions diffs - 0.0.45 → 0.0.46 - Mend

pangea 0.0.45 → 0.0.46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2051) hide show

data/lib/pangea/resources/aws_elasticache_cluster/CLAUDE.md DELETED Viewed

@@ -1,240 +0,0 @@
-# AWS ElastiCache Cluster Implementation
-## Overview
-The `aws_elasticache_cluster` resource provides a type-safe interface for managing AWS ElastiCache clusters supporting both Redis and Memcached engines with comprehensive validation and engine-specific optimizations.
-## Architecture
-### Type System
-The implementation uses `ElastiCacheClusterAttributes` dry-struct for validation:
-```ruby
-class ElastiCacheClusterAttributes < Dry::Struct
-  attribute :cluster_id, Types::String
-  attribute :engine, Types::String.enum("redis", "memcached")
-  attribute :node_type, Types::String.enum(/* comprehensive node type list */)
-  # ... additional attributes
-end
-```
-### Engine-Specific Validation
-The resource implements sophisticated validation logic that enforces engine-specific constraints:
-#### Redis Constraints
-- Single node clusters (replication groups handle scaling)
-- Auth tokens require transit encryption
-- At-rest encryption requires engine version 3.2.6+
-- Snapshot features only available for Redis
-#### Memcached Constraints
-- Multi-node cluster support (1-40 nodes)
-- No encryption capabilities
-- No backup/snapshot features
-- No authentication support
-### Node Type Support
-Comprehensive support for AWS ElastiCache node types across all families:
-- **Burstable Performance**: T4g, T3 instances for variable workloads
-- **General Purpose**: M6g, M5 instances for balanced compute/memory
-- **Memory Optimized**: R6g, R5 instances for memory-intensive applications
-## Key Features
-### 1. Multi-Engine Architecture
-```ruby
-def is_redis?
-  engine == "redis"
-end
-def is_memcached?
-  engine == "memcached"
-end
-```
-Engine detection enables conditional feature availability and validation.
-### 2. Encryption Support
-Redis-specific encryption with comprehensive validation:
-```ruby
-# Auth token requires transit encryption
-if attrs.auth_token && !attrs.transit_encryption_enabled
-  raise Dry::Struct::Error, "Auth token requires transit_encryption_enabled=true"
-end
-```
-### 3. Version Compatibility
-Engine version validation for encryption features:
-```ruby
-def engine_supports_encryption?
-  return false unless is_redis?
-  return true unless engine_version
-  version_parts = engine_version.split('.').map(&:to_i)
-  major, minor, patch = version_parts[0], version_parts[1], version_parts[2] || 0
-  major > 3 || (major == 3 && minor > 2) || (major == 3 && minor == 2 && patch >= 6)
-end
-```
-### 4. Multi-AZ Configuration
-Supports both single-AZ and multi-AZ deployments with appropriate validation:
-```ruby
-# Multi-AZ requires multiple nodes for Memcached
-if attrs.engine == "memcached" && attrs.preferred_availability_zones.any? && attrs.num_cache_nodes < 2
-  raise Dry::Struct::Error, "Multi-AZ deployment requires at least 2 cache nodes for Memcached"
-end
-```
-## Implementation Patterns
-### 1. Resource Function Structure
-The function follows Pangea's standard resource pattern:
-```ruby
-def aws_elasticache_cluster(name, attributes = {})
-  # 1. Validate attributes
-  cluster_attrs = ElastiCacheClusterAttributes.new(attributes)
-  # 2. Generate terraform resource
-  resource(:aws_elasticache_cluster, name) do
-    # Conditional configuration based on engine
-  end
-  # 3. Return ResourceReference
-  ResourceReference.new(...)
-end
-```
-### 2. Conditional Configuration
-Engine-specific terraform resource configuration:
-```ruby
-# Redis-specific configuration
-if cluster_attrs.is_redis?
-  snapshot_retention_limit cluster_attrs.snapshot_retention_limit if cluster_attrs.snapshot_retention_limit > 0
-  at_rest_encryption_enabled cluster_attrs.at_rest_encryption_enabled if cluster_attrs.at_rest_encryption_enabled
-end
-```
-### 3. Default Value Assignment
-Dynamic default value assignment based on engine:
-```ruby
-# Port default for Redis
-attrs = attrs.copy_with(port: attrs.port || 6379)
-```
-## Configuration Helpers
-### Pre-defined Configurations
-`ElastiCacheConfigs` module provides common configurations:
-```ruby
-module ElastiCacheConfigs
-  def self.redis(version: "7.0", node_type: "cache.t4g.micro")
-    {
-      engine: "redis",
-      engine_version: version,
-      node_type: node_type,
-      at_rest_encryption_enabled: true,
-      transit_encryption_enabled: true
-    }
-  end
-end
-```
-### Cost Estimation
-Built-in cost estimation based on node type and configuration:
-```ruby
-def estimated_monthly_cost
-  hourly_rate = case node_type
-               when /t4g.micro/ then 0.032
-               when /r6g.large/ then 0.101
-               # ... additional mappings
-               end
-  total_cost = hourly_rate * 730 * num_cache_nodes
-  "~$#{total_cost.round(2)}/month"
-end
-```
-## Resource Outputs
-The resource provides comprehensive outputs for integration:
-```ruby
-outputs: {
-  id: "${aws_elasticache_cluster.#{name}.id}",
-  cluster_address: "${aws_elasticache_cluster.#{name}.cluster_address}",
-  configuration_endpoint: "${aws_elasticache_cluster.#{name}.configuration_endpoint}",
-  port: "${aws_elasticache_cluster.#{name}.port}",
-  cache_nodes: "${aws_elasticache_cluster.#{name}.cache_nodes}"
-}
-```
-## Computed Properties
-Rich computed properties for infrastructure logic:
-```ruby
-computed_properties: {
-  is_redis: cluster_attrs.is_redis?,
-  supports_encryption: cluster_attrs.supports_encryption?,
-  engine_supports_encryption: cluster_attrs.engine_supports_encryption?,
-  estimated_monthly_cost: cluster_attrs.estimated_monthly_cost
-}
-```
-## Best Practices Encoded
-### 1. Security by Default
-- Encryption enabled by default for Redis
-- Auth token validation
-- Security group requirement validation
-### 2. Engine Optimization
-- Single-node Redis for replication group compatibility
-- Multi-node Memcached for distribution
-- Engine-specific port defaults
-### 3. Cost Awareness
-- Instance type validation
-- Cost estimation helpers
-- Right-sizing guidance
-## Integration Points
-### Network Integration
-- Subnet group requirement for VPC placement
-- Security group integration for access control
-- Multi-AZ placement support
-### Monitoring Integration
-- CloudWatch logs delivery configuration
-- Performance insights support
-- Notification topic integration
-### Backup Integration
-- Redis snapshot configuration
-- Automated backup retention
-- Final snapshot management
-This implementation provides a production-ready, type-safe interface for ElastiCache clusters with comprehensive validation, engine-specific optimizations, and integration capabilities.

data/lib/pangea/resources/aws_elasticache_cluster/resource.rb DELETED Viewed

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-require 'pangea/resources/base'
-require 'pangea/resources/reference'
-require 'pangea/resources/aws_elasticache_cluster/types'
-require 'pangea/resource_registry'
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS ElastiCache Cluster with type-safe attributes
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] ElastiCache cluster attributes
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      def aws_elasticache_cluster(name, attributes = {})
-        # Validate attributes using dry-struct
-        cluster_attrs = AWS::Types::Types::ElastiCacheClusterAttributes.new(attributes)
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_elasticache_cluster, name) do
-          cluster_id cluster_attrs.cluster_id
-          engine cluster_attrs.engine
-          node_type cluster_attrs.node_type
-          num_cache_nodes cluster_attrs.num_cache_nodes
-          # Engine configuration
-          engine_version cluster_attrs.engine_version if cluster_attrs.engine_version
-          parameter_group_name cluster_attrs.parameter_group_name if cluster_attrs.parameter_group_name
-          port cluster_attrs.port if cluster_attrs.port
-          # Network configuration
-          subnet_group_name cluster_attrs.subnet_group_name if cluster_attrs.subnet_group_name
-          security_group_ids cluster_attrs.security_group_ids if cluster_attrs.security_group_ids.any?
-          # Availability zone configuration
-          availability_zone cluster_attrs.availability_zone if cluster_attrs.availability_zone
-          if cluster_attrs.preferred_availability_zones.any?
-            preferred_availability_zones cluster_attrs.preferred_availability_zones
-          end
-          # Maintenance configuration
-          maintenance_window cluster_attrs.maintenance_window if cluster_attrs.maintenance_window
-          notification_topic_arn cluster_attrs.notification_topic_arn if cluster_attrs.notification_topic_arn
-          auto_minor_version_upgrade cluster_attrs.auto_minor_version_upgrade
-          apply_immediately cluster_attrs.apply_immediately
-          # Redis-specific configuration
-          if cluster_attrs.is_redis?
-            # Snapshot configuration
-            snapshot_arns cluster_attrs.snapshot_arns if cluster_attrs.snapshot_arns
-            snapshot_name cluster_attrs.snapshot_name if cluster_attrs.snapshot_name
-            snapshot_window cluster_attrs.snapshot_window if cluster_attrs.snapshot_window
-            snapshot_retention_limit cluster_attrs.snapshot_retention_limit if cluster_attrs.snapshot_retention_limit > 0
-            final_snapshot_identifier cluster_attrs.final_snapshot_identifier if cluster_attrs.final_snapshot_identifier
-            # Encryption configuration
-            at_rest_encryption_enabled cluster_attrs.at_rest_encryption_enabled if cluster_attrs.at_rest_encryption_enabled
-            transit_encryption_enabled cluster_attrs.transit_encryption_enabled if cluster_attrs.transit_encryption_enabled
-            auth_token cluster_attrs.auth_token if cluster_attrs.auth_token
-          end
-          # Log delivery configuration
-          if cluster_attrs.log_delivery_configuration.any?
-            cluster_attrs.log_delivery_configuration.each_with_index do |log_config, index|
-              log_delivery_configuration do
-                destination log_config[:destination]
-                destination_type log_config[:destination_type]
-                log_format log_config[:log_format]
-                log_type log_config[:log_type]
-              end
-            end
-          end
-          # Apply tags if present
-          if cluster_attrs.tags.any?
-            tags do
-              cluster_attrs.tags.each do |key, value|
-                public_send(key, value)
-              end
-            end
-          end
-        end
-        # Create resource reference
-        ref = ResourceReference.new(
-          type: 'aws_elasticache_cluster',
-          name: name,
-          resource_attributes: cluster_attrs.to_h,
-          outputs: {
-            id: "${aws_elasticache_cluster.#{name}.id}",
-            arn: "${aws_elasticache_cluster.#{name}.arn}",
-            cluster_address: "${aws_elasticache_cluster.#{name}.cluster_address}",
-            configuration_endpoint: "${aws_elasticache_cluster.#{name}.configuration_endpoint}",
-            port: "${aws_elasticache_cluster.#{name}.port}",
-            cache_nodes: "${aws_elasticache_cluster.#{name}.cache_nodes}",
-            engine_version_actual: "${aws_elasticache_cluster.#{name}.engine_version_actual}",
-            tags_all: "${aws_elasticache_cluster.#{name}.tags_all}"
-          }
-        )
-        # Add computed properties via method delegation
-        ref.define_singleton_method(:is_redis?) { cluster_attrs.is_redis? }
-        ref.define_singleton_method(:is_memcached?) { cluster_attrs.is_memcached? }
-        ref.define_singleton_method(:default_port) { cluster_attrs.default_port }
-        ref.define_singleton_method(:supports_encryption?) { cluster_attrs.supports_encryption? }
-        ref.define_singleton_method(:supports_backup?) { cluster_attrs.supports_backup? }
-        ref.define_singleton_method(:supports_auth?) { cluster_attrs.supports_auth? }
-        ref.define_singleton_method(:engine_supports_encryption?) { cluster_attrs.engine_supports_encryption? }
-        ref.define_singleton_method(:is_cluster_mode?) { cluster_attrs.is_cluster_mode? }
-        ref.define_singleton_method(:estimated_monthly_cost) { cluster_attrs.estimated_monthly_cost }
-        ref
-      end
-    end
-  end
-end
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

data/lib/pangea/resources/aws_elasticache_cluster/types.rb DELETED Viewed

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-require 'dry-struct'
-require 'pangea/resources/types'
-module Pangea
-  module Resources
-    module AWS
-      module Types
-        # Type-safe attributes for AWS ElastiCache Cluster resources
-        class ElastiCacheClusterAttributes < Dry::Struct
-          transform_keys(&:to_sym)
-          # Cluster identifier (required)
-          attribute :cluster_id, Pangea::Resources::Types::String
-          # Engine type
-          attribute :engine, Pangea::Resources::Types::String.constrained(included_in: ["redis", "memcached"])
-          # Node type (instance class)
-          attribute :node_type, Pangea::Resources::Types::String.constrained(included_in: [
-            # Burstable Performance
-            "cache.t4g.nano", "cache.t4g.micro", "cache.t4g.small", "cache.t4g.medium",
-            "cache.t3.micro", "cache.t3.small", "cache.t3.medium",
-            # General Purpose
-            "cache.m6g.large", "cache.m6g.xlarge", "cache.m6g.2xlarge", "cache.m6g.4xlarge",
-            "cache.m6g.8xlarge", "cache.m6g.12xlarge", "cache.m6g.16xlarge",
-            "cache.m5.large", "cache.m5.xlarge", "cache.m5.2xlarge", "cache.m5.4xlarge",
-            "cache.m5.12xlarge", "cache.m5.24xlarge",
-            # Memory Optimized
-            "cache.r6g.large", "cache.r6g.xlarge", "cache.r6g.2xlarge", "cache.r6g.4xlarge",
-            "cache.r6g.8xlarge", "cache.r6g.12xlarge", "cache.r6g.16xlarge",
-            "cache.r5.large", "cache.r5.xlarge", "cache.r5.2xlarge", "cache.r5.4xlarge",
-            "cache.r5.12xlarge", "cache.r5.24xlarge"
-          ])
-          # Number of cache nodes (Memcached only, Redis uses num_cache_nodes=1 and replication_group for scaling)
-          attribute :num_cache_nodes, Pangea::Resources::Types::Integer.default(1).constrained(gteq: 1, lteq: 40)
-          # Engine version (optional, uses default if not specified)
-          attribute? :engine_version, Pangea::Resources::Types::String.optional
-          # Parameter group name
-          attribute? :parameter_group_name, Pangea::Resources::Types::String.optional
-          # Port number
-          attribute? :port, Pangea::Resources::Types::Integer.optional.constrained(gteq: 1024, lteq: 65535)
-          # Subnet group name
-          attribute? :subnet_group_name, Pangea::Resources::Types::String.optional
-          # Security group IDs
-          attribute :security_group_ids, Pangea::Resources::Types::Array.of(Pangea::Resources::Types::String).default([].freeze)
-          # Availability zone (single AZ placement)
-          attribute? :availability_zone, Pangea::Resources::Types::String.optional
-          # Preferred availability zones (for multi-AZ)
-          attribute :preferred_availability_zones, Pangea::Resources::Types::Array.of(Pangea::Resources::Types::String).default([].freeze)
-          # Maintenance window
-          attribute? :maintenance_window, Pangea::Resources::Types::String.optional  # Format: "ddd:hh24:mi-ddd:hh24:mi"
-          # Notification topic ARN
-          attribute? :notification_topic_arn, Pangea::Resources::Types::String.optional
-          # Auto minor version upgrade
-          attribute :auto_minor_version_upgrade, Pangea::Resources::Types::Bool.default(true)
-          # Snapshot configuration (Redis only)
-          attribute? :snapshot_arns, Pangea::Resources::Types::Array.of(Pangea::Resources::Types::String).optional
-          attribute? :snapshot_name, Pangea::Resources::Types::String.optional
-          attribute? :snapshot_window, Pangea::Resources::Types::String.optional  # Format: "hh24:mi-hh24:mi"
-          attribute :snapshot_retention_limit, Pangea::Resources::Types::Integer.default(0).constrained(gteq: 0, lteq: 35)
-          # Log delivery configuration
-          attribute :log_delivery_configuration, Pangea::Resources::Types::Array.of(Pangea::Resources::Types::Hash).default([].freeze)
-          # Transit encryption (Redis 6.0+ only)
-          attribute? :transit_encryption_enabled, Pangea::Resources::Types::Bool.optional
-          # At-rest encryption (Redis only)
-          attribute? :at_rest_encryption_enabled, Pangea::Resources::Types::Bool.optional
-          # Auth token (Redis only, requires transit encryption)
-          attribute? :auth_token, Pangea::Resources::Types::String.optional
-          # Apply changes immediately
-          attribute :apply_immediately, Pangea::Resources::Types::Bool.default(false)
-          # Tags to apply to the cluster
-          attribute :tags, Pangea::Resources::Types::Hash.default({})
-          # Final snapshot identifier (Redis only)
-          attribute? :final_snapshot_identifier, Pangea::Resources::Types::String.optional
-          # Custom validation
-          def self.new(attributes = {})
-            attrs = super(attributes)
-            # Engine-specific validations
-            if attrs.engine == "redis"
-              # Redis specific validations
-              if attrs.num_cache_nodes > 1
-                raise Dry::Struct::Error, "Redis clusters should use num_cache_nodes=1 and replication groups for scaling"
-              end
-              # Auth token requires transit encryption
-              if attrs.auth_token && !attrs.transit_encryption_enabled
-                raise Dry::Struct::Error, "Auth token requires transit_encryption_enabled=true"
-              end
-              # Encryption validations
-              if attrs.at_rest_encryption_enabled && !attrs.engine_supports_encryption?
-                raise Dry::Struct::Error, "At-rest encryption requires Redis 3.2.6 or later"
-              end
-              # Port default for Redis
-              attrs = attrs.copy_with(port: attrs.port || 6379)
-            elsif attrs.engine == "memcached"
-              # Memcached specific validations
-              if attrs.snapshot_arns || attrs.snapshot_name || attrs.snapshot_window || attrs.snapshot_retention_limit > 0
-                raise Dry::Struct::Error, "Snapshot configuration is only available for Redis"
-              end
-              if attrs.transit_encryption_enabled || attrs.at_rest_encryption_enabled
-                raise Dry::Struct::Error, "Encryption is only available for Redis"
-              end
-              if attrs.auth_token
-                raise Dry::Struct::Error, "Auth token is only available for Redis"
-              end
-              if attrs.final_snapshot_identifier
-                raise Dry::Struct::Error, "Final snapshot is only available for Redis"
-              end
-              # Port default for Memcached
-              attrs = attrs.copy_with(port: attrs.port || 11211)
-            end
-            # AZ validations
-            if attrs.availability_zone && attrs.preferred_availability_zones.any?
-              raise Dry::Struct::Error, "Cannot specify both availability_zone and preferred_availability_zones"
-            end
-            # Multi-AZ requires multiple nodes for Memcached
-            if attrs.engine == "memcached" && attrs.preferred_availability_zones.any? && attrs.num_cache_nodes < 2
-              raise Dry::Struct::Error, "Multi-AZ deployment requires at least 2 cache nodes for Memcached"
-            end
-            attrs
-          end
-          # Helper methods
-          def is_redis?
-            engine == "redis"
-          end
-          def is_memcached?
-            engine == "memcached"
-          end
-          def default_port
-            is_redis? ? 6379 : 11211
-          end
-          def supports_encryption?
-            is_redis?
-          end
-          def supports_backup?
-            is_redis?
-          end
-          def supports_auth?
-            is_redis?
-          end
-          def engine_supports_encryption?
-            # Redis 3.2.6+ supports at-rest encryption
-            return false unless is_redis?
-            return true unless engine_version  # Assume latest version supports it
-            version_parts = engine_version.split('.').map(&:to_i)
-            major, minor, patch = version_parts[0], version_parts[1], version_parts[2] || 0
-            major > 3 || (major == 3 && minor > 2) || (major == 3 && minor == 2 && patch >= 6)
-          end
-          def is_cluster_mode?
-            # This would be true for Redis Cluster mode (replication groups)
-            # For single-node clusters, this is false
-            false
-          end
-          def estimated_monthly_cost
-            # Base hourly rates for different node types (simplified)
-            hourly_rate = case node_type
-                         when /t4g.nano/ then 0.016
-                         when /t4g.micro/ then 0.032
-                         when /t4g.small/ then 0.064
-                         when /t4g.medium/ then 0.128
-                         when /t3.micro/ then 0.017
-                         when /t3.small/ then 0.034
-                         when /t3.medium/ then 0.068
-                         when /m6g.large/ then 0.077
-                         when /m6g.xlarge/ then 0.154
-                         when /m5.large/ then 0.083
-                         when /m5.xlarge/ then 0.166
-                         when /r6g.large/ then 0.101
-                         when /r6g.xlarge/ then 0.202
-                         when /r5.large/ then 0.126
-                         when /r5.xlarge/ then 0.252
-                         else 0.100  # Default estimate
-                         end
-            # Monthly cost (730 hours) * number of nodes
-            total_cost = hourly_rate * 730 * num_cache_nodes
-            "~$#{total_cost.round(2)}/month"
-          end
-        end
-        # Common ElastiCache configurations
-        module ElastiCacheConfigs
-          # Redis default configuration
-          def self.redis(version: "7.0", node_type: "cache.t4g.micro")
-            {
-              engine: "redis",
-              engine_version: version,
-              node_type: node_type,
-              num_cache_nodes: 1,
-              port: 6379,
-              at_rest_encryption_enabled: true,
-              transit_encryption_enabled: true,
-              auto_minor_version_upgrade: true
-            }
-          end
-          # Memcached default configuration
-          def self.memcached(version: "1.6.17", node_type: "cache.t4g.micro", num_nodes: 2)
-            {
-              engine: "memcached",
-              engine_version: version,
-              node_type: node_type,
-              num_cache_nodes: num_nodes,
-              port: 11211,
-              auto_minor_version_upgrade: true
-            }
-          end
-          # High-performance Redis configuration
-          def self.redis_high_performance(node_type: "cache.r6g.large")
-            {
-              engine: "redis",
-              engine_version: "7.0",
-              node_type: node_type,
-              num_cache_nodes: 1,
-              port: 6379,
-              at_rest_encryption_enabled: true,
-              transit_encryption_enabled: true,
-              snapshot_retention_limit: 7,
-              auto_minor_version_upgrade: false  # Control upgrades manually
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pangea/resources/aws_elasticache_cluster/types.rbs DELETED Viewed

@@ -1,41 +0,0 @@
-# RBS type definitions for AWS ElastiCache Cluster types
-module Pangea
-  module Resources
-    module AWS
-      class ElastiCacheClusterAttributes < Dry::Struct
-        attr_reader cluster_id: String
-        attr_reader engine: String
-        attr_reader node_type: String
-        attr_reader num_cache_nodes: Integer
-        attr_reader engine_version: String?
-        attr_reader parameter_group_name: String?
-        attr_reader port: Integer?
-        attr_reader subnet_group_name: String?
-        attr_reader security_group_ids: Array[String]
-        attr_reader preferred_availability_zones: Array[String]
-        attr_reader auto_minor_version_upgrade: bool
-        attr_reader snapshot_retention_limit: Integer
-        attr_reader log_delivery_configuration: Array[Hash[Symbol, untyped]]
-        attr_reader apply_immediately: bool
-        attr_reader tags: Hash[Symbol, String]
-        def is_redis?: () -> bool
-        def is_memcached?: () -> bool
-        def default_port: () -> Integer
-        def supports_encryption?: () -> bool
-        def supports_backup?: () -> bool
-        def supports_auth?: () -> bool
-        def engine_supports_encryption?: () -> bool
-        def is_cluster_mode?: () -> bool
-        def estimated_monthly_cost: () -> String
-      end
-      module ElastiCacheConfigs
-        def self.redis: (?version: String, ?node_type: String) -> Hash[Symbol, untyped]
-        def self.memcached: (?version: String, ?node_type: String, ?num_nodes: Integer) -> Hash[Symbol, untyped]
-        def self.redis_high_performance: (?node_type: String) -> Hash[Symbol, untyped]
-      end
-    end
-  end
-end