pangea 0.0.45 → 0.0.46

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

@@ -1,309 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-require 'pangea/resources/base'
-require 'pangea/resources/reference'
-require 'pangea/resources/aws_kinesis_analytics_application/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS Kinesis Analytics Application for real-time stream processing
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] Kinesis Analytics Application attributes
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      def aws_kinesis_analytics_application(name, attributes = {})
-        # Validate attributes using dry-struct
-        analytics_attrs = Types::KinesisAnalyticsApplicationAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_kinesisanalyticsv2_application, name) do
-          name analytics_attrs.name
-          runtime_environment analytics_attrs.runtime_environment
-          service_execution_role analytics_attrs.service_execution_role
-          start_application analytics_attrs.start_application
-          description analytics_attrs.description if analytics_attrs.description
-          
-          # Application configuration
-          if analytics_attrs.application_configuration
-            application_configuration do
-              app_config = analytics_attrs.application_configuration
-              
-              # Application code configuration
-              if app_config[:application_code_configuration]
-                application_code_configuration do
-                  code_config = app_config[:application_code_configuration]
-                  code_content_type code_config[:code_content_type]
-                  
-                  code_content do
-                    content = code_config[:code_content]
-                    text_content content[:text_content] if content[:text_content]
-                    zip_file_content content[:zip_file_content] if content[:zip_file_content]
-                    
-                    if content[:s3_content_location]
-                      s3_content_location do
-                        s3_location = content[:s3_content_location]
-                        bucket_arn s3_location[:bucket_arn]
-                        file_key s3_location[:file_key]
-                        object_version s3_location[:object_version] if s3_location[:object_version]
-                      end
-                    end
-                  end
-                end
-              end
-              
-              # Flink application configuration
-              if app_config[:flink_application_configuration]
-                flink_application_configuration do
-                  flink_config = app_config[:flink_application_configuration]
-                  
-                  if flink_config[:checkpoint_configuration]
-                    checkpoint_configuration do
-                      checkpoint_config = flink_config[:checkpoint_configuration]
-                      configuration_type checkpoint_config[:configuration_type]
-                      checkpointing_enabled checkpoint_config[:checkpointing_enabled] if checkpoint_config.key?(:checkpointing_enabled)
-                      checkpoint_interval checkpoint_config[:checkpoint_interval] if checkpoint_config[:checkpoint_interval]
-                      min_pause_between_checkpoints checkpoint_config[:min_pause_between_checkpoints] if checkpoint_config[:min_pause_between_checkpoints]
-                    end
-                  end
-                  
-                  if flink_config[:monitoring_configuration]
-                    monitoring_configuration do
-                      monitor_config = flink_config[:monitoring_configuration]
-                      configuration_type monitor_config[:configuration_type]
-                      log_level monitor_config[:log_level] if monitor_config[:log_level]
-                      metrics_level monitor_config[:metrics_level] if monitor_config[:metrics_level]
-                    end
-                  end
-                  
-                  if flink_config[:parallelism_configuration]
-                    parallelism_configuration do
-                      parallel_config = flink_config[:parallelism_configuration]
-                      configuration_type parallel_config[:configuration_type]
-                      parallelism parallel_config[:parallelism] if parallel_config[:parallelism]
-                      parallelism_per_kpu parallel_config[:parallelism_per_kpu] if parallel_config[:parallelism_per_kpu]
-                      auto_scaling_enabled parallel_config[:auto_scaling_enabled] if parallel_config.key?(:auto_scaling_enabled)
-                    end
-                  end
-                end
-              end
-              
-              # SQL application configuration
-              if app_config[:sql_application_configuration]
-                sql_application_configuration do
-                  sql_config = app_config[:sql_application_configuration]
-                  
-                  # Inputs
-                  if sql_config[:inputs]
-                    sql_config[:inputs].each do |input_config|
-                      input do
-                        name_prefix input_config[:name_prefix]
-                        
-                        if input_config[:input_parallelism]
-                          input_parallelism do
-                            count input_config[:input_parallelism][:count] if input_config[:input_parallelism][:count]
-                          end
-                        end
-                        
-                        input_schema do
-                          schema_config = input_config[:input_schema]
-                          record_encoding schema_config[:record_encoding] if schema_config[:record_encoding]
-                          
-                          schema_config[:record_columns].each do |column|
-                            record_column do
-                              name column[:name]
-                              sql_type column[:sql_type]
-                              mapping column[:mapping] if column[:mapping]
-                            end
-                          end
-                          
-                          record_format do
-                            format_config = schema_config[:record_format]
-                            record_format_type format_config[:record_format_type]
-                            
-                            if format_config[:mapping_parameters]
-                              mapping_parameters do
-                                mapping_params = format_config[:mapping_parameters]
-                                
-                                if mapping_params[:json_mapping_parameters]
-                                  json_mapping_parameters do
-                                    record_row_path mapping_params[:json_mapping_parameters][:record_row_path]
-                                  end
-                                end
-                                
-                                if mapping_params[:csv_mapping_parameters]
-                                  csv_mapping_parameters do
-                                    csv_params = mapping_params[:csv_mapping_parameters]
-                                    record_row_delimiter csv_params[:record_row_delimiter]
-                                    record_column_delimiter csv_params[:record_column_delimiter]
-                                  end
-                                end
-                              end
-                            end
-                          end
-                        end
-                        
-                        if input_config[:kinesis_streams_input]
-                          kinesis_streams_input do
-                            resource_arn input_config[:kinesis_streams_input][:resource_arn]
-                          end
-                        end
-                        
-                        if input_config[:kinesis_firehose_input]
-                          kinesis_firehose_input do
-                            resource_arn input_config[:kinesis_firehose_input][:resource_arn]
-                          end
-                        end
-                      end
-                    end
-                  end
-                  
-                  # Outputs
-                  if sql_config[:outputs]
-                    sql_config[:outputs].each do |output_config|
-                      output do
-                        name output_config[:name]
-                        
-                        destination_schema do
-                          record_format_type output_config[:destination_schema][:record_format_type]
-                        end
-                        
-                        if output_config[:kinesis_streams_output]
-                          kinesis_streams_output do
-                            resource_arn output_config[:kinesis_streams_output][:resource_arn]
-                          end
-                        end
-                        
-                        if output_config[:kinesis_firehose_output]
-                          kinesis_firehose_output do
-                            resource_arn output_config[:kinesis_firehose_output][:resource_arn]
-                          end
-                        end
-                        
-                        if output_config[:lambda_output]
-                          lambda_output do
-                            resource_arn output_config[:lambda_output][:resource_arn]
-                          end
-                        end
-                      end
-                    end
-                  end
-                  
-                  # Reference data sources
-                  if sql_config[:reference_data_sources]
-                    sql_config[:reference_data_sources].each do |ref_source|
-                      reference_data_source do
-                        table_name ref_source[:table_name]
-                        
-                        reference_schema do
-                          schema_config = ref_source[:reference_schema]
-                          record_encoding schema_config[:record_encoding] if schema_config[:record_encoding]
-                          
-                          schema_config[:record_columns].each do |column|
-                            record_column do
-                              name column[:name]
-                              sql_type column[:sql_type]
-                              mapping column[:mapping] if column[:mapping]
-                            end
-                          end
-                          
-                          record_format do
-                            format_config = schema_config[:record_format]
-                            record_format_type format_config[:record_format_type]
-                            
-                            if format_config[:mapping_parameters]
-                              mapping_parameters do
-                                # JSON or CSV mapping parameters similar to inputs
-                              end
-                            end
-                          end
-                        end
-                        
-                        if ref_source[:s3_reference_data_source]
-                          s3_reference_data_source do
-                            s3_source = ref_source[:s3_reference_data_source]
-                            bucket_arn s3_source[:bucket_arn]
-                            file_key s3_source[:file_key]
-                          end
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-              
-              # Environment properties
-              if app_config[:environment_properties]
-                environment_properties do
-                  app_config[:environment_properties][:property_groups].each do |prop_group|
-                    property_group do
-                      property_group_id prop_group[:property_group_id]
-                      property_map do
-                        prop_group[:property_map].each do |key, value|
-                          public_send(key, value)
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-              
-              # VPC configuration
-              if app_config[:vpc_configuration]
-                vpc_configuration do
-                  vpc_config = app_config[:vpc_configuration]
-                  subnet_ids vpc_config[:subnet_ids]
-                  security_group_ids vpc_config[:security_group_ids]
-                end
-              end
-            end
-          end
-          
-          # Apply tags if present
-          if analytics_attrs.tags.any?
-            tags do
-              analytics_attrs.tags.each do |key, value|
-                public_send(key, value)
-              end
-            end
-          end
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_kinesisanalyticsv2_application',
-          name: name,
-          resource_attributes: analytics_attrs.to_h,
-          outputs: {
-            id: "${aws_kinesisanalyticsv2_application.#{name}.id}",
-            name: "${aws_kinesisanalyticsv2_application.#{name}.name}",
-            arn: "${aws_kinesisanalyticsv2_application.#{name}.arn}",
-            version_id: "${aws_kinesisanalyticsv2_application.#{name}.version_id}",
-            status: "${aws_kinesisanalyticsv2_application.#{name}.status}",
-            create_timestamp: "${aws_kinesisanalyticsv2_application.#{name}.create_timestamp}",
-            last_update_timestamp: "${aws_kinesisanalyticsv2_application.#{name}.last_update_timestamp}",
-            tags_all: "${aws_kinesisanalyticsv2_application.#{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_analytics_application/types.rb

@@ -1,319 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-require 'dry-struct'
-require 'pangea/resources/types'
-
-module Pangea
-  module Resources
-    module AWS
-      module Types
-        # Kinesis Analytics Application resource attributes with validation
-        class KinesisAnalyticsApplicationAttributes < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          attribute :name, String
-          attribute :description, String.optional
-          
-          # Application configuration
-          attribute :application_configuration, Hash.schema(
-            application_code_configuration?: Hash.schema(
-              code_content: Hash.schema(
-                text_content?: String.optional,
-                zip_file_content?: String.optional,
-                s3_content_location?: Hash.schema(
-                  bucket_arn: String,
-                  file_key: String,
-                  object_version?: String.optional
-                ).optional
-              ),
-              code_content_type: String.enum('PLAINTEXT', 'ZIPFILE')
-            ).optional,
-            
-            flink_application_configuration?: Hash.schema(
-              checkpoint_configuration?: Hash.schema(
-                configuration_type: String.enum('DEFAULT', 'CUSTOM'),
-                checkpointing_enabled?: Bool.optional,
-                checkpoint_interval?: Integer.constrained(gteq: 1000, lteq: 300000).optional,
-                min_pause_between_checkpoints?: Integer.constrained(gteq: 0, lteq: 300000).optional
-              ).optional,
-              monitoring_configuration?: Hash.schema(
-                configuration_type: String.enum('DEFAULT', 'CUSTOM'),
-                log_level?: String.enum('INFO', 'WARN', 'ERROR', 'DEBUG').optional,
-                metrics_level?: String.enum('APPLICATION', 'TASK', 'OPERATOR', 'PARALLELISM').optional
-              ).optional,
-              parallelism_configuration?: Hash.schema(
-                configuration_type: String.enum('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
-              ).optional
-            ).optional,
-            
-            sql_application_configuration?: Hash.schema(
-              inputs?: Array.of(Hash.schema(
-                name_prefix: String.constrained(min_size: 1, max_size: 32),
-                input_parallelism?: Hash.schema(
-                  count?: Integer.constrained(gteq: 1, lteq: 64).optional
-                ).optional,
-                input_schema: Hash.schema(
-                  record_columns: Array.of(Hash.schema(
-                    name: String.constrained(min_size: 1, max_size: 256),
-                    sql_type: String.enum(
-                      'BOOLEAN', 'INTEGER', 'BIGINT', 'DOUBLE', 'DECIMAL', 
-                      'VARCHAR', 'CHAR', 'TIMESTAMP', 'DATE', 'TIME'
-                    ),
-                    mapping?: String.optional
-                  )).constrained(min_size: 1, max_size: 1000),
-                  record_format: Hash.schema(
-                    record_format_type: String.enum('JSON', 'CSV'),
-                    mapping_parameters?: Hash.schema(
-                      json_mapping_parameters?: Hash.schema(
-                        record_row_path: String
-                      ).optional,
-                      csv_mapping_parameters?: Hash.schema(
-                        record_row_delimiter: String.constrained(min_size: 1, max_size: 1024),
-                        record_column_delimiter: String.constrained(min_size: 1, max_size: 1024)
-                      ).optional
-                    ).optional
-                  ),
-                  record_encoding?: String.enum('UTF-8').optional
-                ),
-                kinesis_streams_input?: Hash.schema(
-                  resource_arn: String
-                ).optional,
-                kinesis_firehose_input?: Hash.schema(
-                  resource_arn: String
-                ).optional
-              )).optional,
-              outputs?: Array.of(Hash.schema(
-                name: String.constrained(min_size: 1, max_size: 32),
-                destination_schema: Hash.schema(
-                  record_format_type: String.enum('JSON', 'CSV')
-                ),
-                kinesis_streams_output?: Hash.schema(
-                  resource_arn: String
-                ).optional,
-                kinesis_firehose_output?: Hash.schema(
-                  resource_arn: String
-                ).optional,
-                lambda_output?: Hash.schema(
-                  resource_arn: String
-                ).optional
-              )).optional,
-              reference_data_sources?: Array.of(Hash.schema(
-                table_name: String.constrained(min_size: 1, max_size: 32),
-                reference_schema: Hash.schema(
-                  record_columns: Array.of(Hash.schema(
-                    name: String,
-                    sql_type: String,
-                    mapping?: String.optional
-                  )),
-                  record_format: Hash.schema(
-                    record_format_type: String.enum('JSON', 'CSV'),
-                    mapping_parameters?: Hash.optional
-                  ),
-                  record_encoding?: String.enum('UTF-8').optional
-                ),
-                s3_reference_data_source?: Hash.schema(
-                  bucket_arn: String,
-                  file_key: String
-                ).optional
-              )).optional
-            ).optional,
-            
-            environment_properties?: 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)
-                )
-              ))
-            ).optional,
-            
-            vpc_configuration?: 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)
-            ).optional
-          ).optional
-          
-          attribute :service_execution_role, String
-          attribute :runtime_environment, String.enum('SQL-1_0', 'FLINK-1_6', 'FLINK-1_8', 'FLINK-1_11', 'FLINK-1_13', 'FLINK-1_15', 'FLINK-1_18')
-          attribute :start_application, Bool.default(false)
-          attribute :tags, Resources::Types::AwsTags
-          
-          # Custom validation
-          def self.new(attributes)
-            attrs = attributes.is_a?(Hash) ? attributes : {}
-            
-            # Validate service execution role ARN
-            if attrs[:service_execution_role] && !valid_iam_role_arn?(attrs[:service_execution_role])
-              raise Dry::Struct::Error, "Invalid service execution role ARN: #{attrs[:service_execution_role]}"
-            end
-            
-            # Validate runtime environment vs configuration compatibility
-            runtime = attrs[:runtime_environment]
-            app_config = attrs[:application_configuration]
-            
-            if 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
-              
-              if runtime.start_with?('FLINK') && !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
-            end
-            
-            # Validate code content configuration
-            if app_config&.dig(:application_code_configuration)
-              code_config = app_config[:application_code_configuration]
-              content = code_config[:code_content]
-              content_type = code_config[:code_content_type]
-              
-              case content_type
-              when 'PLAINTEXT'
-                unless content[:text_content]
-                  raise Dry::Struct::Error, "PLAINTEXT code content type requires text_content"
-                end
-              when 'ZIPFILE'
-                unless 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
-            end
-            
-            # Validate SQL application inputs/outputs
-            if app_config&.dig(:sql_application_configuration)
-              sql_config = app_config[:sql_application_configuration]
-              
-              # Validate inputs have either Kinesis Streams or Kinesis Firehose
-              if sql_config[:inputs]
-                sql_config[:inputs].each do |input|
-                  unless 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
-              end
-              
-              # Validate outputs have a destination
-              if sql_config[:outputs]
-                sql_config[:outputs].each do |output|
-                  unless 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
-            
-            super(attrs)
-          end
-          
-          # Validation helpers
-          def self.valid_iam_role_arn?(arn)
-            arn.match?(/\Aarn:aws:iam::\d{12}:role\/[a-zA-Z0-9_\+\=\,\.\@\-]+\z/)
-          end
-          
-          # Computed properties
-          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?
-              # SQL applications typically use 1 KPU minimum
-              base_kpu = 1
-              # Add KPU for inputs and outputs
-              additional_kpu = (input_count + output_count) * 0.1
-              (base_kpu + additional_kpu).ceil
-            elsif is_flink_application?
-              # Flink applications based on parallelism
-              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
-            else
-              1
-            end
-          end
-          
-          def estimated_monthly_cost_usd
-            kpu_usage = estimated_kpu_usage
-            hours_per_month = 24 * 30 # 30 days
-            cost_per_kpu_hour = 0.11 # $0.11 per KPU-hour
-            
-            monthly_cost = kpu_usage * hours_per_month * cost_per_kpu_hour
-            monthly_cost.round(2)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# 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