pangea 0.0.42 → 0.0.45

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

@@ -0,0 +1,288 @@
+# 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_kinesis_firehose_delivery_stream/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS Kinesis Firehose Delivery Stream for reliable data delivery to destinations
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Kinesis Firehose Delivery Stream attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_kinesis_firehose_delivery_stream(name, attributes = {})
+        # Validate attributes using dry-struct
+        firehose_attrs = Types::KinesisFirehoseDeliveryStreamAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_kinesis_firehose_delivery_stream, name) do
+          name firehose_attrs.name
+          destination firehose_attrs.destination
+          
+          # Kinesis source configuration
+          if firehose_attrs.has_kinesis_source?
+            kinesis_source_configuration do
+              kinesis_stream_arn firehose_attrs.kinesis_source_configuration[:kinesis_stream_arn]
+              role_arn firehose_attrs.kinesis_source_configuration[:role_arn]
+            end
+          end
+          
+          # S3 destination configuration
+          if firehose_attrs.s3_configuration
+            s3_configuration do
+              s3_config = firehose_attrs.s3_configuration
+              role_arn s3_config[:role_arn]
+              bucket_arn s3_config[:bucket_arn]
+              prefix s3_config[:prefix] if s3_config[:prefix]
+              error_output_prefix s3_config[:error_output_prefix] if s3_config[:error_output_prefix]
+              buffer_size s3_config[:buffer_size] if s3_config[:buffer_size]
+              buffer_interval s3_config[:buffer_interval] if s3_config[:buffer_interval]
+              compression_format s3_config[:compression_format] if s3_config[:compression_format]
+              
+              if s3_config[:encryption_configuration]
+                encryption_configuration do
+                  enc_config = s3_config[:encryption_configuration]
+                  if enc_config[:no_encryption_config]
+                    no_encryption_config enc_config[:no_encryption_config]
+                  elsif enc_config[:kms_encryption_config]
+                    kms_encryption_config do
+                      aws_kms_key_arn enc_config[:kms_encryption_config][:aws_kms_key_arn]
+                    end
+                  end
+                end
+              end
+              
+              if s3_config[:cloudwatch_logging_options]
+                cloudwatch_logging_options do
+                  log_config = s3_config[:cloudwatch_logging_options]
+                  enabled log_config[:enabled] if log_config.key?(:enabled)
+                  log_group_name log_config[:log_group_name] if log_config[:log_group_name]
+                  log_stream_name log_config[:log_stream_name] if log_config[:log_stream_name]
+                end
+              end
+            end
+          end
+          
+          # Extended S3 destination configuration
+          if firehose_attrs.extended_s3_configuration
+            extended_s3_configuration do
+              es3_config = firehose_attrs.extended_s3_configuration
+              role_arn es3_config[:role_arn]
+              bucket_arn es3_config[:bucket_arn]
+              prefix es3_config[:prefix] if es3_config[:prefix]
+              error_output_prefix es3_config[:error_output_prefix] if es3_config[:error_output_prefix]
+              buffer_size es3_config[:buffer_size] if es3_config[:buffer_size]
+              buffer_interval es3_config[:buffer_interval] if es3_config[:buffer_interval]
+              compression_format es3_config[:compression_format] if es3_config[:compression_format]
+              s3_backup_mode es3_config[:s3_backup_mode] if es3_config[:s3_backup_mode]
+              
+              # Data format conversion
+              if es3_config[:data_format_conversion_configuration]
+                data_format_conversion_configuration do
+                  df_config = es3_config[:data_format_conversion_configuration]
+                  enabled df_config[:enabled]
+                  
+                  if df_config[:output_format_configuration]
+                    output_format_configuration do
+                      if df_config[:output_format_configuration][:serializer]
+                        serializer do
+                          ser_config = df_config[:output_format_configuration][:serializer]
+                          parquet_ser_de({}) if ser_config[:parquet_ser_de]
+                          orc_ser_de({}) if ser_config[:orc_ser_de]
+                        end
+                      end
+                    end
+                  end
+                  
+                  if df_config[:schema_configuration]
+                    schema_configuration do
+                      schema_config = df_config[:schema_configuration]
+                      database_name schema_config[:database_name]
+                      table_name schema_config[:table_name]
+                      role_arn schema_config[:role_arn]
+                      region schema_config[:region] if schema_config[:region]
+                      catalog_id schema_config[:catalog_id] if schema_config[:catalog_id]
+                      version_id schema_config[:version_id] if schema_config[:version_id]
+                    end
+                  end
+                end
+              end
+              
+              # Processing configuration
+              if es3_config[:processing_configuration]
+                processing_configuration do
+                  proc_config = es3_config[:processing_configuration]
+                  enabled proc_config[:enabled]
+                  
+                  if proc_config[:processors]
+                    proc_config[:processors].each do |processor|
+                      processors do
+                        type processor[:type]
+                        if processor[:parameters]
+                          processor[:parameters].each do |param|
+                            parameters do
+                              parameter_name param[:parameter_name]
+                              parameter_value param[:parameter_value]
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+              
+              if es3_config[:cloudwatch_logging_options]
+                cloudwatch_logging_options do
+                  log_config = es3_config[:cloudwatch_logging_options]
+                  enabled log_config[:enabled] if log_config.key?(:enabled)
+                  log_group_name log_config[:log_group_name] if log_config[:log_group_name]
+                  log_stream_name log_config[:log_stream_name] if log_config[:log_stream_name]
+                end
+              end
+            end
+          end
+          
+          # Other destination configurations (Redshift, Elasticsearch, etc.)
+          if firehose_attrs.redshift_configuration
+            redshift_configuration do
+              rs_config = firehose_attrs.redshift_configuration
+              role_arn rs_config[:role_arn]
+              cluster_jdbcurl rs_config[:cluster_jdbcurl]
+              username rs_config[:username]
+              password rs_config[:password]
+              data_table_name rs_config[:data_table_name]
+              copy_options rs_config[:copy_options] if rs_config[:copy_options]
+              data_table_columns rs_config[:data_table_columns] if rs_config[:data_table_columns]
+              s3_backup_mode rs_config[:s3_backup_mode] if rs_config[:s3_backup_mode]
+            end
+          end
+          
+          if firehose_attrs.elasticsearch_configuration
+            elasticsearch_configuration do
+              es_config = firehose_attrs.elasticsearch_configuration
+              role_arn es_config[:role_arn]
+              domain_arn es_config[:domain_arn]
+              index_name es_config[:index_name]
+              type_name es_config[:type_name] if es_config[:type_name]
+              index_rotation_period es_config[:index_rotation_period] if es_config[:index_rotation_period]
+              buffering_size es_config[:buffering_size] if es_config[:buffering_size]
+              buffering_interval es_config[:buffering_interval] if es_config[:buffering_interval]
+              retry_duration es_config[:retry_duration] if es_config[:retry_duration]
+              s3_backup_mode es_config[:s3_backup_mode] if es_config[:s3_backup_mode]
+            end
+          end
+          
+          if firehose_attrs.amazonopensearch_configuration
+            amazonopensearch_configuration do
+              aos_config = firehose_attrs.amazonopensearch_configuration
+              role_arn aos_config[:role_arn]
+              domain_arn aos_config[:domain_arn]
+              index_name aos_config[:index_name]
+              type_name aos_config[:type_name] if aos_config[:type_name]
+              index_rotation_period aos_config[:index_rotation_period] if aos_config[:index_rotation_period]
+              buffering_size aos_config[:buffering_size] if aos_config[:buffering_size]
+              buffering_interval aos_config[:buffering_interval] if aos_config[:buffering_interval]
+              retry_duration aos_config[:retry_duration] if aos_config[:retry_duration]
+              s3_backup_mode aos_config[:s3_backup_mode] if aos_config[:s3_backup_mode]
+            end
+          end
+          
+          if firehose_attrs.splunk_configuration
+            splunk_configuration do
+              splunk_config = firehose_attrs.splunk_configuration
+              hec_endpoint splunk_config[:hec_endpoint]
+              hec_token splunk_config[:hec_token]
+              hec_acknowledgment_timeout splunk_config[:hec_acknowledgment_timeout] if splunk_config[:hec_acknowledgment_timeout]
+              hec_endpoint_type splunk_config[:hec_endpoint_type] if splunk_config[:hec_endpoint_type]
+              retry_duration splunk_config[:retry_duration] if splunk_config[:retry_duration]
+              s3_backup_mode splunk_config[:s3_backup_mode] if splunk_config[:s3_backup_mode]
+            end
+          end
+          
+          if firehose_attrs.http_endpoint_configuration
+            http_endpoint_configuration do
+              http_config = firehose_attrs.http_endpoint_configuration
+              url http_config[:url]
+              name http_config[:name] if http_config[:name]
+              access_key http_config[:access_key] if http_config[:access_key]
+              buffering_size http_config[:buffering_size] if http_config[:buffering_size]
+              buffering_interval http_config[:buffering_interval] if http_config[:buffering_interval]
+              retry_duration http_config[:retry_duration] if http_config[:retry_duration]
+              s3_backup_mode http_config[:s3_backup_mode] if http_config[:s3_backup_mode]
+              
+              if http_config[:request_configuration]
+                request_configuration do
+                  req_config = http_config[:request_configuration]
+                  content_encoding req_config[:content_encoding] if req_config[:content_encoding]
+                  if req_config[:common_attributes]
+                    req_config[:common_attributes].each do |key, value|
+                      common_attributes do
+                        name key
+                        value value
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          
+          # Server-side encryption
+          if firehose_attrs.is_encrypted?
+            server_side_encryption do
+              sse_config = firehose_attrs.server_side_encryption
+              enabled sse_config[:enabled]
+              key_type sse_config[:key_type] if sse_config[:key_type]
+              key_arn sse_config[:key_arn] if sse_config[:key_arn]
+            end
+          end
+          
+          # Apply tags if present
+          if firehose_attrs.tags.any?
+            tags do
+              firehose_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_kinesis_firehose_delivery_stream',
+          name: name,
+          resource_attributes: firehose_attrs.to_h,
+          outputs: {
+            id: "${aws_kinesis_firehose_delivery_stream.#{name}.id}",
+            name: "${aws_kinesis_firehose_delivery_stream.#{name}.name}",
+            arn: "${aws_kinesis_firehose_delivery_stream.#{name}.arn}",
+            version_id: "${aws_kinesis_firehose_delivery_stream.#{name}.version_id}",
+            destination_id: "${aws_kinesis_firehose_delivery_stream.#{name}.destination_id}",
+            tags_all: "${aws_kinesis_firehose_delivery_stream.#{name}.tags_all}"
+          }
+        )
+      end
+    end
+  end
+end
+
+# Auto-register this module when it's loaded
+Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

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

@@ -0,0 +1,305 @@
+# 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
+        # Kinesis Firehose Delivery Stream resource attributes with validation
+        class KinesisFirehoseDeliveryStreamAttributes < Dry::Struct
+          transform_keys(&:to_sym)
+          
+          attribute :name, String
+          attribute :destination, String.enum(
+            'extended_s3', 's3', 'redshift', 'elasticsearch', 'amazonopensearch', 
+            'splunk', 'http_endpoint', 'snowflake'
+          )
+          
+          # S3 destination configuration
+          attribute :s3_configuration, Hash.schema(
+            role_arn: String,
+            bucket_arn: String,
+            prefix?: String.optional,
+            error_output_prefix?: String.optional,
+            buffer_size?: Integer.constrained(gteq: 1, lteq: 128).optional,
+            buffer_interval?: Integer.constrained(gteq: 60, lteq: 900).optional,
+            compression_format?: String.enum('UNCOMPRESSED', 'GZIP', 'ZIP', 'Snappy', 'HADOOP_SNAPPY').optional,
+            encryption_configuration?: Hash.schema(
+              no_encryption_config?: String.enum('NoEncryption').optional,
+              kms_encryption_config?: Hash.schema(
+                aws_kms_key_arn: String
+              ).optional
+            ).optional,
+            cloudwatch_logging_options?: Hash.schema(
+              enabled?: Bool.optional,
+              log_group_name?: String.optional,
+              log_stream_name?: String.optional
+            ).optional
+          ).optional
+          
+          # Extended S3 destination configuration
+          attribute :extended_s3_configuration, Hash.schema(
+            role_arn: String,
+            bucket_arn: String,
+            prefix?: String.optional,
+            error_output_prefix?: String.optional,
+            buffer_size?: Integer.constrained(gteq: 1, lteq: 128).optional,
+            buffer_interval?: Integer.constrained(gteq: 60, lteq: 900).optional,
+            compression_format?: String.enum('UNCOMPRESSED', 'GZIP', 'ZIP', 'Snappy', 'HADOOP_SNAPPY').optional,
+            data_format_conversion_configuration?: Hash.schema(
+              enabled: Bool,
+              output_format_configuration?: Hash.schema(
+                serializer?: Hash.schema(
+                  parquet_ser_de?: Hash.optional,
+                  orc_ser_de?: Hash.optional
+                ).optional
+              ).optional,
+              schema_configuration?: Hash.schema(
+                database_name: String,
+                table_name: String,
+                role_arn: String,
+                region?: String.optional,
+                catalog_id?: String.optional,
+                version_id?: String.optional
+              ).optional
+            ).optional,
+            processing_configuration?: Hash.schema(
+              enabled: Bool,
+              processors?: Array.of(Hash.schema(
+                type: String.enum('Lambda'),
+                parameters?: Array.of(Hash.schema(
+                  parameter_name: String,
+                  parameter_value: String
+                )).optional
+              )).optional
+            ).optional,
+            cloudwatch_logging_options?: Hash.schema(
+              enabled?: Bool.optional,
+              log_group_name?: String.optional,
+              log_stream_name?: String.optional
+            ).optional,
+            s3_backup_mode?: String.enum('Disabled', 'Enabled').optional,
+            s3_backup_configuration?: Hash.optional
+          ).optional
+          
+          # Redshift destination configuration
+          attribute :redshift_configuration, Hash.schema(
+            role_arn: String,
+            cluster_jdbcurl: String,
+            username: String,
+            password: String,
+            data_table_name: String,
+            copy_options?: String.optional,
+            data_table_columns?: String.optional,
+            s3_backup_mode?: String.enum('Disabled', 'Enabled').optional,
+            s3_backup_configuration?: Hash.optional,
+            processing_configuration?: Hash.optional,
+            cloudwatch_logging_options?: Hash.optional
+          ).optional
+          
+          # Elasticsearch destination configuration
+          attribute :elasticsearch_configuration, Hash.schema(
+            role_arn: String,
+            domain_arn: String,
+            index_name: String,
+            type_name?: String.optional,
+            index_rotation_period?: String.enum('NoRotation', 'OneHour', 'OneDay', 'OneWeek', 'OneMonth').optional,
+            buffering_size?: Integer.constrained(gteq: 1, lteq: 100).optional,
+            buffering_interval?: Integer.constrained(gteq: 60, lteq: 900).optional,
+            retry_duration?: Integer.constrained(gteq: 0, lteq: 7200).optional,
+            s3_backup_mode?: String.enum('FailedDocumentsOnly', 'AllDocuments').optional,
+            processing_configuration?: Hash.optional,
+            cloudwatch_logging_options?: Hash.optional
+          ).optional
+          
+          # OpenSearch destination configuration  
+          attribute :amazonopensearch_configuration, Hash.schema(
+            role_arn: String,
+            domain_arn: String,
+            index_name: String,
+            type_name?: String.optional,
+            index_rotation_period?: String.enum('NoRotation', 'OneHour', 'OneDay', 'OneWeek', 'OneMonth').optional,
+            buffering_size?: Integer.constrained(gteq: 1, lteq: 100).optional,
+            buffering_interval?: Integer.constrained(gteq: 60, lteq: 900).optional,
+            retry_duration?: Integer.constrained(gteq: 0, lteq: 7200).optional,
+            s3_backup_mode?: String.enum('FailedDocumentsOnly', 'AllDocuments').optional,
+            processing_configuration?: Hash.optional,
+            cloudwatch_logging_options?: Hash.optional
+          ).optional
+          
+          # Splunk destination configuration
+          attribute :splunk_configuration, Hash.schema(
+            hec_endpoint: String,
+            hec_token: String,
+            hec_acknowledgment_timeout?: Integer.constrained(gteq: 180, lteq: 600).optional,
+            hec_endpoint_type?: String.enum('Raw', 'Event').optional,
+            retry_duration?: Integer.constrained(gteq: 0, lteq: 7200).optional,
+            s3_backup_mode?: String.enum('FailedEventsOnly', 'AllEvents').optional,
+            processing_configuration?: Hash.optional,
+            cloudwatch_logging_options?: Hash.optional
+          ).optional
+          
+          # HTTP endpoint destination configuration
+          attribute :http_endpoint_configuration, Hash.schema(
+            url: String,
+            name?: String.optional,
+            access_key?: String.optional,
+            buffering_size?: Integer.constrained(gteq: 1, lteq: 64).optional,
+            buffering_interval?: Integer.constrained(gteq: 60, lteq: 900).optional,
+            retry_duration?: Integer.constrained(gteq: 0, lteq: 7200).optional,
+            s3_backup_mode?: String.enum('FailedDataOnly', 'AllData').optional,
+            request_configuration?: Hash.schema(
+              content_encoding?: String.enum('NONE', 'GZIP').optional,
+              common_attributes?: Hash.map(String, String).optional
+            ).optional,
+            processing_configuration?: Hash.optional,
+            cloudwatch_logging_options?: Hash.optional
+          ).optional
+          
+          # Kinesis source configuration
+          attribute :kinesis_source_configuration, Hash.schema(
+            kinesis_stream_arn: String,
+            role_arn: String
+          ).optional
+          
+          # Server-side encryption
+          attribute :server_side_encryption, Hash.schema(
+            enabled?: Bool.default(false),
+            key_type?: String.enum('AWS_OWNED_CMK', 'CUSTOMER_MANAGED_CMK').optional,
+            key_arn?: String.optional
+          ).optional
+          
+          attribute :tags, Resources::Types::AwsTags
+          
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(Hash) ? attributes : {}
+            
+            # Validate destination configuration is provided
+            destination_configs = [
+              :s3_configuration, :extended_s3_configuration, :redshift_configuration,
+              :elasticsearch_configuration, :amazonopensearch_configuration,
+              :splunk_configuration, :http_endpoint_configuration
+            ]
+            
+            destination = attrs[:destination]
+            config_key = case destination
+                        when 's3' then :s3_configuration
+                        when 'extended_s3' then :extended_s3_configuration
+                        when 'redshift' then :redshift_configuration
+                        when 'elasticsearch' then :elasticsearch_configuration
+                        when 'amazonopensearch' then :amazonopensearch_configuration
+                        when 'splunk' then :splunk_configuration
+                        when 'http_endpoint' then :http_endpoint_configuration
+                        end
+            
+            if config_key && !attrs[config_key]
+              raise Dry::Struct::Error, "#{config_key} is required when destination is '#{destination}'"
+            end
+            
+            # Validate encryption configuration for server-side encryption
+            if attrs[:server_side_encryption] && attrs[:server_side_encryption][:enabled]
+              sse_config = attrs[:server_side_encryption]
+              if sse_config[:key_type] == 'CUSTOMER_MANAGED_CMK' && !sse_config[:key_arn]
+                raise Dry::Struct::Error, "key_arn is required when key_type is 'CUSTOMER_MANAGED_CMK'"
+              end
+            end
+            
+            # Validate ARN formats
+            if attrs[:kinesis_source_configuration]
+              validate_arn!(attrs[:kinesis_source_configuration][:kinesis_stream_arn], 'kinesis')
+              validate_arn!(attrs[:kinesis_source_configuration][:role_arn], 'iam')
+            end
+            
+            super(attrs)
+          end
+          
+          # ARN validation helper
+          def self.validate_arn!(arn, service)
+            pattern = case service
+                     when 'kinesis' then /\Aarn:aws:kinesis:[a-z0-9-]+:\d{12}:stream\/[a-zA-Z0-9_-]+\z/
+                     when 'iam' then /\Aarn:aws:iam::\d{12}:role\/[a-zA-Z0-9_\+\=\,\.\@\-]+\z/
+                     when 's3' then /\Aarn:aws:s3:::[a-z0-9.-]+\z/
+                     else /\Aarn:aws:[a-z0-9-]+:[a-z0-9-]*:\d{12}:.+\z/
+                     end
+            
+            unless arn.match?(pattern)
+              raise Dry::Struct::Error, "Invalid #{service} ARN format: #{arn}"
+            end
+          end
+          
+          # Computed properties
+          def has_data_transformation?
+            case destination
+            when 'extended_s3'
+              extended_s3_configuration&.dig(:processing_configuration, :enabled) == true
+            when 'redshift', 'elasticsearch', 'amazonopensearch', 'splunk', 'http_endpoint'
+              config = public_send("#{destination}_configuration".to_sym)
+              config&.dig(:processing_configuration, :enabled) == true
+            else
+              false
+            end
+          end
+          
+          def has_format_conversion?
+            destination == 'extended_s3' && 
+              extended_s3_configuration&.dig(:data_format_conversion_configuration, :enabled) == true
+          end
+          
+          def backup_enabled?
+            case destination
+            when 'extended_s3'
+              extended_s3_configuration&.dig(:s3_backup_mode) == 'Enabled'
+            when 'redshift'
+              redshift_configuration&.dig(:s3_backup_mode) == 'Enabled'
+            when 'elasticsearch'
+              elasticsearch_configuration&.dig(:s3_backup_mode) == 'AllDocuments'
+            when 'amazonopensearch'
+              amazonopensearch_configuration&.dig(:s3_backup_mode) == 'AllDocuments'
+            when 'splunk'
+              splunk_configuration&.dig(:s3_backup_mode) == 'AllEvents'
+            when 'http_endpoint'
+              http_endpoint_configuration&.dig(:s3_backup_mode) == 'AllData'
+            else
+              false
+            end
+          end
+          
+          def is_encrypted?
+            server_side_encryption&.dig(:enabled) == true
+          end
+          
+          def uses_customer_managed_key?
+            is_encrypted? && server_side_encryption&.dig(:key_type) == 'CUSTOMER_MANAGED_CMK'
+          end
+          
+          def has_kinesis_source?
+            !kinesis_source_configuration.nil?
+          end
+          
+          def estimated_monthly_cost_usd
+            # Base Firehose pricing: $0.029 per GB ingested
+            # Plus destination-specific costs and data transformation costs
+            "Variable - depends on data volume and destination"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        class KinesisFirehoseDeliveryStreamAttributes < Dry::Struct
+          @attributes: Hash[Symbol, untyped]
+          
+          attr_reader name: String
+          attr_reader destination: String
+          attr_reader s3_configuration: Hash[Symbol, untyped]?
+          attr_reader extended_s3_configuration: Hash[Symbol, untyped]?
+          attr_reader redshift_configuration: Hash[Symbol, untyped]?
+          attr_reader elasticsearch_configuration: Hash[Symbol, untyped]?
+          attr_reader amazonopensearch_configuration: Hash[Symbol, untyped]?
+          attr_reader splunk_configuration: Hash[Symbol, untyped]?
+          attr_reader http_endpoint_configuration: Hash[Symbol, untyped]?
+          attr_reader kinesis_source_configuration: Hash[Symbol, String]?
+          attr_reader server_side_encryption: Hash[Symbol, untyped]?
+          attr_reader tags: Hash[Symbol, String]
+          
+          def self.new: (Hash[Symbol, untyped] attributes) -> KinesisFirehoseDeliveryStreamAttributes
+          
+          # Validation methods
+          def self.validate_arn!: (String arn, String service) -> void
+          
+          # Query methods
+          def has_data_transformation?: () -> bool
+          def has_format_conversion?: () -> bool
+          def backup_enabled?: () -> bool
+          def is_encrypted?: () -> bool
+          def uses_customer_managed_key?: () -> bool
+          def has_kinesis_source?: () -> bool
+          
+          # Cost estimation
+          def estimated_monthly_cost_usd: () -> String
+          
+          def to_h: () -> Hash[Symbol, untyped]
+        end
+      end
+    end
+  end
+end