pangea-aws 0.1.0

data/lib/pangea/resources/aws_kinesis_analytics_application/types/computed.rb

@@ -0,0 +1,131 @@
+# 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
+      module Types
+        class KinesisAnalyticsApplicationAttributes
+          # Computed properties for Kinesis Analytics Application
+          module Computed
+            COST_PER_KPU_HOUR = 0.11
+            HOURS_PER_MONTH = 24 * 30
+
+            def is_sql_application?
+              runtime_environment == 'SQL-1_0'
+            end
+
+            def is_flink_application?
+              runtime_environment.start_with?('FLINK')
+            end
+
+            def has_vpc_configuration?
+              !application_configuration&.dig(:vpc_configuration).nil?
+            end
+
+            def has_code_from_s3?
+              !application_configuration&.dig(:application_code_configuration, :code_content, :s3_content_location).nil?
+            end
+
+            def has_monitoring_enabled?
+              flink_config = application_configuration&.dig(:flink_application_configuration, :monitoring_configuration)
+              return false unless flink_config
+
+              flink_config[:configuration_type] == 'CUSTOM'
+            end
+
+            def has_checkpointing_enabled?
+              checkpoint_config = application_configuration&.dig(:flink_application_configuration,
+                                                                 :checkpoint_configuration)
+              return false unless checkpoint_config
+
+              checkpoint_config[:configuration_type] == 'CUSTOM' && checkpoint_config[:checkpointing_enabled] == true
+            end
+
+            def parallelism_level
+              parallel_config = application_configuration&.dig(:flink_application_configuration,
+                                                               :parallelism_configuration)
+              return nil unless parallel_config
+
+              parallel_config[:parallelism] || 1
+            end
+
+            def auto_scaling_enabled?
+              parallel_config = application_configuration&.dig(:flink_application_configuration,
+                                                               :parallelism_configuration)
+              return false unless parallel_config
+
+              parallel_config[:auto_scaling_enabled] == true
+            end
+
+            def input_count
+              return 0 unless is_sql_application?
+
+              sql_config = application_configuration&.dig(:sql_application_configuration)
+              sql_config&.dig(:inputs)&.length || 0
+            end
+
+            def output_count
+              return 0 unless is_sql_application?
+
+              sql_config = application_configuration&.dig(:sql_application_configuration)
+              sql_config&.dig(:outputs)&.length || 0
+            end
+
+            def reference_data_source_count
+              return 0 unless is_sql_application?
+
+              sql_config = application_configuration&.dig(:sql_application_configuration)
+              sql_config&.dig(:reference_data_sources)&.length || 0
+            end
+
+            def estimated_kpu_usage
+              if is_sql_application?
+                estimate_sql_kpu_usage
+              elsif is_flink_application?
+                estimate_flink_kpu_usage
+              else
+                1
+              end
+            end
+
+            def estimated_monthly_cost_usd
+              kpu_usage = estimated_kpu_usage
+              monthly_cost = kpu_usage * HOURS_PER_MONTH * COST_PER_KPU_HOUR
+              monthly_cost.round(2)
+            end
+
+            private
+
+            def estimate_sql_kpu_usage
+              base_kpu = 1
+              additional_kpu = (input_count + output_count) * 0.1
+              (base_kpu + additional_kpu).ceil
+            end
+
+            def estimate_flink_kpu_usage
+              parallelism = parallelism_level || 1
+              kpu_per_parallelism = application_configuration&.dig(
+                :flink_application_configuration, :parallelism_configuration, :parallelism_per_kpu
+              ) || 1
+              (parallelism.to_f / kpu_per_parallelism).ceil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_kinesis_analytics_application/types/configs.rb

@@ -0,0 +1,91 @@
+# 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
+      module Types
+        class KinesisAnalyticsApplicationAttributes
+          # Configuration type definitions for Kinesis Analytics Application
+          module Configs
+            include Pangea::Resources::Types
+            S3ContentLocation = Hash.schema(
+              bucket_arn: String,
+              file_key: String,
+              object_version?: String.optional
+            ).lax
+
+            CodeContent = Hash.schema(
+              text_content?: String.optional,
+              zip_file_content?: String.optional,
+              s3_content_location?: S3ContentLocation.optional
+            ).lax
+
+            ApplicationCodeConfiguration = Hash.schema(
+              code_content: CodeContent,
+              code_content_type: String.constrained(included_in: ['PLAINTEXT', 'ZIPFILE'])
+            ).lax
+
+            CheckpointConfiguration = Hash.schema(
+              configuration_type: String.constrained(included_in: ['DEFAULT', 'CUSTOM']),
+              checkpointing_enabled?: Bool.optional,
+              checkpoint_interval?: Integer.constrained(gteq: 1000, lteq: 300_000).optional,
+              min_pause_between_checkpoints?: Integer.constrained(gteq: 0, lteq: 300_000).optional
+            ).lax
+
+            MonitoringConfiguration = Hash.schema(
+              configuration_type: String.constrained(included_in: ['DEFAULT', 'CUSTOM']),
+              log_level?: String.constrained(included_in: ['INFO', 'WARN', 'ERROR', 'DEBUG']).optional,
+              metrics_level?: String.constrained(included_in: ['APPLICATION', 'TASK', 'OPERATOR', 'PARALLELISM']).optional
+            ).lax
+
+            ParallelismConfiguration = Hash.schema(
+              configuration_type: String.constrained(included_in: ['DEFAULT', 'CUSTOM']),
+              parallelism?: Integer.constrained(gteq: 1, lteq: 1000).optional,
+              parallelism_per_kpu?: Integer.constrained(gteq: 1, lteq: 4).optional,
+              auto_scaling_enabled?: Bool.optional
+            ).lax
+
+            FlinkApplicationConfiguration = Hash.schema(
+              checkpoint_configuration?: CheckpointConfiguration.optional,
+              monitoring_configuration?: MonitoringConfiguration.optional,
+              parallelism_configuration?: ParallelismConfiguration.optional
+            ).lax
+
+            EnvironmentProperties = Hash.schema(
+              property_groups: Array.of(Hash.schema(
+                property_group_id: String.constrained(min_size: 1, max_size: 50),
+                property_map: Hash.map(
+                  String.constrained(min_size: 1, max_size: 2048),
+                  String.constrained(min_size: 1, max_size: 2048)
+                )
+              )).lax
+            )
+
+
+            unless const_defined?(:VpcConfiguration)
+            VpcConfiguration = Hash.schema(
+              subnet_ids: Array.of(String).constrained(min_size: 2, max_size: 16),
+              security_group_ids: Array.of(String).constrained(min_size: 1, max_size: 5)
+            ).lax
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_kinesis_analytics_application/types/sql_configs.rb

@@ -0,0 +1,114 @@
+# 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
+      module Types
+        class KinesisAnalyticsApplicationAttributes
+          # SQL Application Configuration types for Kinesis Analytics
+          module SqlConfigs
+            include Pangea::Resources::Types
+            SQL_TYPES = %w[BOOLEAN INTEGER BIGINT DOUBLE DECIMAL VARCHAR CHAR TIMESTAMP DATE TIME].freeze
+
+            RecordColumn = Hash.schema(
+              name: String.constrained(min_size: 1, max_size: 256),
+              sql_type: String.enum(*SQL_TYPES),
+              mapping?: String.optional
+            ).lax
+
+            JsonMappingParameters = Hash.schema(
+              record_row_path: String
+            ).lax
+
+            CsvMappingParameters = Hash.schema(
+              record_row_delimiter: String.constrained(min_size: 1, max_size: 1024),
+              record_column_delimiter: String.constrained(min_size: 1, max_size: 1024)
+            ).lax
+
+            MappingParameters = Hash.schema(
+              json_mapping_parameters?: JsonMappingParameters.optional,
+              csv_mapping_parameters?: CsvMappingParameters.optional
+            ).lax
+
+            RecordFormat = Hash.schema(
+              record_format_type: String.constrained(included_in: ['JSON', 'CSV']),
+              mapping_parameters?: MappingParameters.optional
+            ).lax
+
+            InputSchema = Hash.schema(
+              record_columns: Array.of(RecordColumn).constrained(min_size: 1, max_size: 1000),
+              record_format: RecordFormat,
+              record_encoding?: String.constrained(included_in: ['UTF-8']).optional
+            ).lax
+
+            KinesisStreamsInput = Hash.schema(resource_arn: String).lax
+            KinesisFirehoseInput = Hash.schema(resource_arn: String).lax
+
+            InputConfig = Hash.schema(
+              name_prefix: String.constrained(min_size: 1, max_size: 32),
+              input_parallelism?: Hash.schema(count?: Integer.constrained(gteq: 1, lteq: 64).lax.optional).optional,
+              input_schema: InputSchema,
+              kinesis_streams_input?: KinesisStreamsInput.optional,
+              kinesis_firehose_input?: KinesisFirehoseInput.optional
+            )
+
+            DestinationSchema = Hash.schema(
+              record_format_type: String.constrained(included_in: ['JSON', 'CSV'])
+            ).lax
+
+            OutputConfig = Hash.schema(
+              name: String.constrained(min_size: 1, max_size: 32),
+              destination_schema: DestinationSchema,
+              kinesis_streams_output?: Hash.schema(resource_arn: String).lax.optional,
+              kinesis_firehose_output?: Hash.schema(resource_arn: String).lax.optional,
+              lambda_output?: Hash.schema(resource_arn: String).lax.optional
+            )
+
+            ReferenceRecordColumn = Hash.schema(
+              name: String,
+              sql_type: String,
+              mapping?: String.optional
+            ).lax
+
+            ReferenceRecordFormat = Hash.schema(
+              record_format_type: String.constrained(included_in: ['JSON', 'CSV']),
+              mapping_parameters?: Hash.optional
+            ).lax
+
+            ReferenceSchema = Hash.schema(
+              record_columns: Array.of(ReferenceRecordColumn),
+              record_format: ReferenceRecordFormat,
+              record_encoding?: String.constrained(included_in: ['UTF-8']).optional
+            ).lax
+
+            ReferenceDataSource = Hash.schema(
+              table_name: String.constrained(min_size: 1, max_size: 32),
+              reference_schema: ReferenceSchema,
+              s3_reference_data_source?: Hash.schema(bucket_arn: String, file_key: String).lax.optional
+            )
+
+            SqlApplicationConfiguration = Hash.schema(
+              inputs?: Array.of(InputConfig).optional,
+              outputs?: Array.of(OutputConfig).optional,
+              reference_data_sources?: Array.of(ReferenceDataSource).optional
+            ).lax
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_kinesis_analytics_application/types/validation.rb

@@ -0,0 +1,109 @@
+# 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
+      module Types
+        class KinesisAnalyticsApplicationAttributes
+          # Validation methods for Kinesis Analytics Application
+          module Validation
+            IAM_ROLE_ARN_PATTERN = /\Aarn:aws:iam::\d{12}:role\/[a-zA-Z0-9_\+\=\,\.\@\-]+\z/.freeze
+
+            def self.valid_iam_role_arn?(arn)
+              arn.match?(IAM_ROLE_ARN_PATTERN)
+            end
+
+            def self.validate_attributes(attrs)
+              validate_service_execution_role(attrs[:service_execution_role])
+              validate_runtime_configuration(attrs[:runtime_environment], attrs[:application_configuration])
+              validate_code_content(attrs[:application_configuration])
+              validate_sql_configuration(attrs[:application_configuration])
+            end
+
+            def self.validate_service_execution_role(role_arn)
+              return unless role_arn && !valid_iam_role_arn?(role_arn)
+
+              raise Dry::Struct::Error, "Invalid service execution role ARN: #{role_arn}"
+            end
+
+            def self.validate_runtime_configuration(runtime, app_config)
+              return unless runtime && app_config
+
+              if runtime == 'SQL-1_0' && !app_config[:sql_application_configuration]
+                raise Dry::Struct::Error, 'SQL-1_0 runtime requires sql_application_configuration'
+              end
+
+              return unless runtime.start_with?('FLINK')
+              return if app_config[:flink_application_configuration] || app_config[:application_code_configuration]
+
+              raise Dry::Struct::Error,
+                    'Flink runtime requires flink_application_configuration and/or application_code_configuration'
+            end
+
+            def self.validate_code_content(app_config)
+              code_config = app_config&.dig(:application_code_configuration)
+              return unless code_config
+
+              content = code_config[:code_content]
+              content_type = code_config[:code_content_type]
+
+              case content_type
+              when 'PLAINTEXT'
+                raise Dry::Struct::Error, 'PLAINTEXT code content type requires text_content' unless content[:text_content]
+              when 'ZIPFILE'
+                return if content[:zip_file_content] || content[:s3_content_location]
+
+                raise Dry::Struct::Error, 'ZIPFILE code content type requires zip_file_content or s3_content_location'
+              end
+            end
+
+            def self.validate_sql_configuration(app_config)
+              sql_config = app_config&.dig(:sql_application_configuration)
+              return unless sql_config
+
+              validate_sql_inputs(sql_config[:inputs])
+              validate_sql_outputs(sql_config[:outputs])
+            end
+
+            def self.validate_sql_inputs(inputs)
+              return unless inputs
+
+              inputs.each do |input|
+                next if input[:kinesis_streams_input] || input[:kinesis_firehose_input]
+
+                raise Dry::Struct::Error,
+                      "SQL input '#{input[:name_prefix]}' must have either kinesis_streams_input or kinesis_firehose_input"
+              end
+            end
+
+            def self.validate_sql_outputs(outputs)
+              return unless outputs
+
+              outputs.each do |output|
+                next if output[:kinesis_streams_output] || output[:kinesis_firehose_output] || output[:lambda_output]
+
+                raise Dry::Struct::Error,
+                      "SQL output '#{output[:name]}' must have a destination " \
+                      '(kinesis_streams_output, kinesis_firehose_output, or lambda_output)'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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 Analytics Application resource attributes with validation
+        class KinesisAnalyticsApplicationAttributes < Pangea::Resources::BaseAttributes
+          require_relative 'types/configs'
+          require_relative 'types/sql_configs'
+          require_relative 'types/validation'
+          require_relative 'types/computed'
+
+          include Computed
+
+          transform_keys(&:to_sym)
+
+          RUNTIME_ENVIRONMENTS = %w[SQL-1_0 FLINK-1_6 FLINK-1_8 FLINK-1_11 FLINK-1_13 FLINK-1_15 FLINK-1_18].freeze
+
+          # Core attributes
+          attribute? :name, Resources::Types::String.optional
+          attribute? :description, Resources::Types::String.optional
+          attribute? :service_execution_role, Resources::Types::String.optional
+          attribute? :runtime_environment, Resources::Types::String.enum(*RUNTIME_ENVIRONMENTS).optional
+          attribute :start_application, Resources::Types::Bool.default(false)
+          attribute? :tags, Resources::Types::AwsTags.optional
+
+          # Application configuration with nested types from sub-modules
+          attribute? :application_configuration, Resources::Types::Hash.schema(
+            application_code_configuration?: Configs::ApplicationCodeConfiguration.optional,
+            flink_application_configuration?: Configs::FlinkApplicationConfiguration.optional,
+            sql_application_configuration?: SqlConfigs::SqlApplicationConfiguration.optional,
+            environment_properties?: Configs::EnvironmentProperties.optional,
+            vpc_configuration?: Configs::VpcConfiguration.optional
+          ).lax.optional
+
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            Validation.validate_attributes(attrs)
+            super(attrs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        class KinesisAnalyticsApplicationAttributes < Dry::Struct
+          @attributes: Hash[Symbol, untyped]
+          
+          attr_reader name: String
+          attr_reader description: String?
+          attr_reader application_configuration: Hash[Symbol, untyped]?
+          attr_reader service_execution_role: String
+          attr_reader runtime_environment: String
+          attr_reader start_application: bool
+          attr_reader tags: Hash[Symbol, String]
+          
+          def self.new: (Hash[Symbol, untyped] attributes) -> KinesisAnalyticsApplicationAttributes
+          
+          # Validation methods
+          def self.valid_iam_role_arn?: (String arn) -> bool
+          
+          # Query methods
+          def is_sql_application?: () -> bool
+          def is_flink_application?: () -> bool
+          def has_vpc_configuration?: () -> bool
+          def has_code_from_s3?: () -> bool
+          def has_monitoring_enabled?: () -> bool
+          def has_checkpointing_enabled?: () -> bool
+          def auto_scaling_enabled?: () -> bool
+          
+          # Computed properties
+          def parallelism_level: () -> Integer?
+          def input_count: () -> Integer
+          def output_count: () -> Integer
+          def reference_data_source_count: () -> Integer
+          def estimated_kpu_usage: () -> Integer
+          def estimated_monthly_cost_usd: () -> Float
+          
+          def to_h: () -> Hash[Symbol, untyped]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# 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_relative 's3_builders'
+
+module Pangea
+  module Resources
+    module AWS
+      # Builder methods for Kinesis Firehose destination configurations
+      module FirehoseDestinationBuilders
+        include FirehoseS3Builders
+
+        private
+
+        def build_redshift_configuration(builder, rs_config)
+          builder.redshift_configuration do
+            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
+
+        def build_elasticsearch_configuration(builder, es_config)
+          builder.elasticsearch_configuration do
+            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
+
+        def build_opensearch_configuration(builder, aos_config)
+          builder.amazonopensearch_configuration do
+            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
+
+        def build_splunk_configuration(builder, splunk_config)
+          builder.splunk_configuration do
+            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
+
+        def build_http_endpoint_configuration(builder, http_config)
+          builder.http_endpoint_configuration do
+            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]
+
+            build_http_request_configuration(self, http_config[:request_configuration]) if http_config[:request_configuration]
+          end
+        end
+
+        def build_http_request_configuration(builder, req_config)
+          builder.request_configuration do
+            content_encoding req_config[:content_encoding] if req_config[:content_encoding]
+            req_config[:common_attributes]&.each do |key, value|
+              common_attributes do
+                name key
+                value value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end