pangea-aws 0.1.0

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Type-safe attributes for AWS Load Balancer Listener resources
+        class LoadBalancerListenerAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          # The ARN of the load balancer to attach the listener to
+          attribute? :load_balancer_arn, Pangea::Resources::Types::String.optional
+        
+          # The port on which the load balancer is listening
+          attribute? :port, Pangea::Resources::Types::ListenerPort.optional
+        
+          # The protocol for connections from clients to the load balancer
+          attribute? :protocol, Pangea::Resources::Types::ListenerProtocol.optional
+        
+          # The security policy for HTTPS/TLS listeners (required for HTTPS/TLS)
+          attribute? :ssl_policy, Pangea::Resources::Types::SslPolicy.optional
+        
+          # The ARN of the default SSL server certificate (required for HTTPS/TLS)
+          attribute? :certificate_arn, Pangea::Resources::Types::String.optional
+        
+          # The ALPN policy for HTTPS listeners
+          attribute? :alpn_policy, Pangea::Resources::Types::String.constrained(included_in: ['HTTP1Only', 'HTTP2Only', 'HTTP2Optional', 'HTTP2Preferred', 'None']).optional
+        
+          # Default actions for the listener
+          attribute? :default_action, Pangea::Resources::Types::Array.of(
+            Pangea::Resources::Types::Hash.schema(
+              type: Pangea::Resources::Types::ListenerActionType,
+              target_group_arn?: Pangea::Resources::Types::String.optional,
+              forward?: Pangea::Resources::Types::ListenerForwardAction.optional,
+              redirect?: Pangea::Resources::Types::ListenerRedirectAction.optional,
+              fixed_response?: Pangea::Resources::Types::ListenerFixedResponseAction.optional,
+              authenticate_cognito?: Pangea::Resources::Types::ListenerAuthenticateCognitoAction.optional,
+              authenticate_oidc?: Pangea::Resources::Types::ListenerAuthenticateOidcAction.optional,
+              order?: Pangea::Resources::Types::Integer.constrained(gteq: 1, lteq: 50000).optional
+            ).lax
+          ).constrained(min_size: 1)
+        
+          # Tags to apply to the listener
+          attribute :tags, Pangea::Resources::Types::Hash.default({}.freeze)
+
+          # Custom validation for protocol-specific requirements
+          def self.new(attributes = {})
+            attrs = super(attributes)
+          
+            # Validate HTTPS/TLS requirements
+            if ['HTTPS', 'TLS'].include?(attrs.protocol)
+              if attrs.ssl_policy.nil?
+                raise Dry::Struct::Error, "ssl_policy is required for #{attrs.protocol} listeners"
+              end
+              
+              if attrs.certificate_arn.nil?
+                raise Dry::Struct::Error, "certificate_arn is required for #{attrs.protocol} listeners"
+              end
+            elsif !attrs.ssl_policy.nil? || !attrs.certificate_arn.nil?
+              raise Dry::Struct::Error, "ssl_policy and certificate_arn can only be specified for HTTPS/TLS listeners"
+            end
+
+            # Validate protocol-specific ports
+            case attrs.protocol
+            when 'HTTP'
+              # HTTP commonly uses port 80, but can use others
+            when 'HTTPS'  
+              # HTTPS commonly uses port 443, but can use others
+            when 'TCP', 'TLS'
+              # TCP/TLS can use any valid port
+            when 'UDP', 'TCP_UDP'
+              # UDP protocols - validate they're used with Network Load Balancer
+            when 'GENEVE'
+              # GENEVE protocol - used with Gateway Load Balancer
+            end
+
+            # Validate default actions
+            attrs.default_action.each do |action|
+              case action[:type]
+              when 'forward'
+                unless action[:target_group_arn] || action[:forward]
+                  raise Dry::Struct::Error, "forward action requires either target_group_arn or forward configuration"
+                end
+              when 'redirect'
+                unless action[:redirect]
+                  raise Dry::Struct::Error, "redirect action requires redirect configuration"
+                end
+              when 'fixed-response'
+                unless action[:fixed_response]
+                  raise Dry::Struct::Error, "fixed-response action requires fixed_response configuration"
+                end
+              when 'authenticate-cognito'
+                unless action[:authenticate_cognito]
+                  raise Dry::Struct::Error, "authenticate-cognito action requires authenticate_cognito configuration"
+                end
+              when 'authenticate-oidc'
+                unless action[:authenticate_oidc]
+                  raise Dry::Struct::Error, "authenticate-oidc action requires authenticate_oidc configuration"
+                end
+              end
+            end
+
+            attrs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# Type definitions for AWS Load Balancer Listener resources
+
+module Pangea
+  module Resources
+    module AWS
+      class LoadBalancerListenerAttributes < Dry::Struct
+        attribute :load_balancer_arn, String
+        attribute :port, Integer
+        attribute :protocol, String
+        attribute? :ssl_policy, String?
+        attribute? :certificate_arn, String?  
+        attribute? :alpn_policy, String?
+        attribute :default_action, Array[Hash[Symbol, untyped]]
+        attribute :tags, Hash[Symbol, String]
+        
+        def self.new: (Hash[Symbol, untyped] attributes) -> LoadBalancerListenerAttributes
+      end
+      
+      # Load balancer listener function signature
+      def aws_lb_listener: (Symbol name, Hash[Symbol, untyped] attributes) -> ResourceReference
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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_lb_listener_certificate/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS Load Balancer Listener Certificate attachment with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Listener certificate attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_lb_listener_certificate(name, attributes = {})
+        # Validate attributes using dry-struct
+        cert_attrs = Types::LoadBalancerListenerCertificateAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_lb_listener_certificate, name) do
+          listener_arn cert_attrs.listener_arn
+          certificate_arn cert_attrs.certificate_arn
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_lb_listener_certificate',
+          name: name,
+          resource_attributes: cert_attrs.to_h,
+          outputs: {
+            listener_arn: "${aws_lb_listener_certificate.#{name}.listener_arn}",
+            certificate_arn: "${aws_lb_listener_certificate.#{name}.certificate_arn}"
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# 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
+      # Type-safe attributes for AWS Load Balancer Listener Certificate resources
+      class LoadBalancerListenerCertificateAttributes < Pangea::Resources::BaseAttributes
+        # The ARN of the listener to attach the certificate to
+        attribute? :listener_arn, Resources::Types::String.constrained(
+          format: /\Aarn:aws:elasticloadbalancing:[a-z0-9-]+:\d{12}:listener\/[a-zA-Z0-9\/-]+\z/
+        )
+        
+        # The ARN of the SSL certificate to attach
+        attribute? :certificate_arn, Resources::Types::String.constrained(
+          format: /\Aarn:aws:acm:[a-z0-9-]+:\d{12}:certificate\/[a-f0-9-]+\z/
+        )
+
+        # Custom validation for certificate-listener compatibility
+        def self.new(attributes = {})
+          attrs = super(attributes)
+          
+          # Extract regions from ARNs for validation
+          listener_region = attrs.listener_arn.split(':')[3]
+          cert_region = attrs.certificate_arn.split(':')[3]
+          
+          if listener_region != cert_region
+            raise Dry::Struct::Error, "Certificate region (#{cert_region}) must match listener region (#{listener_region})"
+          end
+
+          attrs
+        end
+      end
+    end
+      end
+    end
+  end

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

@@ -0,0 +1,17 @@
+# Type definitions for AWS Load Balancer Listener Certificate resources
+
+module Pangea
+  module Resources
+    module AWS
+      class LoadBalancerListenerCertificateAttributes < Dry::Struct
+        attribute :listener_arn, String
+        attribute :certificate_arn, String
+        
+        def self.new: (Hash[Symbol, untyped] attributes) -> LoadBalancerListenerCertificateAttributes
+      end
+      
+      # Load balancer listener certificate function signature
+      def aws_lb_listener_certificate: (Symbol name, Hash[Symbol, untyped] attributes) -> ResourceReference
+    end
+  end
+end

data/lib/pangea/resources/aws_lb_listener_rule/action_builders.rb

@@ -0,0 +1,123 @@
+# 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.
+
+module Pangea
+  module Resources
+    module AWS
+      # Action builders for AWS LB Listener Rule resource
+      # Extracts complex nested action building logic for cleaner resource definition
+      module LbListenerRuleActionBuilders
+        extend self
+
+        def apply_action(ctx, action)
+          ctx.action do
+            type action[:type]
+            order action[:order] if action[:order]
+
+            case action[:type]
+            when 'forward' then apply_forward(self, action)
+            when 'redirect' then apply_redirect(self, action)
+            when 'fixed-response' then apply_fixed_response(self, action)
+            when 'authenticate-cognito' then apply_cognito_auth(self, action)
+            when 'authenticate-oidc' then apply_oidc_auth(self, action)
+            end
+          end
+        end
+
+        def apply_forward(ctx, action)
+          if action[:target_group_arn]
+            ctx.target_group_arn action[:target_group_arn]
+          elsif action[:forward]
+            ctx.forward do
+              action[:forward][:target_groups].each do |tg|
+                target_group do
+                  arn tg[:arn]
+                  weight tg[:weight] if tg[:weight] != 100
+                end
+              end
+              apply_stickiness(self, action[:forward][:stickiness]) if action[:forward][:stickiness]
+            end
+          end
+        end
+
+        def apply_stickiness(ctx, stickiness)
+          ctx.stickiness do
+            enabled stickiness[:enabled]
+            duration stickiness[:duration] if stickiness[:duration]
+          end
+        end
+
+        def apply_redirect(ctx, action)
+          ctx.redirect do
+            protocol action[:redirect][:protocol] if action[:redirect][:protocol]
+            port action[:redirect][:port] if action[:redirect][:port]
+            host action[:redirect][:host] if action[:redirect][:host]
+            path action[:redirect][:path] if action[:redirect][:path]
+            query action[:redirect][:query] if action[:redirect][:query]
+            status_code action[:redirect][:status_code]
+          end
+        end
+
+        def apply_fixed_response(ctx, action)
+          ctx.fixed_response do
+            content_type action[:fixed_response][:content_type] if action[:fixed_response][:content_type]
+            message_body action[:fixed_response][:message_body] if action[:fixed_response][:message_body]
+            status_code action[:fixed_response][:status_code]
+          end
+        end
+
+        def apply_cognito_auth(ctx, action)
+          cognito = action[:authenticate_cognito]
+          ctx.authenticate_cognito do
+            user_pool_arn cognito[:user_pool_arn]
+            user_pool_client_id cognito[:user_pool_client_id]
+            user_pool_domain cognito[:user_pool_domain]
+            apply_auth_extras(self, cognito[:authentication_request_extra_params])
+            on_unauthenticated_request cognito[:on_unauthenticated_request] if cognito[:on_unauthenticated_request]
+            scope cognito[:scope] if cognito[:scope]
+            session_cookie_name cognito[:session_cookie_name] if cognito[:session_cookie_name]
+            session_timeout cognito[:session_timeout] if cognito[:session_timeout]
+          end
+        end
+
+        def apply_oidc_auth(ctx, action)
+          oidc = action[:authenticate_oidc]
+          ctx.authenticate_oidc do
+            authorization_endpoint oidc[:authorization_endpoint]
+            client_id oidc[:client_id]
+            client_secret oidc[:client_secret]
+            issuer oidc[:issuer]
+            token_endpoint oidc[:token_endpoint]
+            user_info_endpoint oidc[:user_info_endpoint]
+            apply_auth_extras(self, oidc[:authentication_request_extra_params])
+            on_unauthenticated_request oidc[:on_unauthenticated_request] if oidc[:on_unauthenticated_request]
+            scope oidc[:scope] if oidc[:scope]
+            session_cookie_name oidc[:session_cookie_name] if oidc[:session_cookie_name]
+            session_timeout oidc[:session_timeout] if oidc[:session_timeout]
+          end
+        end
+
+        def apply_auth_extras(ctx, params)
+          return unless params
+
+          ctx.authentication_request_extra_params do
+            params.each { |key, value| public_send(key, value) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# 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_lb_listener_rule/types'
+require_relative 'action_builders'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS Load Balancer Listener Rule with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Listener rule attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_lb_listener_rule(name, attributes = {})
+        # Validate attributes using dry-struct
+        rule_attrs = Types::LoadBalancerListenerRuleAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_lb_listener_rule, name) do
+          listener_arn rule_attrs.listener_arn
+          priority rule_attrs.priority
+          
+          # Actions configuration
+          rule_attrs.action.each do |act|
+            LbListenerRuleActionBuilders.apply_action(self, act)
+          end
+          
+          # Conditions configuration
+          rule_attrs.condition.each_with_index do |condition, index|
+            condition do
+              # Legacy condition format (deprecated but supported)
+              if condition[:field] && condition[:values]
+                field condition[:field]
+                values condition[:values]
+              end
+              
+              # Modern condition types
+              if condition[:host_header]
+                host_header do
+                  values condition[:host_header][:values]
+                end
+              end
+              
+              if condition[:path_pattern]
+                path_pattern do
+                  values condition[:path_pattern][:values]
+                end
+              end
+              
+              if condition[:http_method]
+                http_method do
+                  values condition[:http_method][:values]
+                end
+              end
+              
+              if condition[:query_string]
+                condition[:query_string][:values].each do |qs|
+                  query_string do
+                    key qs[:key] if qs[:key]
+                    value qs[:value]
+                  end
+                end
+              end
+              
+              if condition[:http_header]
+                http_header do
+                  http_header_name condition[:http_header][:http_header_name]
+                  values condition[:http_header][:values]
+                end
+              end
+              
+              if condition[:source_ip]
+                source_ip do
+                  values condition[:source_ip][:values]
+                end
+              end
+            end
+          end
+          
+          # Apply tags if present
+          if rule_attrs.tags&.any?
+            tags do
+              rule_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_lb_listener_rule',
+          name: name,
+          resource_attributes: rule_attrs.to_h,
+          outputs: {
+            id: "${aws_lb_listener_rule.#{name}.id}",
+            arn: "${aws_lb_listener_rule.#{name}.arn}",
+            listener_arn: "${aws_lb_listener_rule.#{name}.listener_arn}",
+            priority: "${aws_lb_listener_rule.#{name}.priority}"
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# 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
+      # Type-safe attributes for AWS Load Balancer Listener Rule resources
+      class LoadBalancerListenerRuleAttributes < Pangea::Resources::BaseAttributes
+        # The ARN of the listener to attach the rule to
+        attribute? :listener_arn, Resources::Types::String.optional
+        
+        # The priority for the rule (1-50000, lower numbers have higher priority)
+        attribute? :priority, Resources::Types::Integer.constrained(gteq: 1, lteq: 50000).optional
+        
+        # Actions to take when the rule conditions are met
+        attribute? :action, Resources::Types::Array.of(
+          Resources::Types::Hash.schema(
+            type: Resources::Types::ListenerActionType,
+            target_group_arn?: Resources::Types::String.optional,
+            forward?: Resources::Types::ListenerForwardAction.optional,
+            redirect?: Resources::Types::ListenerRedirectAction.optional,
+            fixed_response?: Resources::Types::ListenerFixedResponseAction.optional,
+            authenticate_cognito?: Resources::Types::ListenerAuthenticateCognitoAction.optional,
+            authenticate_oidc?: Resources::Types::ListenerAuthenticateOidcAction.optional,
+            order?: Resources::Types::Integer.constrained(gteq: 1, lteq: 50000).optional
+          ).lax
+        ).constrained(min_size: 1)
+        
+        # Conditions that must be met for the rule to apply
+        attribute? :condition, Resources::Types::Array.of(
+          Resources::Types::Hash.schema(
+            field?: Resources::Types::String.optional, # Legacy field name
+            values?: Resources::Types::Array.of(Resources::Types::String).optional, # Legacy values
+            host_header?: Resources::Types::ListenerConditionHostHeader.optional,
+            path_pattern?: Resources::Types::ListenerConditionPathPattern.optional,
+            http_method?: Resources::Types::ListenerConditionHttpMethod.optional,
+            query_string?: Resources::Types::ListenerConditionQueryString.optional,
+            http_header?: Resources::Types::ListenerConditionHttpHeader.optional,
+            source_ip?: Resources::Types::ListenerConditionSourceIp.optional
+          ).lax
+        ).constrained(min_size: 1)
+        
+        # Tags to apply to the listener rule
+        attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+        # Custom validation for condition and action completeness
+        def self.new(attributes = {})
+          attrs = super(attributes)
+          
+          # Validate that each condition has proper configuration
+          attrs.condition.each_with_index do |condition, index|
+            condition_types = []
+            
+            # Check legacy condition format first
+            if condition&.dig(:field) && condition&.dig(:values)
+              condition_types << 'legacy'
+            end
+            
+            # Check modern condition types
+            condition_types << 'host-header' if condition&.dig(:host_header)
+            condition_types << 'path-pattern' if condition&.dig(:path_pattern)
+            condition_types << 'http-method' if condition&.dig(:http_method)
+            condition_types << 'query-string' if condition&.dig(:query_string)
+            condition_types << 'http-header' if condition&.dig(:http_header)
+            condition_types << 'source-ip' if condition&.dig(:source_ip)
+            
+            if condition_types.empty?
+              raise Dry::Struct::Error, "Condition #{index + 1} must specify at least one condition type"
+            elsif condition_types.length > 1
+              raise Dry::Struct::Error, "Condition #{index + 1} can only specify one condition type, found: #{condition_types.join(', ')}"
+            end
+          end
+          
+          # Validate actions
+          attrs.action.each_with_index do |action, index|
+            case action&.dig(:type)
+            when 'forward'
+              unless action&.dig(:target_group_arn) || action&.dig(:forward)
+                raise Dry::Struct::Error, "Forward action #{index + 1} requires either target_group_arn or forward configuration"
+              end
+            when 'redirect'
+              unless action&.dig(:redirect)
+                raise Dry::Struct::Error, "Redirect action #{index + 1} requires redirect configuration"
+              end
+            when 'fixed-response'
+              unless action&.dig(:fixed_response)
+                raise Dry::Struct::Error, "Fixed-response action #{index + 1} requires fixed_response configuration"
+              end
+            when 'authenticate-cognito'
+              unless action&.dig(:authenticate_cognito)
+                raise Dry::Struct::Error, "Authenticate-cognito action #{index + 1} requires authenticate_cognito configuration"
+              end
+            when 'authenticate-oidc'
+              unless action&.dig(:authenticate_oidc)
+                raise Dry::Struct::Error, "Authenticate-oidc action #{index + 1} requires authenticate_oidc configuration"
+              end
+            end
+          end
+
+          attrs
+        end
+      end
+    end
+      end
+    end
+  end

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

@@ -0,0 +1,20 @@
+# Type definitions for AWS Load Balancer Listener Rule resources
+
+module Pangea
+  module Resources
+    module AWS
+      class LoadBalancerListenerRuleAttributes < Dry::Struct
+        attribute :listener_arn, String
+        attribute :priority, Integer
+        attribute :action, Array[Hash[Symbol, untyped]]
+        attribute :condition, Array[Hash[Symbol, untyped]]
+        attribute :tags, Hash[Symbol, String]
+        
+        def self.new: (Hash[Symbol, untyped] attributes) -> LoadBalancerListenerRuleAttributes
+      end
+      
+      # Load balancer listener rule function signature
+      def aws_lb_listener_rule: (Symbol name, Hash[Symbol, untyped] attributes) -> ResourceReference
+    end
+  end
+end