pangea-aws 0.1.0

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

@@ -0,0 +1,184 @@
+# 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
+        # EFS Access Point resource attributes with validation
+        class EfsAccessPointAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          
+          # Required attributes
+          attribute? :file_system_id, Resources::Types::String.optional
+          
+          # Optional POSIX user configuration
+          attribute? :posix_user, Resources::Types::EfsPosixUser.optional
+          
+          # Optional root directory configuration  
+          attribute? :root_directory, Resources::Types::EfsRootDirectory.optional
+          
+          # Tags
+          attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+          
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            
+            # Validate root directory path if specified
+            if attrs[:root_directory] && attrs[:root_directory][:path]
+              path = attrs[:root_directory][:path]
+              
+              # Path must start with /
+              unless path.start_with?('/')
+                raise Dry::Struct::Error, "root_directory path must start with '/', got '#{path}'"
+              end
+              
+              # Path cannot end with / unless it's the root path
+              if path.length > 1 && path.end_with?('/')
+                raise Dry::Struct::Error, "root_directory path cannot end with '/' except for root path '/'"
+              end
+              
+              # Path cannot be longer than 100 characters
+              if path.length > 100
+                raise Dry::Struct::Error, "root_directory path cannot exceed 100 characters, got #{path.length}"
+              end
+              
+              # Path cannot contain consecutive slashes
+              if path.include?('//')
+                raise Dry::Struct::Error, "root_directory path cannot contain consecutive slashes '//'"
+              end
+              
+              # Validate path components
+              path_components = path.split('/').reject(&:empty?)
+              path_components.each do |component|
+                # Each component must be valid filename
+                if component.match?(/[<>:"|?*\x00-\x1f]/)
+                  raise Dry::Struct::Error, "root_directory path component '#{component}' contains invalid characters"
+                end
+                
+                # Each component cannot be . or ..
+                if component == '.' || component == '..'
+                  raise Dry::Struct::Error, "root_directory path cannot contain '.' or '..' components"
+                end
+              end
+            end
+            
+            # Validate creation_info permissions format if specified
+            if attrs[:root_directory] && 
+               attrs[:root_directory][:creation_info] && 
+               attrs[:root_directory][:creation_info][:permissions]
+              
+              perms = attrs[:root_directory][:creation_info][:permissions]
+              unless perms.match?(/\A[0-7]{3,4}\z/)
+                raise Dry::Struct::Error, "creation_info permissions must be 3-4 digit octal format (e.g., '755', '0755')"
+              end
+              
+              # Convert to integer and validate range
+              perm_int = perms.to_i(8)
+              if perm_int > 0o7777
+                raise Dry::Struct::Error, "creation_info permissions cannot exceed 0777 (got #{perms})"
+              end
+            end
+            
+            # Validate POSIX user IDs if specified
+            if attrs[:posix_user]
+              posix = attrs[:posix_user]
+              
+              # Validate secondary_gids length
+              if posix[:secondary_gids] && posix[:secondary_gids].length > 16
+                raise Dry::Struct::Error, "posix_user secondary_gids cannot exceed 16 groups"
+              end
+              
+              # Validate UID/GID are not reserved system IDs in sensitive range
+              [posix[:uid], posix[:gid]].compact.each do |id|
+                if id == 0
+                  # Root user/group - log warning but allow for containers
+                  # In production, using root should be discouraged
+                end
+              end
+            end
+            
+            super(attrs)
+          end
+          
+          # Computed properties
+          def has_posix_user?
+            !posix_user.nil?
+          end
+          
+          def has_root_directory?
+            !root_directory.nil?
+          end
+          
+          def has_creation_info?
+            root_directory && root_directory&.dig(:creation_info)
+          end
+          
+          def effective_root_path
+            root_directory&.dig(:path) || "/"
+          end
+          
+          def effective_uid
+            posix_user&.dig(:uid) || 1000  # Default non-root UID
+          end
+          
+          def effective_gid  
+            posix_user&.dig(:gid) || 1000  # Default non-root GID
+          end
+          
+          def is_root_user?
+            effective_uid == 0
+          end
+          
+          def security_assessment
+            issues = []
+            warnings = []
+            
+            # Check for root user
+            if is_root_user?
+              warnings << "Using root user (UID 0) - consider using non-privileged user"
+            end
+            
+            # Check for overly permissive directory permissions
+            if has_creation_info?
+              perms = root_directory&.dig(:creation_info)[:permissions]
+              perm_int = perms.to_i(8)
+              
+              # Check for world-writable
+              if (perm_int & 0o002) != 0
+                issues << "Directory permissions are world-writable (#{perms}) - security risk"
+              end
+              
+              # Check for world-readable sensitive paths
+              if effective_root_path.match?(/\/(etc|home|root|var\/log)/) && (perm_int & 0o004) != 0
+                warnings << "World-readable permissions on sensitive path #{effective_root_path}"
+              end
+            end
+            
+            {
+              issues: issues,
+              warnings: warnings,
+              secure: issues.empty?
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# 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/aws_efs_file_system/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Creates an AWS EFS (Elastic File System) file system
+      # 
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] EFS file system configuration
+      # @return [ResourceReference] Reference to the created file system
+      def aws_efs_file_system(name, attributes = {})
+        validated_attrs = Types::EfsFileSystemAttributes.new(attributes)
+
+        resource(:aws_efs_file_system, name) do
+          creation_token validated_attrs.creation_token if validated_attrs.creation_token
+          performance_mode validated_attrs.performance_mode
+          throughput_mode validated_attrs.throughput_mode
+          encrypted validated_attrs.encrypted
+          tags validated_attrs.tags if validated_attrs.tags&.any?
+
+          # Optional attributes
+          provisioned_throughput_in_mibps validated_attrs.provisioned_throughput_in_mibps if validated_attrs.provisioned_throughput_in_mibps
+          kms_key_id validated_attrs.kms_key_id if validated_attrs.kms_key_id
+          availability_zone_name validated_attrs.availability_zone_name if validated_attrs.availability_zone_name
+
+          # Lifecycle policy
+          lifecycle_policy validated_attrs.lifecycle_policy if validated_attrs.lifecycle_policy&.any?
+
+          # Backup policy
+          backup_policy validated_attrs.backup_policy if validated_attrs.backup_policy
+        end
+
+        ref = ResourceReference.new(
+          type: :aws_efs_file_system,
+          name: name,
+          attributes: validated_attrs,
+          outputs: {
+            id: "${aws_efs_file_system.#{name}.id}",
+            arn: "${aws_efs_file_system.#{name}.arn}",
+            dns_name: "${aws_efs_file_system.#{name}.dns_name}",
+            availability_zone_id: "${aws_efs_file_system.#{name}.availability_zone_id}",
+            availability_zone_name: "${aws_efs_file_system.#{name}.availability_zone_name}",
+            creation_token: "${aws_efs_file_system.#{name}.creation_token}",
+            encrypted: "${aws_efs_file_system.#{name}.encrypted}",
+            kms_key_id: "${aws_efs_file_system.#{name}.kms_key_id}",
+            number_of_mount_targets: "${aws_efs_file_system.#{name}.number_of_mount_targets}",
+            owner_id: "${aws_efs_file_system.#{name}.owner_id}",
+            performance_mode: "${aws_efs_file_system.#{name}.performance_mode}",
+            size_in_bytes: "${aws_efs_file_system.#{name}.size_in_bytes}",
+            throughput_mode: "${aws_efs_file_system.#{name}.throughput_mode}",
+            provisioned_throughput_in_mibps: "${aws_efs_file_system.#{name}.provisioned_throughput_in_mibps}",
+            tags_all: "${aws_efs_file_system.#{name}.tags_all}"
+          }
+        )
+
+        # Delegate computed methods to resource reference
+        ref.define_singleton_method(:is_one_zone?) { validated_attrs.is_one_zone? }
+        ref.define_singleton_method(:is_regional?) { validated_attrs.is_regional? }
+        ref.define_singleton_method(:is_encrypted?) { validated_attrs.is_encrypted? }
+        ref.define_singleton_method(:has_lifecycle_policy?) { validated_attrs.has_lifecycle_policy? }
+        ref.define_singleton_method(:storage_class) { validated_attrs.storage_class }
+        ref.define_singleton_method(:estimated_storage_cost_per_gb) { validated_attrs.estimated_storage_cost_per_gb }
+
+        ref
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# 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
+        # EFS File System resource attributes with validation
+        class EfsFileSystemAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          # Core EFS attributes
+          attribute? :creation_token, Resources::Types::String.optional
+          attribute :performance_mode, Resources::Types::EfsPerformanceMode.default("generalPurpose")
+          attribute :throughput_mode, Resources::Types::EfsThroughputMode.default("bursting")
+          attribute? :provisioned_throughput_in_mibps, Resources::Types::Integer.optional
+          attribute :encrypted, Resources::Types::Bool.default(false)
+          attribute? :kms_key_id, Resources::Types::String.optional
+
+          # Lifecycle management
+          attribute? :lifecycle_policy, Resources::Types::Array.of(Resources::Types::Hash).optional
+
+          # Backup policy
+          attribute? :backup_policy, Resources::Types::Hash.optional
+
+          # Storage configuration
+          attribute? :availability_zone_name, Resources::Types::String.optional
+
+          # Tags
+          attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+
+            # Call parent to get defaults applied
+            instance = super(attrs)
+
+            # Validate required attributes
+            unless instance.creation_token
+              raise Dry::Struct::Error, "creation_token is required for EFS file system"
+            end
+
+            # Validate throughput mode configuration
+            if instance.throughput_mode == "provisioned" && !instance.provisioned_throughput_in_mibps
+              raise Dry::Struct::Error, "Provisioned throughput mode requires provisioned_throughput_in_mibps"
+            end
+
+            if instance.throughput_mode == "bursting" && instance.provisioned_throughput_in_mibps
+              raise Dry::Struct::Error, "Bursting mode cannot have provisioned_throughput_in_mibps"
+            end
+
+            # Validate provisioned throughput range
+            if instance.provisioned_throughput_in_mibps
+              throughput = instance.provisioned_throughput_in_mibps
+              if throughput < 1 || throughput > 3584
+                raise Dry::Struct::Error, "provisioned_throughput_in_mibps must be between 1 and 3584 MiB/s, got #{throughput}"
+              end
+            end
+
+            # Validate performance mode constraints for One Zone
+            if instance.availability_zone_name && instance.performance_mode == "maxIO"
+              raise Dry::Struct::Error, "One Zone storage class is incompatible with maxIO performance mode"
+            end
+
+            instance
+          end
+
+          # Computed properties
+          def is_one_zone?
+            !availability_zone_name.nil?
+          end
+
+          def is_regional?
+            availability_zone_name.nil?
+          end
+
+          def is_encrypted?
+            encrypted == true
+          end
+
+          def has_lifecycle_policy?
+            !lifecycle_policy.nil? && !lifecycle_policy.empty?
+          end
+
+          def storage_class
+            is_one_zone? ? "OneZone" : "Regional"
+          end
+
+          def estimated_storage_cost_per_gb
+            is_one_zone? ? 0.16 : 0.30
+          end
+
+          def estimated_monthly_cost_per_gb
+            # Rough cost estimation in USD per GB per month (as of 2024)
+            base_cost = estimated_storage_cost_per_gb
+
+            # Add throughput costs for provisioned mode
+            if throughput_mode == "provisioned" && provisioned_throughput_in_mibps
+              throughput_cost = provisioned_throughput_in_mibps * 6.00 / 1024 # $6 per provisioned MiB/s per month
+              return { storage: base_cost, throughput: throughput_cost, total: base_cost + throughput_cost }
+            end
+
+            { storage: base_cost, throughput: 0.0, total: base_cost }
+          end
+
+          # Configuration validation warnings
+          def validate_configuration
+            warnings = []
+
+            unless encrypted
+              warnings << "EFS is not encrypted - consider enabling encryption for data at rest"
+            end
+
+            unless has_lifecycle_policy?
+              warnings << "No lifecycle policy configured - consider enabling to reduce costs"
+            end
+
+            if throughput_mode == "provisioned" && provisioned_throughput_in_mibps && provisioned_throughput_in_mibps >= 500
+              warnings << "High provisioned throughput (#{provisioned_throughput_in_mibps} MiB/s) will incur significant costs"
+            end
+
+            warnings
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# 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/aws_efs_mount_target/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Creates an AWS EFS Mount Target for VPC access to an EFS file system
+      # 
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Mount target configuration
+      # @return [ResourceReference] Reference to the created mount target
+      def aws_efs_mount_target(name, attributes = {})
+        validated_attrs = Types::EfsMountTargetAttributes.new(attributes)
+        
+        resource_attributes = {
+          file_system_id: validated_attrs.file_system_id,
+          subnet_id: validated_attrs.subnet_id,
+          security_groups: validated_attrs.security_groups
+        }
+        
+        # Add optional IP address if specified
+        resource_attributes[:ip_address] = validated_attrs.ip_address if validated_attrs.ip_address
+        
+        resource(:aws_efs_mount_target, name, resource_attributes)
+        
+        ResourceReference.new(
+          type: :aws_efs_mount_target,
+          name: name,
+          attributes: validated_attrs,
+          outputs: {
+            id: "${aws_efs_mount_target.#{name}.id}",
+            dns_name: "${aws_efs_mount_target.#{name}.dns_name}",
+            file_system_arn: "${aws_efs_mount_target.#{name}.file_system_arn}",
+            file_system_id: "${aws_efs_mount_target.#{name}.file_system_id}",
+            ip_address: "${aws_efs_mount_target.#{name}.ip_address}",
+            mount_target_dns_name: "${aws_efs_mount_target.#{name}.mount_target_dns_name}",
+            network_interface_id: "${aws_efs_mount_target.#{name}.network_interface_id}",
+            owner_id: "${aws_efs_mount_target.#{name}.owner_id}",
+            security_groups: "${aws_efs_mount_target.#{name}.security_groups}",
+            subnet_id: "${aws_efs_mount_target.#{name}.subnet_id}",
+            availability_zone_id: "${aws_efs_mount_target.#{name}.availability_zone_id}",
+            availability_zone_name: "${aws_efs_mount_target.#{name}.availability_zone_name}"
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# 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
+        # EFS Mount Target resource attributes with validation
+        class EfsMountTargetAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          
+          # Required attributes
+          attribute? :file_system_id, Resources::Types::String.optional
+          attribute? :subnet_id, Resources::Types::String.optional
+          
+          # Optional attributes  
+          attribute? :ip_address, Resources::Types::String.optional
+          attribute :security_groups, Resources::Types::Array.of(Resources::Types::String).default([].freeze)
+          
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            
+            # Validate IP address format if provided
+            if attrs[:ip_address]
+              ip = attrs[:ip_address]
+              unless ip.match?(/\A(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\z/)
+                raise Dry::Struct::Error, "ip_address must be a valid IPv4 address, got '#{ip}'"
+              end
+              
+              # Check if it's in private IP range (as mount targets are in VPC)
+              ip_parts = ip.split('.').map(&:to_i)
+              is_private = false
+              
+              # 10.0.0.0/8
+              is_private = true if ip_parts[0] == 10
+              
+              # 172.16.0.0/12  
+              is_private = true if ip_parts[0] == 172 && (16..31).include?(ip_parts[1])
+              
+              # 192.168.0.0/16
+              is_private = true if ip_parts[0] == 192 && ip_parts[1] == 168
+              
+              unless is_private
+                raise Dry::Struct::Error, "ip_address must be in private IP range (10.0.0.0/8, 172.16.0.0/12, or 192.168.0.0/16)"
+              end
+            end
+            
+            # Validate security groups array
+            if attrs[:security_groups] && attrs[:security_groups].length > 5
+              raise Dry::Struct::Error, "Maximum of 5 security groups allowed for EFS mount targets"
+            end
+            
+            super(attrs)
+          end
+          
+          # Computed properties
+          def has_custom_ip?
+            !ip_address.nil?
+          end
+          
+          def security_group_count
+            security_groups.length
+          end
+          
+          def is_fully_configured?
+            !file_system_id.empty? && !subnet_id.empty? && !security_groups.empty?
+          end
+          
+          def estimated_data_transfer_cost_per_gb
+            # EFS mount targets don't have direct costs, but data transfer applies
+            # Regional: $0.01 per GB for cross-AZ access
+            # One Zone: No cross-AZ charges within same AZ
+            {
+              cross_az_data_transfer: 0.01,
+              same_az_data_transfer: 0.00,
+              note: "Actual costs depend on file system type and access patterns"
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# 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_eip/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS Elastic IP with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Resource attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_eip(name, attributes = {})
+        # Validate attributes using dry-struct
+        attrs = AWS::Types::EipAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_eip, name) do
+          # Domain is always specified (default is vpc)
+          domain attrs.domain
+          
+          # Instance association
+          instance attrs.instance if attrs.instance
+          
+          # Network interface association
+          network_interface attrs.network_interface if attrs.network_interface
+          
+          # Private IP association (requires network_interface)
+          associate_with_private_ip attrs.associate_with_private_ip if attrs.associate_with_private_ip
+          
+          # Customer-owned IP pool
+          customer_owned_ipv4_pool attrs.customer_owned_ipv4_pool if attrs.customer_owned_ipv4_pool
+          
+          # Network border group
+          network_border_group attrs.network_border_group if attrs.network_border_group
+          
+          # Public IPv4 pool
+          public_ipv4_pool attrs.public_ipv4_pool if attrs.public_ipv4_pool
+          
+          # Apply tags if present
+          if attrs.tags&.any?
+            tags do
+              attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ref = ResourceReference.new(
+          type: 'aws_eip',
+          name: name,
+          resource_attributes: attrs.to_h,
+          outputs: {
+            id: "${aws_eip.#{name}.id}",
+            allocation_id: "${aws_eip.#{name}.allocation_id}",
+            association_id: "${aws_eip.#{name}.association_id}",
+            carrier_ip: "${aws_eip.#{name}.carrier_ip}",
+            customer_owned_ip: "${aws_eip.#{name}.customer_owned_ip}",
+            customer_owned_ipv4_pool: "${aws_eip.#{name}.customer_owned_ipv4_pool}",
+            domain: "${aws_eip.#{name}.domain}",
+            instance: "${aws_eip.#{name}.instance}",
+            network_border_group: "${aws_eip.#{name}.network_border_group}",
+            network_interface: "${aws_eip.#{name}.network_interface}",
+            private_dns: "${aws_eip.#{name}.private_dns}",
+            private_ip: "${aws_eip.#{name}.private_ip}",
+            public_dns: "${aws_eip.#{name}.public_dns}",
+            public_ip: "${aws_eip.#{name}.public_ip}",
+            public_ipv4_pool: "${aws_eip.#{name}.public_ipv4_pool}",
+            tags_all: "${aws_eip.#{name}.tags_all}",
+            vpc: "${aws_eip.#{name}.vpc}"
+          }
+        )
+        
+        # Add computed properties via method delegation
+        ref.define_singleton_method(:vpc?) { attrs.vpc? }
+        ref.define_singleton_method(:associated?) { attrs.associated? }
+        ref.define_singleton_method(:customer_owned?) { attrs.customer_owned? }
+        ref.define_singleton_method(:association_type) { attrs.association_type }
+        
+        ref
+      end
+    end
+  end
+end
+
+# Note: Registration handled by main aws.rb module