pangea 0.0.45 → 0.0.46

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

@@ -1,279 +0,0 @@
-# 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

@@ -1,96 +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_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

@@ -1,254 +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/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

@@ -1,59 +0,0 @@
-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