pangea 0.0.45 → 0.0.46

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

@@ -1,213 +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
-        # Transit Gateway Route Table Propagation resource attributes with validation
-        class TransitGatewayRouteTablePropagationAttributes < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          attribute :transit_gateway_attachment_id, Resources::Types::String
-          attribute :transit_gateway_route_table_id, Resources::Types::String
-          
-          # Custom validation for propagation configuration
-          def self.new(attributes)
-            attrs = attributes.is_a?(Hash) ? attributes : {}
-            
-            # Validate attachment ID format
-            if attrs[:transit_gateway_attachment_id] && !attrs[:transit_gateway_attachment_id].match?(/\Atgw-attach-[0-9a-f]{8,17}\z/)
-              raise Dry::Struct::Error, "Invalid Transit Gateway Attachment ID format: #{attrs[:transit_gateway_attachment_id]}. Expected format: tgw-attach-xxxxxxxx"
-            end
-            
-            # Validate route table ID format
-            if attrs[:transit_gateway_route_table_id] && !attrs[:transit_gateway_route_table_id].match?(/\Atgw-rtb-[0-9a-f]{8,17}\z/)
-              raise Dry::Struct::Error, "Invalid Transit Gateway Route Table ID format: #{attrs[:transit_gateway_route_table_id]}. Expected format: tgw-rtb-xxxxxxxx"
-            end
-            
-            super(attrs)
-          end
-          
-          # Computed properties
-          def propagation_purpose
-            "Propagates routes from attachment #{transit_gateway_attachment_id} to route table #{transit_gateway_route_table_id}"
-          end
-          
-          def route_advertisement_behavior
-            {
-              direction: "inbound_to_route_table",
-              mechanism: "automatic_route_propagation", 
-              route_type: "propagated_routes",
-              override_capability: "static_routes_override_propagated"
-            }
-          end
-          
-          def propagation_implications
-            implications = {
-              route_creation: "Routes from the attachment will be automatically created in the route table",
-              route_management: "Propagated routes are managed automatically - do not create static routes for same CIDRs",
-              route_priority: "Static routes take precedence over propagated routes for the same destination",
-              dynamic_updates: "Route changes in source attachment are automatically reflected in route table"
-            }
-            
-            implications[:traffic_flow] = "Other attachments associated with this route table will learn routes to the propagating attachment"
-            implications[:bidirectional_note] = "Propagation only advertises routes TO the attachment, not FROM it"
-            
-            implications
-          end
-          
-          def security_considerations
-            considerations = []
-            
-            considerations << "Route propagation automatically advertises attachment's routes to the route table"
-            considerations << "All attachments associated with the route table will learn propagated routes"
-            considerations << "Propagated routes can be overridden by static routes for security policies"
-            considerations << "Route propagation enables dynamic connectivity that may bypass static security controls"
-            
-            considerations << "Consider whether automatic route propagation aligns with security segmentation requirements"
-            considerations << "Monitor propagated routes to ensure they don't create unintended connectivity paths"
-            considerations << "Document which attachments propagate to which route tables for security reviews"
-            
-            considerations
-          end
-          
-          def operational_insights
-            insights = {
-              automation_level: "fully_automatic",
-              route_lifecycle: "managed_by_aws",
-              troubleshooting_complexity: "medium", # Propagated routes can be confusing
-              change_detection: "cloudtrail_and_route_monitoring"
-            }
-            
-            insights[:best_practices] = [
-              "Use route propagation for dynamic environments where routes change frequently",
-              "Combine with static routes for fine-grained control over specific destinations",
-              "Document propagation relationships for operational clarity",
-              "Monitor route table size to avoid hitting AWS limits"
-            ]
-            
-            insights[:when_to_use] = [
-              "VPC attachments with changing subnets",
-              "VPN connections with dynamic routing",
-              "Direct Connect gateways with BGP",
-              "Peering connections between dynamic environments"
-            ]
-            
-            insights[:when_not_to_use] = [
-              "High-security environments requiring manual route control",
-              "Static environments where routes never change",
-              "Situations requiring asymmetric routing policies"
-            ]
-            
-            insights
-          end
-          
-          def route_propagation_scenarios
-            scenarios = {
-              vpc_attachment: {
-                description: "VPC subnets are propagated as routes",
-                route_source: "VPC CIDR and associated subnets",
-                update_trigger: "Subnet creation/deletion in VPC",
-                typical_use_case: "Dynamic subnet management"
-              },
-              vpn_attachment: {
-                description: "Customer network routes learned via BGP",
-                route_source: "BGP advertisements from customer gateway",
-                update_trigger: "BGP route updates from on-premises",
-                typical_use_case: "Dynamic on-premises connectivity"
-              },
-              dx_gateway_attachment: {
-                description: "Direct Connect virtual interface routes",
-                route_source: "BGP advertisements from Direct Connect",
-                update_trigger: "BGP updates from Direct Connect partner",
-                typical_use_case: "Enterprise network integration"
-              },
-              peering_attachment: {
-                description: "Routes from peered Transit Gateway",
-                route_source: "Routes from remote Transit Gateway",
-                update_trigger: "Route changes in remote Transit Gateway",
-                typical_use_case: "Cross-region or cross-account connectivity"
-              }
-            }
-            
-            scenarios
-          end
-          
-          def troubleshooting_guide
-            guide = {
-              common_issues: [
-                "Propagated routes not appearing: Check attachment state and route table association",
-                "Route conflicts: Static routes override propagated routes for same destination",
-                "Unexpected connectivity: Propagated routes may create paths not anticipated",
-                "Route limits exceeded: Monitor route table size, AWS limits at 10,000 routes per table"
-              ],
-              verification_steps: [
-                "Verify attachment is in 'available' state",
-                "Check that source attachment has routes to propagate",
-                "Confirm route table association exists for destination attachments", 
-                "Validate no static routes conflict with propagated routes"
-              ],
-              monitoring_approaches: [
-                "Use CloudWatch metrics for route table route count",
-                "Monitor Transit Gateway route table via AWS Console",
-                "Track propagation changes through CloudTrail events",
-                "Use VPC Flow Logs to verify traffic follows propagated routes"
-              ],
-              debugging_techniques: [
-                "Compare route table contents before/after propagation",
-                "Use traceroute to verify traffic path through propagated routes",
-                "Check BGP status for VPN/Direct Connect attachments",
-                "Validate attachment association and propagation configuration"
-              ]
-            }
-            
-            guide
-          end
-          
-          def estimated_impact
-            impact = {
-              scope: "route_table_route_population",
-              automation_level: "high",
-              change_frequency: "dynamic", # Routes update automatically
-              reversibility: "easy", # Can disable propagation
-              monitoring_requirements: "medium" # Need to watch for unexpected routes
-            }
-            
-            impact[:benefits] = [
-              "Automatic route management reduces operational overhead",
-              "Dynamic environments stay connected as routes change",
-              "BGP integration enables enterprise-grade networking",
-              "Reduces risk of manual route configuration errors"
-            ]
-            
-            impact[:risks] = [
-              "Automatic routes may create unintended connectivity",
-              "Route limits can be reached more quickly with propagation",
-              "Troubleshooting is more complex with dynamic routes",
-              "Security policies may be bypassed by propagated routes"
-            ]
-            
-            impact
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pangea/resources/aws_ec2_transit_gateway_route_table_propagation.rbs

@@ -1,25 +0,0 @@
-module Pangea
-  module Resources
-    module AWS
-      module Types
-        class TransitGatewayRouteTablePropagationAttributes < Dry::Struct
-          def self.new: (Hash[Symbol, untyped] attributes) -> TransitGatewayRouteTablePropagationAttributes
-          def propagation_purpose: () -> String
-          def route_advertisement_behavior: () -> Hash[Symbol, untyped]
-          def propagation_implications: () -> Hash[Symbol, untyped]
-          def security_considerations: () -> Array[String]
-          def operational_insights: () -> Hash[Symbol, untyped]
-          def route_propagation_scenarios: () -> Hash[Symbol, untyped]
-          def troubleshooting_guide: () -> Hash[Symbol, untyped]
-          def estimated_impact: () -> Hash[Symbol, untyped]
-          def to_h: () -> Hash[Symbol, untyped]
-          
-          def transit_gateway_attachment_id: () -> String
-          def transit_gateway_route_table_id: () -> String
-        end
-      end
-      
-      def aws_ec2_transit_gateway_route_table_propagation: (Symbol name, ?Hash[Symbol, untyped] attributes) -> ResourceReference
-    end
-  end
-end

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

@@ -1,326 +0,0 @@
-# AWS EC2 Transit Gateway VPC Attachment Implementation
-
-## Resource Overview
-
-The `aws_ec2_transit_gateway_vpc_attachment` resource creates and manages VPC attachments to AWS Transit Gateways. This implementation provides comprehensive validation, routing analysis, and high availability considerations for production deployments.
-
-## Implementation Details
-
-### Type Safety and Validation
-
-The resource uses `TransitGatewayVpcAttachmentAttributes` dry-struct for complete type safety:
-
-```ruby
-class TransitGatewayVpcAttachmentAttributes < Dry::Struct
-  # Required connectivity components
-  attribute :transit_gateway_id, Resources::Types::String
-  attribute :vpc_id, Resources::Types::String  
-  attribute :subnet_ids, Resources::Types::Array.of(Resources::Types::String).constrained(min_size: 1)
-  
-  # Optional feature toggles
-  attribute? :appliance_mode_support, Resources::Types::TransitGatewayVpcAttachmentApplianceModeSupport
-  attribute? :dns_support, Resources::Types::TransitGatewayVpcAttachmentDnsSupport
-  attribute? :ipv6_support, Resources::Types::TransitGatewayVpcAttachmentIpv6Support
-  
-  # Route table behavior control
-  attribute? :transit_gateway_default_route_table_association, Resources::Types::Bool.optional
-  attribute? :transit_gateway_default_route_table_propagation, Resources::Types::Bool.optional
-end
-```
-
-### AWS Resource ID Validation
-
-The implementation validates AWS resource ID formats:
-
-```ruby
-# VPC ID validation: vpc-xxxxxxxx
-unless vpc_id.match?(/\Avpc-[0-9a-f]{8,17}\z/)
-  raise Dry::Struct::Error, "Invalid VPC ID format: #{vpc_id}. Expected format: vpc-xxxxxxxx"
-end
-
-# Transit Gateway ID validation: tgw-xxxxxxxx  
-unless transit_gateway_id.match?(/\Atgw-[0-9a-f]{8,17}\z/)
-  raise Dry::Struct::Error, "Invalid Transit Gateway ID format: #{transit_gateway_id}. Expected format: tgw-xxxxxxxx"
-end
-
-# Subnet ID validation: subnet-xxxxxxxx
-subnet_ids.each do |subnet_id|
-  unless subnet_id.match?(/\Asubnet-[0-9a-f]{8,17}\z/)
-    raise Dry::Struct::Error, "Invalid subnet ID format: #{subnet_id}. Expected format: subnet-xxxxxxxx"
-  end
-end
-```
-
-### High Availability Analysis
-
-The resource provides sophisticated availability analysis:
-
-```ruby
-def is_highly_available?
-  # Multiple subnets provide high availability across AZs
-  subnet_ids.length > 1
-end
-
-def availability_zones_count
-  # Estimate AZ count based on subnet count (assuming best practices)
-  case subnet_ids.length
-  when 1 then 1  # Single AZ - no HA
-  when 2 then 2  # Dual AZ - basic HA  
-  when 3 then 3  # Triple AZ - full HA
-  else subnet_ids.length # More than 3 AZs possible in some regions
-  end
-end
-```
-
-### Routing Behavior Analysis
-
-The implementation provides detailed routing behavior analysis:
-
-```ruby
-def routing_behavior
-  behavior = {
-    default_route_table_association: transit_gateway_default_route_table_association,
-    default_route_table_propagation: transit_gateway_default_route_table_propagation,
-    dns_resolution: dns_support == 'enable',
-    appliance_mode: appliance_mode_support == 'enable'
-  }
-  
-  # Determine routing pattern based on configuration
-  if transit_gateway_default_route_table_association && transit_gateway_default_route_table_propagation
-    behavior[:pattern] = 'full_mesh'     # All-to-all connectivity
-  elsif transit_gateway_default_route_table_association && !transit_gateway_default_route_table_propagation
-    behavior[:pattern] = 'hub_and_spoke_receiver'  # Receives traffic, doesn't send routes
-  elsif !transit_gateway_default_route_table_association && transit_gateway_default_route_table_propagation
-    behavior[:pattern] = 'hub_and_spoke_sender'    # Sends routes, doesn't receive traffic
-  else
-    behavior[:pattern] = 'isolated'      # No default connectivity
-  end
-  
-  behavior
-end
-```
-
-### Security Analysis
-
-Comprehensive security considerations analysis:
-
-```ruby
-def security_considerations
-  considerations = []
-  
-  # High availability warnings
-  unless is_highly_available?
-    considerations << "Single subnet attachment - no high availability. Consider adding subnets in additional AZs"
-  end
-  
-  # Appliance mode implications
-  if appliance_mode_support == 'enable'
-    considerations << "Appliance mode support is enabled - traffic will be directed to a single network appliance"
-  end
-  
-  # DNS resolution impact
-  if dns_support == 'disable'
-    considerations << "DNS support is disabled - DNS resolution across the Transit Gateway will not work"
-  end
-  
-  # Route table management warnings
-  if transit_gateway_default_route_table_association == false
-    considerations << "Default route table association is disabled - ensure custom route table is associated"
-  end
-  
-  if transit_gateway_default_route_table_propagation == false
-    considerations << "Default route table propagation is disabled - routes will not be automatically propagated"
-  end
-  
-  considerations
-end
-```
-
-## Terraform Resource Synthesis
-
-The resource generates clean Terraform configuration with conditional attributes:
-
-```ruby
-resource(:aws_ec2_transit_gateway_vpc_attachment, name) do
-  # Always required
-  transit_gateway_id attachment_attrs.transit_gateway_id
-  vpc_id attachment_attrs.vpc_id
-  subnet_ids attachment_attrs.subnet_ids
-  
-  # Conditional optional attributes
-  if attachment_attrs.appliance_mode_support
-    appliance_mode_support attachment_attrs.appliance_mode_support
-  end
-  
-  if attachment_attrs.dns_support
-    dns_support attachment_attrs.dns_support
-  end
-  
-  # Boolean attributes with explicit nil checking
-  if !attachment_attrs.transit_gateway_default_route_table_association.nil?
-    transit_gateway_default_route_table_association attachment_attrs.transit_gateway_default_route_table_association
-  end
-  
-  # ... other optional attributes
-end
-```
-
-## Architecture Pattern Support
-
-### 1. Full Mesh Connectivity
-Default configuration with all attachments associated and propagating:
-```ruby
-transit_gateway_default_route_table_association: true,
-transit_gateway_default_route_table_propagation: true
-```
-
-### 2. Hub and Spoke Architecture
-- **Hub**: Receives traffic from spokes, doesn't propagate its routes
-- **Spoke**: Sends traffic to hub, propagates routes to hub
-
-```ruby
-# Hub configuration
-hub_attachment = aws_ec2_transit_gateway_vpc_attachment(:hub, {
-  transit_gateway_default_route_table_association: true,  # Receives traffic
-  transit_gateway_default_route_table_propagation: false  # Doesn't propagate
-})
-
-# Spoke configuration  
-spoke_attachment = aws_ec2_transit_gateway_vpc_attachment(:spoke, {
-  transit_gateway_default_route_table_association: true,  # Can reach hub
-  transit_gateway_default_route_table_propagation: true   # Advertises routes
-})
-```
-
-### 3. Network Segmentation
-Complete isolation with custom route table management:
-```ruby
-isolated_attachment = aws_ec2_transit_gateway_vpc_attachment(:isolated, {
-  transit_gateway_default_route_table_association: false,  # Custom route tables only
-  transit_gateway_default_route_table_propagation: false   # Manual route control
-})
-```
-
-### 4. Appliance Mode for Security Inspection
-Traffic flows through network security appliances:
-```ruby
-firewall_attachment = aws_ec2_transit_gateway_vpc_attachment(:firewall, {
-  appliance_mode_support: "enable",                       # Single appliance routing
-  transit_gateway_default_route_table_association: false, # Custom routing required
-  transit_gateway_default_route_table_propagation: false  # Manual control
-})
-```
-
-## Cost Analysis
-
-Detailed cost breakdown with operational insights:
-
-```ruby
-def estimated_monthly_cost
-  # VPC attachment base cost: $36.50 per month per attachment
-  base_cost = 36.50
-  
-  {
-    monthly_attachment_cost: base_cost,
-    currency: 'USD',
-    note: 'Fixed monthly cost per VPC attachment. Data processing charges apply separately.'
-  }
-end
-```
-
-Additional cost considerations:
-- Data processing: ~$0.02/GB for inter-AZ traffic through Transit Gateway
-- No additional cost for multiple subnets within same attachment
-- Cross-region data transfer charges apply for multi-region connectivity
-
-## Output References
-
-The resource provides standard AWS outputs plus computed insights:
-
-```ruby
-outputs: {
-  id: "${aws_ec2_transit_gateway_vpc_attachment.#{name}.id}",
-  vpc_owner_id: "${aws_ec2_transit_gateway_vpc_attachment.#{name}.vpc_owner_id}",
-  tags_all: "${aws_ec2_transit_gateway_vpc_attachment.#{name}.tags_all}"
-},
-computed_attributes: {
-  is_highly_available: attachment_attrs.is_highly_available?,
-  supports_appliance_mode_inspection: attachment_attrs.supports_appliance_mode_inspection?,
-  routing_behavior: attachment_attrs.routing_behavior,
-  security_considerations: attachment_attrs.security_considerations
-}
-```
-
-## Integration Patterns
-
-### VPC Resource Integration
-```ruby
-# Reference VPC and subnet resources
-vpc_attachment = aws_ec2_transit_gateway_vpc_attachment(:app_vpc, {
-  transit_gateway_id: tgw_ref.id,           # Reference from Transit Gateway resource
-  vpc_id: app_vpc_ref.id,                   # Reference from VPC resource
-  subnet_ids: [                             # References from subnet resources
-    private_subnet_1a_ref.id,
-    private_subnet_1b_ref.id,
-    private_subnet_1c_ref.id
-  ]
-})
-```
-
-### Route Table Integration
-The attachment can be referenced by route table associations:
-```ruby
-# Custom route table association (when default is disabled)
-route_table_association = aws_ec2_transit_gateway_route_table_association(:custom, {
-  transit_gateway_attachment_id: vpc_attachment.id,  # Reference attachment
-  transit_gateway_route_table_id: custom_rt_ref.id
-})
-```
-
-## Validation Strategy
-
-### Input Validation
-- AWS resource ID format validation using regex patterns
-- Subnet count minimum enforcement (at least 1 required)
-- Boolean attribute explicit handling (nil vs false distinction)
-
-### Configuration Validation
-- Appliance mode and routing configuration compatibility
-- IPv6 requirements validation
-- High availability best practice warnings
-
-### Runtime Validation
-- Cross-resource reference resolution
-- Subnet-to-VPC ownership validation (handled by AWS)
-- Transit Gateway capacity and limits (handled by AWS)
-
-## Error Handling
-
-Comprehensive error messages for common issues:
-
-```ruby
-# Resource ID format errors
-raise Dry::Struct::Error, "Invalid VPC ID format: #{vpc_id}. Expected format: vpc-xxxxxxxx"
-
-# Configuration dependency errors  
-raise Dry::Struct::Error, "Appliance mode requires custom route table configuration"
-
-# High availability warnings (not errors, but flagged in security_considerations)
-"Single subnet attachment - no high availability. Consider adding subnets in additional AZs"
-```
-
-## Testing Considerations
-
-### Unit Tests
-- AWS resource ID format validation
-- High availability detection logic
-- Routing behavior analysis
-- Security considerations generation
-
-### Integration Tests
-- Terraform resource generation validation
-- Cross-resource reference resolution
-- Multi-attachment routing behavior
-- Cost calculation accuracy
-
-This implementation provides a production-ready foundation for Transit Gateway VPC attachment management with comprehensive validation, security analysis, and operational insights for complex network architectures.

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

@@ -1,101 +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_ec2_transit_gateway_vpc_attachment/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS EC2 Transit Gateway VPC Attachment with type-safe attributes
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] Transit Gateway VPC Attachment attributes
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      def aws_ec2_transit_gateway_vpc_attachment(name, attributes = {})
-        # Validate attributes using dry-struct
-        attachment_attrs = Types::TransitGatewayVpcAttachmentAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_ec2_transit_gateway_vpc_attachment, name) do
-          # Required attributes
-          transit_gateway_id attachment_attrs.transit_gateway_id
-          vpc_id attachment_attrs.vpc_id
-          subnet_ids attachment_attrs.subnet_ids
-          
-          # Optional appliance mode support
-          if attachment_attrs.appliance_mode_support
-            appliance_mode_support attachment_attrs.appliance_mode_support
-          end
-          
-          # Optional DNS support
-          if attachment_attrs.dns_support
-            dns_support attachment_attrs.dns_support
-          end
-          
-          # Optional IPv6 support
-          if attachment_attrs.ipv6_support
-            ipv6_support attachment_attrs.ipv6_support
-          end
-          
-          # Optional default route table association
-          if !attachment_attrs.transit_gateway_default_route_table_association.nil?
-            transit_gateway_default_route_table_association attachment_attrs.transit_gateway_default_route_table_association
-          end
-          
-          # Optional default route table propagation
-          if !attachment_attrs.transit_gateway_default_route_table_propagation.nil?
-            transit_gateway_default_route_table_propagation attachment_attrs.transit_gateway_default_route_table_propagation
-          end
-          
-          # Apply tags if present
-          if attachment_attrs.tags.any?
-            tags do
-              attachment_attrs.tags.each do |key, value|
-                public_send(key, value)
-              end
-            end
-          end
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_ec2_transit_gateway_vpc_attachment',
-          name: name,
-          resource_attributes: attachment_attrs.to_h,
-          outputs: {
-            id: "${aws_ec2_transit_gateway_vpc_attachment.#{name}.id}",
-            vpc_owner_id: "${aws_ec2_transit_gateway_vpc_attachment.#{name}.vpc_owner_id}",
-            tags_all: "${aws_ec2_transit_gateway_vpc_attachment.#{name}.tags_all}"
-          },
-          computed_attributes: {
-            is_highly_available: attachment_attrs.is_highly_available?,
-            supports_appliance_mode_inspection: attachment_attrs.supports_appliance_mode_inspection?,
-            estimated_monthly_cost: attachment_attrs.estimated_monthly_cost,
-            availability_zones_count: attachment_attrs.availability_zones_count,
-            security_considerations: attachment_attrs.security_considerations,
-            routing_behavior: attachment_attrs.routing_behavior
-          }
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)