pangea 0.0.42 → 0.0.45

data/lib/pangea/resources/aws_rds_cluster_endpoint/CLAUDE.md

@@ -0,0 +1,279 @@
+# AWS RDS Cluster Endpoint Implementation
+
+## Resource Overview
+
+The `aws_rds_cluster_endpoint` resource implements Aurora cluster custom endpoints with type-safe attributes and advanced validation. This resource provides fine-grained connection routing capabilities for Aurora clusters.
+
+## Implementation Details
+
+### Type Safety and Validation
+
+**Core Validation Rules:**
+- Endpoint identifier must start with a letter and contain only letters, numbers, and hyphens
+- Maximum endpoint identifier length of 63 characters
+- DB instances cannot appear in both static_members and excluded_members
+- WRITER endpoints cannot use static or excluded member configurations (AWS restriction)
+- Validates custom_endpoint_type enum values (READER, WRITER, ANY)
+
+**Dry-Struct Types:**
+- `ExcludedMember` - Validates excluded cluster member configuration
+- `StaticMember` - Validates static cluster member configuration  
+- `RdsClusterEndpointAttributes` - Main attribute struct with comprehensive validation
+
+### Advanced Features
+
+**Member Selection Logic:**
+- Static members: Always include specific DB instances in routing
+- Excluded members: Never route to specific DB instances
+- Default behavior: Use Aurora's automatic member selection
+- Cross-validation prevents conflicting member configurations
+
+**Endpoint Type Behaviors:**
+- READER: Routes only to read replicas, supports member selection
+- WRITER: Routes only to primary, no member selection allowed
+- ANY: Routes to any available member, supports member selection
+
+**Configuration Intelligence:**
+- Automatic validation of endpoint type and member configuration compatibility
+- DNS name generation for connection string construction
+- Configuration summary generation for documentation and monitoring
+
+### Database-Specific Validations
+
+**Aurora Cluster Integration:**
+- Validates cluster identifier format and requirements
+- Provides method for external DB instance validation (validate_db_instances)
+- Generates cluster-aware DNS names for endpoints
+- Integrates with Aurora cluster member management
+
+**Connection Routing Validation:**
+- Ensures endpoint configuration aligns with Aurora's routing capabilities
+- Validates member selection against Aurora cluster constraints
+- Prevents configuration conflicts that would cause AWS API errors
+
+### Production Database Patterns
+
+**High Availability Support:**
+- Failover endpoint configuration with primary exclusion
+- Regional disaster recovery endpoint patterns
+- Load balancing endpoints for multi-AZ deployments
+- Dedicated instance routing for specialized workloads
+
+**Performance Optimization:**
+- Analytics endpoint patterns for heavy read workloads
+- Static member routing for consistent performance
+- Instance type-aware routing configurations
+- Connection pooling optimization endpoints
+
+**Operational Excellence:**
+- Comprehensive configuration summary for monitoring
+- Cost estimation (endpoints are typically free with Aurora)
+- Tag-based organization and management
+- Integration with cluster lifecycle management
+
+## Architecture Integration
+
+### Multi-Tier Applications
+
+```ruby
+# Example: Three-tier application with dedicated endpoints
+template :multi_tier_endpoints do
+  # Web application endpoint - load balanced across all members
+  web_endpoint = aws_rds_cluster_endpoint(:web_tier, {
+    cluster_identifier: cluster_ref,
+    cluster_endpoint_identifier: "web-tier",
+    custom_endpoint_type: "ANY",
+    tags: { Tier: "web", Purpose: "application" }
+  })
+
+  # Analytics endpoint - dedicated read replicas only
+  analytics_endpoint = aws_rds_cluster_endpoint(:analytics, {
+    cluster_identifier: cluster_ref,
+    cluster_endpoint_identifier: "analytics",
+    custom_endpoint_type: "READER",
+    static_members: analytics_instance_refs,
+    tags: { Tier: "analytics", Purpose: "reporting" }
+  })
+
+  # Admin endpoint - writer access for administration
+  admin_endpoint = aws_rds_cluster_endpoint(:admin, {
+    cluster_identifier: cluster_ref,
+    cluster_endpoint_identifier: "admin",
+    custom_endpoint_type: "WRITER",
+    tags: { Tier: "admin", Purpose: "management" }
+  })
+end
+```
+
+### Disaster Recovery Patterns
+
+```ruby
+# Example: Cross-region disaster recovery endpoint
+template :disaster_recovery_endpoints do
+  # Primary region endpoint excluding DR instances
+  primary_endpoint = aws_rds_cluster_endpoint(:primary, {
+    cluster_identifier: global_cluster_ref,
+    cluster_endpoint_identifier: "primary-region",
+    custom_endpoint_type: "READER",
+    excluded_members: dr_instance_refs,
+    tags: { Region: "primary", Purpose: "active" }
+  })
+
+  # DR endpoint for failover scenarios
+  dr_endpoint = aws_rds_cluster_endpoint(:disaster_recovery, {
+    cluster_identifier: global_cluster_ref,
+    cluster_endpoint_identifier: "dr-region",
+    custom_endpoint_type: "READER",
+    static_members: dr_instance_refs,
+    tags: { Region: "secondary", Purpose: "disaster-recovery" }
+  })
+end
+```
+
+## Testing and Validation
+
+### Type Safety Testing
+
+The implementation provides comprehensive type safety through:
+- Dry-struct validation for all input parameters
+- Custom validation logic for AWS-specific constraints  
+- Runtime type checking with meaningful error messages
+- Integration validation with cluster and instance configurations
+
+### Configuration Validation
+
+**Pre-deployment Validation:**
+- Member selection conflict detection
+- Endpoint type and configuration compatibility checking
+- Cluster identifier and naming convention validation
+- Tag validation for organizational compliance
+
+**Runtime Validation:**
+- DB instance existence validation (when cluster data available)
+- Member selection effectiveness validation
+- Performance impact assessment for endpoint configurations
+
+### Error Handling
+
+**Common Configuration Errors:**
+- Invalid endpoint type and member selection combinations
+- DB instance references that don't exist in the cluster
+- Endpoint identifier naming violations
+- Tag format and compliance issues
+
+**Error Recovery:**
+- Clear error messages with specific validation failures
+- Suggestions for configuration fixes
+- Reference to AWS documentation for complex constraints
+- Integration with Pangea's error reporting system
+
+## Performance Considerations
+
+### Connection Routing Optimization
+
+**Endpoint Selection Strategy:**
+- Use READER endpoints for read-heavy workloads
+- Use WRITER endpoints sparingly for admin operations
+- Use ANY endpoints for balanced mixed workloads
+- Use static members for consistent performance requirements
+
+**Instance Distribution:**
+- Balance static member selection across availability zones
+- Consider instance types when creating static member groups
+- Exclude overloaded instances during peak periods
+- Rotate endpoint usage to prevent hotspots
+
+### Monitoring and Observability
+
+**Endpoint Metrics:**
+- Connection count per endpoint
+- Query performance by endpoint type
+- Instance utilization within endpoint groups
+- Failover behavior and recovery times
+
+**Configuration Tracking:**
+- Endpoint lifecycle management
+- Member selection changes over time
+- Performance impact of routing decisions
+- Cost allocation by endpoint usage
+
+## Security Considerations
+
+### Access Control
+
+**Network Security:**
+- Custom endpoints inherit cluster security group settings
+- Additional security groups can be applied at the cluster level
+- VPC and subnet restrictions apply to all endpoints
+- SSL/TLS settings inherited from cluster configuration
+
+**Authentication and Authorization:**
+- Endpoint-specific user management not supported (cluster-level only)
+- IAM database authentication applies to all endpoints
+- Connection string security for different endpoint types
+- Audit logging includes endpoint-specific connection details
+
+### Compliance Requirements
+
+**Data Protection:**
+- Endpoints inherit cluster encryption settings
+- Audit trail includes endpoint-specific access patterns
+- Compliance reporting includes endpoint usage data
+- Data residency requirements apply to endpoint routing
+
+## Common Pitfalls and Solutions
+
+### Configuration Mistakes
+
+**Pitfall: WRITER endpoints with member selection**
+```ruby
+# INCORRECT - will cause validation error
+aws_rds_cluster_endpoint(:bad_writer, {
+  custom_endpoint_type: "WRITER",
+  static_members: [{ db_instance_identifier: "some-instance" }]  # Not allowed
+})
+
+# CORRECT - WRITER endpoints use default routing
+aws_rds_cluster_endpoint(:good_writer, {
+  custom_endpoint_type: "WRITER"
+})
+```
+
+**Pitfall: Conflicting member configurations**
+```ruby
+# INCORRECT - same instance in both lists
+aws_rds_cluster_endpoint(:conflicted, {
+  custom_endpoint_type: "READER",
+  static_members: [{ db_instance_identifier: "instance-1" }],
+  excluded_members: [{ db_instance_identifier: "instance-1" }]  # Conflict
+})
+```
+
+**Pitfall: Invalid endpoint identifiers**
+```ruby
+# INCORRECT - starts with number
+aws_rds_cluster_endpoint(:bad_name, {
+  cluster_endpoint_identifier: "1-endpoint"  # Invalid
+})
+
+# CORRECT - starts with letter
+aws_rds_cluster_endpoint(:good_name, {
+  cluster_endpoint_identifier: "endpoint-1"
+})
+```
+
+### Performance Issues
+
+**Solution: Instance Type Awareness**
+- Match endpoint routing to instance capabilities
+- Use high-memory instances for analytics endpoints
+- Use general-purpose instances for balanced workloads
+- Consider network performance for distributed applications
+
+**Solution: Connection Pool Management**
+- Configure application connection pools per endpoint
+- Monitor connection distribution across endpoints
+- Implement connection retry logic for endpoint failovers
+- Use appropriate connection pool sizes for endpoint types
+
+This implementation provides a robust, type-safe interface for Aurora cluster endpoints with comprehensive validation, clear error handling, and production-ready patterns for high-availability database architectures.

data/lib/pangea/resources/aws_rds_cluster_endpoint/resource.rb

@@ -0,0 +1,96 @@
+# 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_rds_cluster_endpoint/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS RDS Cluster Endpoint with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] RDS cluster endpoint attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_rds_cluster_endpoint(name, attributes = {})
+        # Validate attributes using dry-struct
+        endpoint_attrs = Types::RdsClusterEndpointAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_rds_cluster_endpoint, name) do
+          cluster_identifier endpoint_attrs.cluster_identifier
+          cluster_endpoint_identifier endpoint_attrs.cluster_endpoint_identifier
+          custom_endpoint_type endpoint_attrs.custom_endpoint_type
+          
+          # Static members configuration
+          if endpoint_attrs.static_members.any?
+            static_members endpoint_attrs.static_members.map(&:db_instance_identifier)
+          end
+          
+          # Excluded members configuration
+          if endpoint_attrs.excluded_members.any?
+            excluded_members endpoint_attrs.excluded_members.map(&:db_instance_identifier)
+          end
+          
+          # Apply tags if present
+          if endpoint_attrs.tags.any?
+            tags do
+              endpoint_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_rds_cluster_endpoint',
+          name: name,
+          resource_attributes: endpoint_attrs.to_h,
+          outputs: {
+            id: "${aws_rds_cluster_endpoint.#{name}.id}",
+            arn: "${aws_rds_cluster_endpoint.#{name}.arn}",
+            cluster_identifier: "${aws_rds_cluster_endpoint.#{name}.cluster_identifier}",
+            cluster_endpoint_identifier: "${aws_rds_cluster_endpoint.#{name}.cluster_endpoint_identifier}",
+            custom_endpoint_type: "${aws_rds_cluster_endpoint.#{name}.custom_endpoint_type}",
+            endpoint: "${aws_rds_cluster_endpoint.#{name}.endpoint}",
+            static_members: "${aws_rds_cluster_endpoint.#{name}.static_members}",
+            excluded_members: "${aws_rds_cluster_endpoint.#{name}.excluded_members}",
+            tags: "${aws_rds_cluster_endpoint.#{name}.tags}",
+            tags_all: "${aws_rds_cluster_endpoint.#{name}.tags_all}"
+          },
+          computed_properties: {
+            is_reader: endpoint_attrs.is_reader?,
+            is_writer: endpoint_attrs.is_writer?,
+            is_any: endpoint_attrs.is_any?,
+            has_static_members: endpoint_attrs.has_static_members?,
+            has_excluded_members: endpoint_attrs.has_excluded_members?,
+            static_member_db_ids: endpoint_attrs.static_member_db_ids,
+            excluded_member_db_ids: endpoint_attrs.excluded_member_db_ids,
+            uses_custom_member_config: endpoint_attrs.uses_custom_member_config?,
+            configuration_summary: endpoint_attrs.configuration_summary,
+            estimated_monthly_cost: endpoint_attrs.estimated_monthly_cost
+          }
+        )
+      end
+    end
+  end
+end
+
+# Auto-register this module when it's loaded
+Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

data/lib/pangea/resources/aws_rds_cluster_endpoint/types.rb

@@ -0,0 +1,254 @@
+# 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/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+      # Excluded cluster member configuration for Aurora endpoints
+      class ExcludedMember < Dry::Struct
+        # The DB instance identifier for the cluster member to exclude
+        attribute :db_instance_identifier, Resources::Types::String
+      end
+
+      # Static cluster member configuration for Aurora endpoints  
+      class StaticMember < Dry::Struct
+        # The DB instance identifier for the static cluster member
+        attribute :db_instance_identifier, Resources::Types::String
+      end
+
+      # Type-safe attributes for AWS RDS Cluster Endpoint resources
+      class RdsClusterEndpointAttributes < Dry::Struct
+        # Cluster identifier that the endpoint will belong to
+        attribute :cluster_identifier, Resources::Types::String
+
+        # Cluster endpoint identifier (unique within the cluster)
+        attribute :cluster_endpoint_identifier, Resources::Types::String
+
+        # Custom endpoint type (READER, WRITER, ANY)
+        attribute :custom_endpoint_type, Resources::Types::String.enum("READER", "WRITER", "ANY")
+
+        # List of static cluster members to include in the endpoint
+        # These members will always be included regardless of their role
+        attribute :static_members, Resources::Types::Array.of(StaticMember).default([].freeze)
+
+        # List of cluster members to exclude from the endpoint
+        # These members will never be included in load balancing
+        attribute :excluded_members, Resources::Types::Array.of(ExcludedMember).default([].freeze)
+
+        # Tags to apply to the cluster endpoint
+        attribute :tags, Resources::Types::AwsTags.default({})
+
+        # Custom validation
+        def self.new(attributes = {})
+          attrs = super(attributes)
+
+          # Cannot have the same DB instance in both static_members and excluded_members
+          static_db_ids = attrs.static_members.map(&:db_instance_identifier).to_set
+          excluded_db_ids = attrs.excluded_members.map(&:db_instance_identifier).to_set
+
+          overlap = static_db_ids & excluded_db_ids
+          if overlap.any?
+            raise Dry::Struct::Error, "DB instances cannot be in both static_members and excluded_members: #{overlap.to_a.join(', ')}"
+          end
+
+          # Validate endpoint identifier format
+          if attrs.cluster_endpoint_identifier !~ /^[a-zA-Z][a-zA-Z0-9-]*$/
+            raise Dry::Struct::Error, "cluster_endpoint_identifier must start with a letter and contain only letters, numbers, and hyphens"
+          end
+
+          # Validate endpoint identifier length
+          if attrs.cluster_endpoint_identifier.length > 63
+            raise Dry::Struct::Error, "cluster_endpoint_identifier cannot exceed 63 characters"
+          end
+
+          # WRITER endpoints cannot have static members (AWS restriction)
+          if attrs.custom_endpoint_type == "WRITER" && attrs.static_members.any?
+            raise Dry::Struct::Error, "WRITER endpoints cannot have static members"
+          end
+
+          # WRITER endpoints cannot have excluded members (AWS restriction)
+          if attrs.custom_endpoint_type == "WRITER" && attrs.excluded_members.any?
+            raise Dry::Struct::Error, "WRITER endpoints cannot have excluded members"
+          end
+
+          attrs
+        end
+
+        # Check if this is a reader endpoint
+        def is_reader?
+          custom_endpoint_type == "READER"
+        end
+
+        # Check if this is a writer endpoint  
+        def is_writer?
+          custom_endpoint_type == "WRITER"
+        end
+
+        # Check if this is an any endpoint
+        def is_any?
+          custom_endpoint_type == "ANY"
+        end
+
+        # Check if endpoint has static member configuration
+        def has_static_members?
+          static_members.any?
+        end
+
+        # Check if endpoint has excluded member configuration
+        def has_excluded_members?
+          excluded_members.any?
+        end
+
+        # Get list of static member DB instance identifiers
+        def static_member_db_ids
+          static_members.map(&:db_instance_identifier)
+        end
+
+        # Get list of excluded member DB instance identifiers
+        def excluded_member_db_ids
+          excluded_members.map(&:db_instance_identifier)
+        end
+
+        # Check if endpoint uses custom member configuration
+        def uses_custom_member_config?
+          has_static_members? || has_excluded_members?
+        end
+
+        # Get endpoint configuration summary
+        def configuration_summary
+          config = ["Type: #{custom_endpoint_type}"]
+          
+          if has_static_members?
+            config << "Static members: #{static_member_db_ids.join(', ')}"
+          end
+          
+          if has_excluded_members?
+            config << "Excluded members: #{excluded_member_db_ids.join(', ')}"
+          end
+
+          unless uses_custom_member_config?
+            config << "Uses cluster default member selection"
+          end
+          
+          config.join("; ")
+        end
+
+        # Validate that referenced DB instance exists in the cluster (placeholder for external validation)
+        def validate_db_instances(cluster_instances)
+          all_referenced_ids = static_member_db_ids + excluded_member_db_ids
+          cluster_db_ids = cluster_instances.map { |instance| instance.fetch(:db_instance_identifier) }
+          
+          invalid_ids = all_referenced_ids - cluster_db_ids
+          if invalid_ids.any?
+            raise Dry::Struct::Error, "Referenced DB instances not found in cluster: #{invalid_ids.join(', ')}"
+          end
+        end
+
+        # Generate unique endpoint name for use in DNS and connection strings
+        def endpoint_dns_name(cluster_arn_or_id)
+          # Extract cluster identifier from ARN if provided
+          cluster_id = cluster_arn_or_id.include?(':') ? cluster_arn_or_id.split(':').last : cluster_arn_or_id
+          "#{cluster_id}.cluster-custom-#{cluster_endpoint_identifier}"
+        end
+
+        # Estimate additional monthly cost (Aurora endpoints are generally free)
+        def estimated_monthly_cost
+          "$0.00 (Custom endpoints are included with Aurora clusters)"
+        end
+      end
+
+      # Common RDS Cluster Endpoint configurations
+      module RdsClusterEndpointConfigs
+        # Read-only endpoint for reporting and analytics
+        def self.read_replica_endpoint(cluster_id:, endpoint_id: "read-replica")
+          {
+            cluster_identifier: cluster_id,
+            cluster_endpoint_identifier: endpoint_id,
+            custom_endpoint_type: "READER",
+            tags: { Purpose: "read-replica", Usage: "analytics" }
+          }
+        end
+
+        # Custom reader endpoint excluding specific instances
+        def self.analytics_endpoint(cluster_id:, excluded_db_instances: [], endpoint_id: "analytics")
+          excluded_members = excluded_db_instances.map { |db_id| { db_instance_identifier: db_id } }
+          
+          {
+            cluster_identifier: cluster_id,
+            cluster_endpoint_identifier: endpoint_id,
+            custom_endpoint_type: "READER",
+            excluded_members: excluded_members,
+            tags: { Purpose: "analytics", Type: "custom-reader" }
+          }
+        end
+
+        # Static reader endpoint with specific instances
+        def self.dedicated_reader_endpoint(cluster_id:, static_db_instances:, endpoint_id: "dedicated-reader")
+          static_members = static_db_instances.map { |db_id| { db_instance_identifier: db_id } }
+          
+          {
+            cluster_identifier: cluster_id,
+            cluster_endpoint_identifier: endpoint_id,
+            custom_endpoint_type: "READER",
+            static_members: static_members,
+            tags: { Purpose: "dedicated-reader", Type: "static-members" }
+          }
+        end
+
+        # Any endpoint for connection pooling
+        def self.pooled_endpoint(cluster_id:, endpoint_id: "pooled")
+          {
+            cluster_identifier: cluster_id,
+            cluster_endpoint_identifier: endpoint_id,
+            custom_endpoint_type: "ANY",
+            tags: { Purpose: "connection-pooling", Type: "any" }
+          }
+        end
+
+        # Development/testing endpoint
+        def self.development_endpoint(cluster_id:, endpoint_id: "dev")
+          {
+            cluster_identifier: cluster_id,
+            cluster_endpoint_identifier: endpoint_id,
+            custom_endpoint_type: "READER",
+            tags: { Environment: "development", Purpose: "testing" }
+          }
+        end
+
+        # Regional failover endpoint
+        def self.failover_endpoint(cluster_id:, excluded_primary: nil, endpoint_id: "failover")
+          config = {
+            cluster_identifier: cluster_id,
+            cluster_endpoint_identifier: endpoint_id,
+            custom_endpoint_type: "READER",
+            tags: { Purpose: "failover", Type: "disaster-recovery" }
+          }
+
+          if excluded_primary
+            config[:excluded_members] = [{ db_instance_identifier: excluded_primary }]
+          end
+
+          config
+        end
+      end
+    end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_rds_cluster_endpoint/types.rbs

@@ -0,0 +1,59 @@
+module Pangea
+  module Resources
+    module AWS
+      class ExcludedMember < Dry::Struct
+        attribute :db_instance_identifier, Types::String
+        
+        def db_instance_identifier: () -> String
+      end
+
+      class StaticMember < Dry::Struct
+        attribute :db_instance_identifier, Types::String
+        
+        def db_instance_identifier: () -> String
+      end
+
+      class RdsClusterEndpointAttributes < Dry::Struct
+        attribute :cluster_identifier, Types::String
+        attribute :cluster_endpoint_identifier, Types::String
+        attribute :custom_endpoint_type, Types::String
+        attribute :static_members, Types::Array[StaticMember]
+        attribute :excluded_members, Types::Array[ExcludedMember]
+        attribute :tags, Types::AwsTags
+
+        def self.new: (Hash[Symbol, untyped] attributes) -> RdsClusterEndpointAttributes
+
+        def cluster_identifier: () -> String
+        def cluster_endpoint_identifier: () -> String
+        def custom_endpoint_type: () -> String
+        def static_members: () -> Array[StaticMember]
+        def excluded_members: () -> Array[ExcludedMember]
+        def tags: () -> Hash[Symbol, String]
+
+        def is_reader?: () -> bool
+        def is_writer?: () -> bool
+        def is_any?: () -> bool
+        def has_static_members?: () -> bool
+        def has_excluded_members?: () -> bool
+        def static_member_db_ids: () -> Array[String]
+        def excluded_member_db_ids: () -> Array[String]
+        def uses_custom_member_config?: () -> bool
+        def configuration_summary: () -> String
+        def validate_db_instances: (Array[Hash[Symbol, String]]) -> void
+        def endpoint_dns_name: (String) -> String
+        def estimated_monthly_cost: () -> String
+      end
+
+      module RdsClusterEndpointConfigs
+        def self.read_replica_endpoint: (cluster_id: String, ?endpoint_id: String) -> Hash[Symbol, untyped]
+        def self.analytics_endpoint: (cluster_id: String, ?excluded_db_instances: Array[String], ?endpoint_id: String) -> Hash[Symbol, untyped]
+        def self.dedicated_reader_endpoint: (cluster_id: String, static_db_instances: Array[String], ?endpoint_id: String) -> Hash[Symbol, untyped]
+        def self.pooled_endpoint: (cluster_id: String, ?endpoint_id: String) -> Hash[Symbol, untyped]
+        def self.development_endpoint: (cluster_id: String, ?endpoint_id: String) -> Hash[Symbol, untyped]
+        def self.failover_endpoint: (cluster_id: String, ?excluded_primary: String?, ?endpoint_id: String) -> Hash[Symbol, untyped]
+      end
+
+      def aws_rds_cluster_endpoint: (Symbol name, Hash[Symbol, untyped] attributes) -> ResourceReference
+    end
+  end
+end