pangea-aws 0.1.0

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

@@ -0,0 +1,21 @@
+# 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'
+require 'json'
+require_relative 'types/parameters'
+require_relative 'types/attributes'
+require_relative 'types/configs'

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

@@ -0,0 +1,58 @@
+# RBS type definitions for AWS EventBridge Target types
+
+module Pangea
+  module Resources
+    module AWS
+      class EventBridgeTargetAttributes < Dry::Struct
+        attr_reader rule: String
+        attr_reader event_bus_name: String
+        attr_reader target_id: String
+        attr_reader arn: String
+        attr_reader role_arn: String?
+        attr_reader input: String?
+        attr_reader input_path: String?
+        attr_reader input_transformer: Hash[Symbol, untyped]?
+        attr_reader retry_policy: Hash[Symbol, untyped]?
+        attr_reader dead_letter_config: Hash[Symbol, untyped]?
+        attr_reader http_parameters: Hash[Symbol, untyped]?
+        attr_reader kinesis_parameters: Hash[Symbol, untyped]?
+        attr_reader sqs_parameters: Hash[Symbol, untyped]?
+        attr_reader ecs_parameters: Hash[Symbol, untyped]?
+        attr_reader batch_parameters: Hash[Symbol, untyped]?
+        
+        def target_type: () -> String
+        def is_lambda_target?: () -> bool
+        def is_sqs_target?: () -> bool
+        def is_sns_target?: () -> bool
+        def is_kinesis_target?: () -> bool
+        def is_ecs_target?: () -> bool
+        def is_batch_target?: () -> bool
+        def is_api_gateway_target?: () -> bool
+        def is_fifo_sqs?: () -> bool
+        def has_role?: () -> bool
+        def has_input_transformation?: () -> bool
+        def has_retry_policy?: () -> bool
+        def has_dead_letter_queue?: () -> bool
+        def uses_default_bus?: () -> bool
+        def uses_custom_bus?: () -> bool
+        def max_retry_attempts: () -> Integer
+        def max_event_age_hours: () -> Float?
+        def estimated_monthly_cost: () -> String
+        def target_service: () -> String
+        def reliability_features: () -> String
+      end
+
+      module EventBridgeTargetConfigs
+        def self.lambda_target: (rule: String, target_id: String, function_arn: String, ?input: String?) -> Hash[Symbol, untyped]
+        def self.sqs_target: (rule: String, target_id: String, queue_arn: String, ?message_group_id: String?) -> Hash[Symbol, untyped]
+        def self.sns_target: (rule: String, target_id: String, topic_arn: String, ?role_arn: String?) -> Hash[Symbol, untyped]
+        def self.kinesis_target: (rule: String, target_id: String, stream_arn: String, role_arn: String, ?partition_key_path: String?) -> Hash[Symbol, untyped]
+        def self.ecs_target: (rule: String, target_id: String, task_definition_arn: String, role_arn: String, ?cluster_arn: String?, ?launch_type: String, ?task_count: Integer, ?subnets: Array[String], ?security_groups: Array[String]) -> Hash[Symbol, untyped]
+        def self.reliable_target: (rule: String, target_id: String, arn: String, ?role_arn: String?, ?max_retry_attempts: Integer, ?max_event_age_hours: Integer) -> Hash[Symbol, untyped]
+        def self.target_with_dlq: (rule: String, target_id: String, arn: String, dlq_arn: String, ?role_arn: String?) -> Hash[Symbol, untyped]
+        def self.transformed_target: (rule: String, target_id: String, arn: String, input_template: String, ?input_paths: Hash[String, String]?, ?role_arn: String?) -> Hash[Symbol, untyped]
+        def self.batch_target: (rule: String, target_id: String, job_queue_arn: String, job_definition: String, job_name: String, role_arn: String, ?array_size: Integer?) -> Hash[Symbol, untyped]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# 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_relative 'types'
+
+module Pangea
+  module Resources
+    module AWS
+      # Creates a fully managed, high-performance FSx for Lustre file system
+      #
+      # @param name [Symbol] The unique name for this resource instance
+      # @param attributes [Hash] FSx Lustre file system configuration
+      # @return [ResourceReference] Reference object with FSx Lustre outputs
+      #
+      # @example Basic SCRATCH deployment for HPC workloads
+      #   fsx = aws_fsx_lustre_filesystem(:hpc_storage, {
+      #     storage_capacity: 1200,
+      #     subnet_ids: [subnet_ref.id],
+      #     deployment_type: "SCRATCH_2"
+      #   })
+      #
+      # @example PERSISTENT deployment with S3 integration
+      #   fsx = aws_fsx_lustre_filesystem(:ml_training, {
+      #     storage_capacity: 9600,
+      #     subnet_ids: [subnet_ref.id],
+      #     deployment_type: "PERSISTENT_1",
+      #     storage_type: "SSD",
+      #     per_unit_storage_throughput: 200,
+      #     import_path: "s3://my-bucket/training-data",
+      #     export_path: "s3://my-bucket/training-output",
+      #     auto_import_policy: "NEW_CHANGED"
+      #   })
+      #
+      # @example High-capacity HDD storage with backups
+      #   fsx = aws_fsx_lustre_filesystem(:archive_storage, {
+      #     storage_capacity: 12000,
+      #     subnet_ids: [subnet_ref.id],
+      #     deployment_type: "PERSISTENT_1",
+      #     storage_type: "HDD",
+      #     per_unit_storage_throughput: 40,
+      #     automatic_backup_retention_days: 7,
+      #     drive_cache_type: "READ"
+      #   })
+      def aws_fsx_lustre_filesystem(name, attributes = {})
+        # Validate and transform attributes
+        fsx_attrs = Types::FsxLustreFileSystemAttributes.new(attributes)
+        
+        # Create FSx Lustre resource
+        resource(:aws_fsx_lustre_file_system, name) do
+          # Storage configuration
+          storage_capacity fsx_attrs.storage_capacity
+          storage_type fsx_attrs.storage_type
+          deployment_type fsx_attrs.deployment_type
+          
+          # Network configuration
+          subnet_ids fsx_attrs.subnet_ids
+          security_group_ids fsx_attrs.security_group_ids if fsx_attrs.security_group_ids
+          
+          # S3 data repository configuration
+          import_path fsx_attrs.import_path if fsx_attrs.import_path
+          export_path fsx_attrs.export_path if fsx_attrs.export_path
+          auto_import_policy fsx_attrs.auto_import_policy if fsx_attrs.auto_import_policy
+          imported_file_chunk_size fsx_attrs.imported_file_chunk_size if fsx_attrs.imported_file_chunk_size
+          
+          # Performance configuration for PERSISTENT
+          if fsx_attrs.is_persistent? && fsx_attrs.per_unit_storage_throughput
+            per_unit_storage_throughput fsx_attrs.per_unit_storage_throughput
+          end
+          
+          # Backup configuration for PERSISTENT
+          if fsx_attrs.is_persistent?
+            automatic_backup_retention_days fsx_attrs.automatic_backup_retention_days if fsx_attrs.automatic_backup_retention_days
+            daily_automatic_backup_start_time fsx_attrs.daily_automatic_backup_start_time if fsx_attrs.daily_automatic_backup_start_time
+            copy_tags_to_backups fsx_attrs.copy_tags_to_backups if !fsx_attrs.copy_tags_to_backups.nil?
+          end
+          
+          # Additional configurations
+          data_compression_type fsx_attrs.data_compression_type if fsx_attrs.data_compression_type != "NONE"
+          drive_cache_type fsx_attrs.drive_cache_type if fsx_attrs.drive_cache_type && fsx_attrs.storage_type == "HDD"
+          kms_key_id fsx_attrs.kms_key_id if fsx_attrs.kms_key_id
+          file_system_type_version fsx_attrs.file_system_type_version
+          weekly_maintenance_start_time fsx_attrs.weekly_maintenance_start_time if fsx_attrs.weekly_maintenance_start_time
+          
+          # Tags
+          if fsx_attrs.tags&.any?
+            tags do
+              fsx_attrs.tags.each { |key, value| public_send(key, value) }
+            end
+          end
+        end
+        
+        # Return reference with FSx Lustre-specific outputs
+        ref = ResourceReference.new(
+          type: 'aws_fsx_lustre_file_system',
+          name: name,
+          resource_attributes: fsx_attrs.to_h,
+          outputs: {
+            # Core identifiers
+            id: "${aws_fsx_lustre_file_system.#{name}.id}",
+            arn: "${aws_fsx_lustre_file_system.#{name}.arn}",
+            dns_name: "${aws_fsx_lustre_file_system.#{name}.dns_name}",
+            
+            # Mount information
+            mount_name: "${aws_fsx_lustre_file_system.#{name}.mount_name}",
+            network_interface_ids: "${aws_fsx_lustre_file_system.#{name}.network_interface_ids}",
+            
+            # Resource details
+            owner_id: "${aws_fsx_lustre_file_system.#{name}.owner_id}",
+            vpc_id: "${aws_fsx_lustre_file_system.#{name}.vpc_id}",
+            weekly_maintenance_start_time: "${aws_fsx_lustre_file_system.#{name}.weekly_maintenance_start_time}",
+            
+            # Configuration outputs
+            deployment_type: fsx_attrs.deployment_type,
+            storage_type: fsx_attrs.storage_type,
+            storage_capacity: fsx_attrs.storage_capacity,
+            per_unit_storage_throughput: fsx_attrs.per_unit_storage_throughput
+          }
+        )
+        
+        # Add computed properties via method delegation
+        ref.define_singleton_method(:is_persistent?) { fsx_attrs.is_persistent? }
+        ref.define_singleton_method(:is_scratch?) { fsx_attrs.is_scratch? }
+        ref.define_singleton_method(:supports_backups?) { fsx_attrs.supports_backups? }
+        ref.define_singleton_method(:supports_throughput_configuration?) { fsx_attrs.supports_throughput_configuration? }
+        ref.define_singleton_method(:supports_drive_cache?) { fsx_attrs.supports_drive_cache? }
+        ref.define_singleton_method(:estimated_baseline_throughput) { fsx_attrs.estimated_baseline_throughput }
+        ref.define_singleton_method(:estimated_monthly_cost) { fsx_attrs.estimated_monthly_cost }
+        
+        ref
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_fsx_lustre_filesystem/types/helpers.rb

@@ -0,0 +1,101 @@
+# 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
+        # Helper methods for FSx Lustre filesystem attributes
+        module FsxLustreHelpers
+          def is_persistent?
+            deployment_type.start_with?('PERSISTENT')
+          end
+
+          def is_scratch?
+            deployment_type.start_with?('SCRATCH')
+          end
+
+          def supports_backups?
+            is_persistent?
+          end
+
+          def supports_throughput_configuration?
+            is_persistent?
+          end
+
+          def supports_drive_cache?
+            storage_type == 'HDD'
+          end
+
+          def estimated_baseline_throughput
+            case deployment_type
+            when 'SCRATCH_1'
+              200 * (storage_capacity / 1200)
+            when 'SCRATCH_2'
+              240 * (storage_capacity / 1200)
+            when 'PERSISTENT_1', 'PERSISTENT_2'
+              calculate_persistent_throughput
+            end
+          end
+
+          def estimated_monthly_cost
+            storage_cost = calculate_storage_cost
+            throughput_cost = calculate_throughput_cost
+            { storage: storage_cost.round(2), throughput: throughput_cost.round(2), total: (storage_cost + throughput_cost).round(2) }
+          end
+
+          private
+
+          def calculate_persistent_throughput
+            if per_unit_storage_throughput
+              (per_unit_storage_throughput * storage_capacity) / 1024
+            elsif storage_type == 'SSD'
+              50 * (storage_capacity / 1024)
+            else
+              12 * (storage_capacity / 1024)
+            end
+          end
+
+          def calculate_storage_cost
+            case [storage_type, deployment_type]
+            when ['SSD', 'SCRATCH_2']
+              storage_capacity * 0.140
+            when ['HDD', 'PERSISTENT_1'], ['HDD', 'PERSISTENT_2']
+              storage_capacity * 0.015
+            when ['SSD', 'PERSISTENT_1'], ['SSD', 'PERSISTENT_2']
+              storage_capacity * 0.145
+            else
+              storage_capacity * 0.140
+            end
+          end
+
+          def calculate_throughput_cost
+            return 0 unless is_persistent? && per_unit_storage_throughput && storage_type == 'SSD'
+
+            throughput_multiplier = case per_unit_storage_throughput
+                                    when 50 then 0
+                                    when 100 then 0.035
+                                    when 200 then 0.070
+                                    when 500 then 0.175
+                                    when 1000 then 0.350
+                                    else 0
+                                    end
+            (storage_capacity / 1024.0) * throughput_multiplier * 730
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# 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'
+require_relative 'types/helpers'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # FSx Lustre file system resource attributes with validation
+        class FsxLustreFileSystemAttributes < Pangea::Resources::BaseAttributes
+          include FsxLustreHelpers
+          transform_keys(&:to_sym)
+
+          attribute? :import_path, Resources::Types::String.optional
+          attribute? :export_path, Resources::Types::String.optional
+          attribute? :storage_capacity, Resources::Types::Integer.optional
+          attribute :subnet_ids, Resources::Types::Array.of(Resources::Types::String).default([].freeze)
+          attribute? :security_group_ids, Resources::Types::Array.of(Resources::Types::String).optional
+          attribute :storage_type, Resources::Types::String.default('SSD').constrained(included_in: %w[SSD HDD])
+          attribute? :per_unit_storage_throughput, Resources::Types::Integer.optional
+          attribute :deployment_type, Resources::Types::String.default('SCRATCH_2').constrained(included_in: %w[SCRATCH_1 SCRATCH_2 PERSISTENT_1 PERSISTENT_2])
+          attribute? :auto_import_policy, Resources::Types::String.optional.constrained(included_in: %w[NONE NEW NEW_CHANGED NEW_CHANGED_DELETED])
+          attribute? :imported_file_chunk_size, Resources::Types::Integer.optional
+          attribute? :weekly_maintenance_start_time, Resources::Types::String.optional
+          attribute? :automatic_backup_retention_days, Resources::Types::Integer.optional
+          attribute? :daily_automatic_backup_start_time, Resources::Types::String.optional
+          attribute? :copy_tags_to_backups, Resources::Types::Bool.default(false)
+          attribute? :data_compression_type, Resources::Types::String.default('NONE').constrained(included_in: %w[NONE LZ4])
+          attribute? :drive_cache_type, Resources::Types::String.optional.constrained(included_in: %w[NONE READ])
+          attribute? :kms_key_id, Resources::Types::String.optional
+          attribute? :file_system_type_version, Resources::Types::String.default('2.15')
+          attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            instance = super(attrs)
+            validate_storage_capacity(instance)
+            validate_throughput(instance)
+            validate_scratch_constraints(instance)
+            validate_hdd_constraints(instance)
+            validate_backup_retention(instance)
+            validate_chunk_size(instance)
+            instance
+          end
+
+          def self.validate_storage_capacity(instance)
+            if instance.storage_type == 'SSD'
+              valid = [1200, 2400, 4800, 9600, 19200, 28800, 38400, 57600, 76800, 96000, 115200]
+              raise Dry::Struct::Error, "For SSD storage, capacity must be one of: #{valid.join(', ')} GB" unless valid.include?(instance.storage_capacity)
+            elsif instance.storage_type == 'HDD'
+              if instance.storage_capacity < 6000 || instance.storage_capacity % 6000 != 0
+                raise Dry::Struct::Error, 'For HDD storage, capacity must be a multiple of 6000 GB (minimum 6000 GB)'
+              end
+            end
+          end
+
+          def self.validate_throughput(instance)
+            return unless instance.deployment_type.start_with?('PERSISTENT') && instance.per_unit_storage_throughput
+
+            if instance.storage_type == 'SSD'
+              valid = [50, 100, 200, 500, 1000]
+              raise Dry::Struct::Error, "For PERSISTENT SSD, throughput must be one of: #{valid.join(', ')} MB/s/TiB" unless valid.include?(instance.per_unit_storage_throughput)
+            elsif instance.storage_type == 'HDD'
+              valid = [12, 40]
+              raise Dry::Struct::Error, "For PERSISTENT HDD, throughput must be one of: #{valid.join(', ')} MB/s/TiB" unless valid.include?(instance.per_unit_storage_throughput)
+            end
+          end
+
+          def self.validate_scratch_constraints(instance)
+            return unless instance.deployment_type.start_with?('SCRATCH')
+
+            raise Dry::Struct::Error, 'per_unit_storage_throughput cannot be specified for SCRATCH deployment types' if instance.per_unit_storage_throughput
+            raise Dry::Struct::Error, 'automatic_backup_retention_days cannot be set for SCRATCH deployment types' if instance.automatic_backup_retention_days
+            raise Dry::Struct::Error, 'daily_automatic_backup_start_time cannot be set for SCRATCH deployment types' if instance.daily_automatic_backup_start_time
+          end
+
+          def self.validate_hdd_constraints(instance)
+            return unless instance.drive_cache_type && instance.storage_type != 'HDD'
+
+            raise Dry::Struct::Error, 'drive_cache_type can only be specified for HDD storage type'
+          end
+
+          def self.validate_backup_retention(instance)
+            return unless instance.automatic_backup_retention_days
+
+            days = instance.automatic_backup_retention_days
+            raise Dry::Struct::Error, 'automatic_backup_retention_days must be between 0 and 90' if days < 0 || days > 90
+          end
+
+          def self.validate_chunk_size(instance)
+            return unless instance.imported_file_chunk_size
+
+            chunk = instance.imported_file_chunk_size
+            raise Dry::Struct::Error, 'imported_file_chunk_size must be between 1 and 512000 MB' if chunk < 1 || chunk > 512_000
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# 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 "types"
+
+module Pangea
+  module Resources
+    module AwsGameliftAlias
+      # Resource-specific methods for AWS GameLift Alias
+      module Resource
+        def self.validate(definition)
+          Types::Attributes.from_dynamic(definition)
+        end
+
+        def self.defaults
+          {}
+        end
+
+        def self.required_attributes
+          %i[name description routing_strategy]
+        end
+
+        def self.compute_attributes(definition)
+          attrs = {
+            id: ref(definition[:name], :id),
+            arn: ref(definition[:name], :arn),
+            creation_time: ref(definition[:name], :creation_time),
+            last_updated_time: ref(definition[:name], :last_updated_time)
+          }
+
+          Types::Reference.new(attrs)
+        end
+
+        private
+
+        def self.ref(name, attribute)
+          "${aws_gamelift_alias.#{name}.#{attribute}}"
+        end
+      end
+
+      # Public resource function
+      def aws_gamelift_alias(name, attributes = {})
+        # Apply defaults
+        attributes = Resource.defaults.merge(attributes)
+        
+        # Validate and create resource
+        validated = Resource.validate(attributes)
+        
+        # Create terraform resource
+        resource :aws_gamelift_alias, name do
+          # Add attributes
+          validated.to_h.each do |key, value|
+            send(key, value) unless value.nil?
+          end
+        end
+        
+        # Return computed attributes as reference
+        Resource.compute_attributes(validated.to_h.merge(name: name))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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 AwsGameliftAlias
+      module Types
+        # Routing strategy for the alias
+        class RoutingStrategy < Pangea::Resources::BaseAttributes
+          attribute? :type, Pangea::Resources::Types::String.constrained(included_in: ["SIMPLE", "TERMINAL"]).optional
+          attribute :fleet_id?, Pangea::Resources::Types::String
+          attribute :message?, Pangea::Resources::Types::String
+
+          def self.from_dynamic(d)
+            d = Pangea::Resources::Types::Hash[d]
+            
+            # Validate based on type
+            case d[:type]
+            when "SIMPLE"
+              unless d[:fleet_id]
+                raise ArgumentError, "fleet_id is required when routing_strategy type is SIMPLE"
+              end
+            when "TERMINAL"
+              unless d[:message]
+                raise ArgumentError, "message is required when routing_strategy type is TERMINAL"
+              end
+            end
+
+            new(
+              type: d.fetch(:type),
+              fleet_id: d[:fleet_id],
+              message: d[:message]
+            )
+          end
+        end
+
+        # Main attributes for GameLift alias
+
+        # Reference for GameLift alias resources
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require_relative "types"
+
+module Pangea
+  module Resources
+    module AwsGameliftBuild
+      # Resource-specific methods for AWS GameLift Build
+      module Resource
+        def self.validate(definition)
+          # Validate storage location
+          storage = definition[:storage_location]
+          if storage
+            unless storage[:bucket] && storage[:key] && storage[:role_arn]
+              raise ArgumentError, "storage_location must include bucket, key, and role_arn"
+            end
+          end
+
+          Types::Attributes.from_dynamic(definition)
+        end
+
+        def self.defaults
+          {
+            operating_system: "AMAZON_LINUX_2"
+          }
+        end
+
+        def self.required_attributes
+          %i[name operating_system storage_location]
+        end
+
+        def self.compute_attributes(definition)
+          attrs = {
+            id: ref(definition[:name], :id),
+            arn: ref(definition[:name], :arn),
+            creation_time: ref(definition[:name], :creation_time),
+            size_on_disk: ref(definition[:name], :size_on_disk),
+            status: ref(definition[:name], :status)
+          }
+
+          Types::Reference.new(attrs)
+        end
+
+        private
+
+        def self.ref(name, attribute)
+          "${aws_gamelift_build.#{name}.#{attribute}}"
+        end
+      end
+
+      # Public resource function
+      def aws_gamelift_build(name, attributes = {})
+        # Apply defaults
+        attributes = Resource.defaults.merge(attributes)
+        
+        # Validate and create resource
+        validated = Resource.validate(attributes)
+        
+        # Create terraform resource
+        resource :aws_gamelift_build, name do
+          # Add attributes
+          validated.to_h.each do |key, value|
+            send(key, value) unless value.nil?
+          end
+        end
+        
+        # Return computed attributes as reference
+        Resource.compute_attributes(validated.to_h.merge(name: name))
+      end
+    end
+  end
+end