pangea-aws 0.1.0

data/lib/pangea/resources/aws_media_live_channel/resource/dsl_builder/input_attachments.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 MediaLiveChannel
+        class DSLBuilder
+          # Input attachment DSL building for MediaLive Channel
+          module InputAttachments
+            def build_input_attachments(ctx)
+              attrs.input_attachments.each do |input_attachment|
+                ctx.input_attachments do
+                  input_attachment_name input_attachment[:input_attachment_name]
+                  input_id input_attachment[:input_id]
+                  build_input_settings(self, input_attachment[:input_settings]) if input_attachment[:input_settings]
+                end
+              end
+            end
+
+            private
+
+            def build_input_settings(ctx, settings)
+              ctx.input_settings do
+                build_audio_selectors(self, settings[:audio_selectors]) if settings[:audio_selectors]
+                build_caption_selectors(self, settings[:caption_selectors]) if settings[:caption_selectors]
+                apply_filter_settings(self, settings)
+                build_network_input_settings(self, settings[:network_input_settings]) if settings[:network_input_settings]
+                smpte2038_data_preference settings[:smpte2038_data_preference] if settings[:smpte2038_data_preference]
+                source_end_behavior settings[:source_end_behavior] if settings[:source_end_behavior]
+                build_video_selector(self, settings[:video_selector]) if settings[:video_selector]
+              end
+            end
+
+            def apply_filter_settings(ctx, settings)
+              ctx.deblock_filter settings[:deblock_filter] if settings[:deblock_filter]
+              ctx.denoise_filter settings[:denoise_filter] if settings[:denoise_filter]
+              ctx.filter_strength settings[:filter_strength] if settings[:filter_strength]
+              ctx.input_filter settings[:input_filter] if settings[:input_filter]
+            end
+
+            def build_audio_selectors(ctx, audio_selectors)
+              audio_selectors.each do |audio_selector|
+                ctx.audio_selectors do
+                  name audio_selector[:name]
+                  build_audio_selector_settings(self, audio_selector[:selector_settings]) if audio_selector[:selector_settings]
+                end
+              end
+            end
+
+            def build_audio_selector_settings(ctx, settings)
+              ctx.selector_settings do
+                if settings[:audio_language_selection]
+                  audio_language_selection do
+                    language_code settings[:audio_language_selection][:language_code]
+                    language_selection_policy settings[:audio_language_selection][:language_selection_policy] if settings[:audio_language_selection][:language_selection_policy]
+                  end
+                end
+
+                if settings[:audio_pid_selection]
+                  audio_pid_selection do
+                    pid settings[:audio_pid_selection][:pid]
+                  end
+                end
+              end
+            end
+
+            def build_caption_selectors(ctx, caption_selectors)
+              caption_selectors.each do |caption_selector|
+                ctx.caption_selectors do
+                  name caption_selector[:name]
+                  language_code caption_selector[:language_code] if caption_selector[:language_code]
+                  selector_settings {} if caption_selector[:selector_settings]
+                end
+              end
+            end
+
+            def build_network_input_settings(ctx, network_settings)
+              ctx.network_input_settings do
+                if network_settings[:hls_input_settings]
+                  hls_input_settings do
+                    bandwidth network_settings[:hls_input_settings][:bandwidth] if network_settings[:hls_input_settings][:bandwidth]
+                    buffer_segments network_settings[:hls_input_settings][:buffer_segments] if network_settings[:hls_input_settings][:buffer_segments]
+                    retries network_settings[:hls_input_settings][:retries] if network_settings[:hls_input_settings][:retries]
+                    retry_interval network_settings[:hls_input_settings][:retry_interval] if network_settings[:hls_input_settings][:retry_interval]
+                  end
+                end
+                server_validation network_settings[:server_validation] if network_settings[:server_validation]
+              end
+            end
+
+            def build_video_selector(ctx, video_selector)
+              ctx.video_selector do
+                color_space video_selector[:color_space] if video_selector[:color_space]
+                color_space_usage video_selector[:color_space_usage] if video_selector[:color_space_usage]
+
+                if video_selector[:selector_settings]
+                  selector_settings do
+                    if video_selector[:selector_settings][:video_selector_pid]
+                      video_selector_pid do
+                        pid video_selector[:selector_settings][:video_selector_pid][:pid]
+                      end
+                    end
+                    if video_selector[:selector_settings][:video_selector_program_id]
+                      video_selector_program_id do
+                        program_id video_selector[:selector_settings][:video_selector_program_id][:program_id]
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_media_live_channel/resource/dsl_builder.rb

@@ -0,0 +1,42 @@
+# 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 'dsl_builder/input_attachments'
+require_relative 'dsl_builder/encoder_settings'
+require_relative 'dsl_builder/destinations'
+require_relative 'dsl_builder/configurations'
+
+module Pangea
+  module Resources
+    module AWS
+      module MediaLiveChannel
+        # DSL builder for MediaLive Channel terraform blocks
+        class DSLBuilder
+          include InputAttachments
+          include EncoderSettings
+          include Destinations
+          include Configurations
+
+          attr_reader :attrs
+
+          def initialize(channel_attrs)
+            @attrs = channel_attrs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_media_live_channel/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 'pangea/resources/base'
+require 'pangea/resources/reference'
+require 'pangea/resources/aws_media_live_channel/types'
+require 'pangea/resource_registry'
+
+require_relative 'resource/dsl_builder'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS MediaLive Channel with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] MediaLive channel attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_media_live_channel(name, attributes = {})
+        channel_attrs = Types::MediaLiveChannelAttributes.new(attributes)
+        builder = MediaLiveChannel::DSLBuilder.new(channel_attrs)
+
+        resource(:aws_medialive_channel, name) do
+          name channel_attrs.name
+          channel_class channel_attrs.channel_class
+
+          builder.build_input_attachments(self)
+
+          encoder_settings do
+            builder.build_encoder_settings(self)
+          end
+
+          builder.build_destinations(self)
+          builder.build_input_specification(self)
+
+          log_level channel_attrs.log_level
+
+          builder.build_maintenance(self)
+          builder.build_reserved_instances(self)
+
+          role_arn channel_attrs.role_arn
+
+          builder.build_vpc(self)
+          builder.build_tags(self)
+        end
+
+        ResourceReference.new(
+          type: 'aws_medialive_channel',
+          name: name,
+          resource_attributes: channel_attrs.to_h,
+          outputs: {
+            arn: "${aws_medialive_channel.#{name}.arn}",
+            channel_id: "${aws_medialive_channel.#{name}.channel_id}",
+            id: "${aws_medialive_channel.#{name}.id}"
+          },
+          computed: {
+            single_pipeline: channel_attrs.single_pipeline?,
+            standard_channel: channel_attrs.standard_channel?,
+            has_redundancy: channel_attrs.has_redundancy?,
+            input_count: channel_attrs.input_count,
+            output_group_count: channel_attrs.output_group_count,
+            destination_count: channel_attrs.destination_count,
+            has_vpc_config: channel_attrs.has_vpc_config?,
+            maintenance_scheduled: channel_attrs.maintenance_scheduled?,
+            schedule_actions_count: channel_attrs.schedule_actions_count,
+            supports_hdr: channel_attrs.supports_hdr?,
+            maximum_resolution: channel_attrs.maximum_resolution
+          }
+        )
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_media_live_channel/types/audio_codec_settings.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module MediaLiveChannel
+            T = Resources::Types
+
+          # Audio codec and description type definitions
+
+          module AudioCodecSettings
+            T = Resources::Types
+
+            # AAC codec settings
+            AacSettings = T::Hash.schema(
+              bitrate?: T::Float.optional,
+              coding_mode?: T::String.constrained(included_in: ['AD_RECEIVER_MIX', 'CODING_MODE_1_0', 'CODING_MODE_1_1', 'CODING_MODE_2_0', 'CODING_MODE_5_1']).optional,
+              input_type?: T::String.constrained(included_in: ['BROADCASTER_MIXED_AD', 'NORMAL']).optional,
+              profile?: T::String.constrained(included_in: ['HEV1', 'HEV2', 'LC']).optional,
+              rate_control_mode?: T::String.constrained(included_in: ['CBR', 'VBR']).optional,
+              raw_format?: T::String.constrained(included_in: ['LATM_LOAS', 'NONE']).optional,
+              sample_rate?: T::Float.optional,
+              spec?: T::String.constrained(included_in: ['MPEG2', 'MPEG4']).optional,
+              vbr_quality?: T::String.constrained(included_in: ['HIGH', 'LOW', 'MEDIUM_HIGH', 'MEDIUM_LOW']).optional
+            ).lax
+
+            # AC3 codec settings
+            Ac3Settings = T::Hash.schema(
+              bitrate?: T::Float.optional,
+              bitstream_mode?: T::String.constrained(included_in: ['COMMENTARY', 'COMPLETE_MAIN', 'DIALOGUE', 'EMERGENCY', 'HEARING_IMPAIRED', 'MUSIC_AND_EFFECTS', 'VISUALLY_IMPAIRED', 'VOICE_OVER']).optional,
+              coding_mode?: T::String.constrained(included_in: ['CODING_MODE_1_0', 'CODING_MODE_1_1', 'CODING_MODE_2_0', 'CODING_MODE_3_2_LFE']).optional,
+              dialnorm?: T::Integer.optional,
+              drc_profile?: T::String.constrained(included_in: ['FILM_STANDARD', 'NONE']).optional,
+              lfe_filter?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional,
+              metadata_control?: T::String.constrained(included_in: ['FOLLOW_INPUT', 'USE_CONFIGURED']).optional
+            ).lax
+
+            # EAC3 codec settings
+            Eac3Settings = T::Hash.schema(
+              attenuation_control?: T::String.constrained(included_in: ['ATTENUATE_3_DB', 'NONE']).optional,
+              bitrate?: T::Float.optional,
+              bitstream_mode?: T::String.constrained(included_in: ['COMMENTARY', 'COMPLETE_MAIN', 'EMERGENCY', 'HEARING_IMPAIRED', 'VISUALLY_IMPAIRED']).optional,
+              coding_mode?: T::String.constrained(included_in: ['CODING_MODE_1_0', 'CODING_MODE_2_0', 'CODING_MODE_3_2']).optional,
+              dc_filter?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional,
+              dialnorm?: T::Integer.optional,
+              drc_line?: T::String.constrained(included_in: ['FILM_LIGHT', 'FILM_STANDARD', 'MUSIC_LIGHT', 'MUSIC_STANDARD', 'NONE', 'SPEECH']).optional,
+              drc_rf?: T::String.constrained(included_in: ['FILM_LIGHT', 'FILM_STANDARD', 'MUSIC_LIGHT', 'MUSIC_STANDARD', 'NONE', 'SPEECH']).optional,
+              lfe_control?: T::String.constrained(included_in: ['LFE', 'NO_LFE']).optional,
+              lfe_filter?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional,
+              lo_ro_center_mix_level?: T::Float.optional,
+              lo_ro_surround_mix_level?: T::Float.optional,
+              lt_rt_center_mix_level?: T::Float.optional,
+              lt_rt_surround_mix_level?: T::Float.optional,
+              metadata_control?: T::String.constrained(included_in: ['FOLLOW_INPUT', 'USE_CONFIGURED']).optional,
+              passthrough_control?: T::String.constrained(included_in: ['NO_PASSTHROUGH', 'WHEN_POSSIBLE']).optional,
+              phase_control?: T::String.constrained(included_in: ['NO_SHIFT', 'SHIFT_90_DEGREES']).optional,
+              stereo_downmix?: T::String.constrained(included_in: ['DPL2', 'LO_RO', 'LT_RT', 'NOT_INDICATED']).optional,
+              surround_ex_mode?: T::String.constrained(included_in: ['DISABLED', 'ENABLED', 'NOT_INDICATED']).optional,
+              surround_mode?: T::String.constrained(included_in: ['DISABLED', 'ENABLED', 'NOT_INDICATED']).optional
+            ).lax
+
+            # Codec settings container
+            CodecSettings = T::Hash.schema(
+              aac_settings?: AacSettings.optional,
+              ac3_settings?: Ac3Settings.optional,
+              eac3_settings?: Eac3Settings.optional
+            ).lax
+
+            # Remix settings
+            ChannelMapping = T::Hash.schema(
+              input_channel_levels: T::Array.of(
+                T::Hash.schema(
+                  gain: T::Integer,
+                  input_channel: T::Integer
+                ).lax
+              ),
+              output_channel: T::Integer
+            )
+
+            RemixSettings = T::Hash.schema(
+              channel_mappings: T::Array.of(ChannelMapping),
+              channels_in?: T::Integer.optional,
+              channels_out?: T::Integer.optional
+            ).lax
+
+            # Audio description
+            AudioDescription = T::Hash.schema(
+              audio_selector_name: T::String,
+              audio_type?: T::String.constrained(included_in: ['CLEAN_EFFECTS', 'HEARING_IMPAIRED', 'UNDEFINED', 'VISUAL_IMPAIRED_COMMENTARY']).optional,
+              audio_type_control?: T::String.constrained(included_in: ['FOLLOW_INPUT', 'USE_CONFIGURED']).optional,
+              codec_settings?: CodecSettings.optional,
+              language_code?: T::String.optional,
+              language_code_control?: T::String.constrained(included_in: ['FOLLOW_INPUT', 'USE_CONFIGURED']).optional,
+              name: T::String,
+              remix_settings?: RemixSettings.optional,
+              stream_name?: T::String.optional
+            ).lax
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_media_live_channel/types/caption_settings.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'pangea/resources/types'
+require_relative 'encoder_config'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module MediaLiveChannel
+            T = Resources::Types
+
+          # Caption type definitions
+
+          module CaptionSettings
+            T = Resources::Types
+            EC = EncoderConfig
+
+            # Font settings (shared for burn-in and DVB-sub)
+            FontColorEnum = T::String.constrained(included_in: ['BLACK', 'BLUE', 'GREEN', 'RED', 'WHITE', 'YELLOW'])
+            BackgroundColorEnum = T::String.constrained(included_in: ['BLACK', 'NONE', 'WHITE'])
+            ShadowColorEnum = T::String.constrained(included_in: ['BLACK', 'NONE', 'WHITE'])
+            AlignmentEnum = T::String.constrained(included_in: ['CENTERED', 'LEFT', 'SMART'])
+
+            # Burn-in destination settings
+            BurnInDestinationSettings = T::Hash.schema(
+              alignment?: AlignmentEnum.optional,
+              background_color?: BackgroundColorEnum.optional,
+              background_opacity?: T::Integer.optional,
+              font?: EC::ImageInput.optional,
+              font_color?: FontColorEnum.optional,
+              font_opacity?: T::Integer.optional,
+              font_resolution?: T::Integer.optional,
+              font_size?: T::String.optional,
+              outline_color?: FontColorEnum.optional,
+              outline_size?: T::Integer.optional,
+              shadow_color?: ShadowColorEnum.optional,
+              shadow_opacity?: T::Integer.optional,
+              shadow_x_offset?: T::Integer.optional,
+              shadow_y_offset?: T::Integer.optional,
+              teletext_grid_control?: T::String.constrained(included_in: ['FIXED', 'SCALED']).optional,
+              x_position?: T::Integer.optional,
+              y_position?: T::Integer.optional
+            ).lax
+
+            # DVB-sub destination settings
+            DvbSubDestinationSettings = T::Hash.schema(
+              alignment?: AlignmentEnum.optional,
+              background_color?: BackgroundColorEnum.optional,
+              background_opacity?: T::Integer.optional,
+              font?: EC::ImageInput.optional,
+              font_color?: FontColorEnum.optional,
+              font_opacity?: T::Integer.optional,
+              font_resolution?: T::Integer.optional,
+              font_size?: T::String.optional,
+              outline_color?: FontColorEnum.optional,
+              outline_size?: T::Integer.optional,
+              shadow_color?: ShadowColorEnum.optional,
+              shadow_opacity?: T::Integer.optional,
+              shadow_x_offset?: T::Integer.optional,
+              shadow_y_offset?: T::Integer.optional,
+              teletext_grid_control?: T::String.constrained(included_in: ['FIXED', 'SCALED']).optional,
+              x_position?: T::Integer.optional,
+              y_position?: T::Integer.optional
+            ).lax
+
+            # EBU TT-D destination settings
+            EbuTtDDestinationSettings = T::Hash.schema(
+              copyright_holder?: T::String.optional,
+              fill_line_gap?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional,
+              font_family?: T::String.optional,
+              style_control?: T::String.constrained(included_in: ['EXCLUDE', 'INCLUDE']).optional
+            ).lax
+
+            # TTML destination settings
+            TtmlDestinationSettings = T::Hash.schema(
+              style_control?: T::String.constrained(included_in: ['PASSTHROUGH', 'USE_CONFIGURED']).optional
+            ).lax
+
+            # WebVTT destination settings
+            WebvttDestinationSettings = T::Hash.schema(
+              style_control?: T::String.constrained(included_in: ['NO_STYLE_DATA', 'PASSTHROUGH']).optional
+            ).lax
+
+            # Caption destination settings container
+            DestinationSettings = T::Hash.schema(
+              arib_destination_settings?: T::Hash.optional,
+              burn_in_destination_settings?: BurnInDestinationSettings.optional,
+              dvb_sub_destination_settings?: DvbSubDestinationSettings.optional,
+              ebu_tt_d_destination_settings?: EbuTtDDestinationSettings.optional,
+              embedded_destination_settings?: T::Hash.optional,
+              embedded_plus_scte20_destination_settings?: T::Hash.optional,
+              rtmp_caption_info_destination_settings?: T::Hash.optional,
+              scte20_plus_embedded_destination_settings?: T::Hash.optional,
+              scte27_destination_settings?: T::Hash.optional,
+              smpte_tt_destination_settings?: T::Hash.optional,
+              teletext_destination_settings?: T::Hash.optional,
+              ttml_destination_settings?: TtmlDestinationSettings.optional,
+              webvtt_destination_settings?: WebvttDestinationSettings.optional
+            ).lax
+
+            # Caption description
+            CaptionDescription = T::Hash.schema(
+              caption_selector_name: T::String,
+              destination_settings?: DestinationSettings.optional,
+              language_code?: T::String.optional,
+              language_description?: T::String.optional,
+              name: T::String
+            ).lax
+
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_media_live_channel/types/channel_config.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module MediaLiveChannel
+          # Channel configuration type definitions
+          module ChannelConfig
+            T = Resources::Types
+
+            # Destination media package settings
+            MediaPackageChannelSettings = T::Hash.schema(
+              channel_id: T::String
+            ).lax
+
+            # Destination multiplex settings
+            MultiplexSettings = T::Hash.schema(
+              multiplex_id: T::String,
+              program_name: T::String
+            ).lax
+
+            # Destination URL settings
+            UrlSettings = T::Hash.schema(
+              password_param?: T::String.optional,
+              stream_name?: T::String.optional,
+              url?: T::String.optional,
+              username?: T::String.optional
+            ).lax
+
+            # Channel destination
+            Destination = T::Hash.schema(
+              id: T::String,
+              media_package_settings?: T::Array.of(MediaPackageChannelSettings).optional,
+              multiplex_settings?: MultiplexSettings.optional,
+              settings?: T::Array.of(UrlSettings).optional
+            ).lax
+
+            # Input specification
+            InputSpecification = T::Hash.schema(
+              codec: T::String.constrained(included_in: ['MPEG2', 'AVC', 'HEVC']),
+              maximum_bitrate: T::String.constrained(included_in: ['MAX_10_MBPS', 'MAX_20_MBPS', 'MAX_50_MBPS']),
+              resolution: T::String.constrained(included_in: ['SD', 'HD', 'UHD'])
+            ).lax
+
+            # Maintenance window
+            MaintenanceWindow = T::Hash.schema(
+              maintenance_day: T::String.constrained(included_in: ['MONDAY', 'TUESDAY', 'WEDNESDAY', 'THURSDAY', 'FRIDAY', 'SATURDAY', 'SUNDAY']),
+              maintenance_start_time: T::String
+            ).lax
+
+            # Reserved instance
+            ReservedInstance = T::Hash.schema(
+              count: T::Integer,
+              name: T::String
+            ).lax
+
+            # VPC configuration
+            VpcConfig = T::Hash.schema(
+              public_address_allocation_ids: T::Array.of(T::String),
+              security_group_ids: T::Array.of(T::String),
+              subnet_ids: T::Array.of(T::String)
+            ).lax
+
+            # Log level enum
+            LogLevel = T::String.constrained(included_in: ['ERROR', 'WARNING', 'INFO', 'DEBUG', 'DISABLED'])
+
+            # Channel class enum
+            ChannelClass = T::String.constrained(included_in: ['STANDARD', 'SINGLE_PIPELINE'])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_media_live_channel/types/encoder_config.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module MediaLiveChannel
+          # Encoder configuration type definitions
+          module EncoderConfig
+            T = Resources::Types
+
+            # Image input settings (shared)
+            ImageInput = T::Hash.schema(
+              password_param?: T::String.optional,
+              uri: T::String,
+              username?: T::String.optional
+            ).lax
+
+            # Timecode config
+            TimecodeConfig = T::Hash.schema(
+              source: T::String.constrained(included_in: ['EMBEDDED', 'SYSTEMCLOCK', 'ZEROBASED']),
+              sync_threshold?: T::Integer.optional
+            ).lax
+
+            # Avail blanking
+            AvailBlanking = T::Hash.schema(
+              avail_blanking_image?: ImageInput.optional,
+              state?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional
+            ).lax
+
+            # SCTE35 avail settings
+            Scte35SpliceInsert = T::Hash.schema(
+              ad_avail_offset?: T::Integer.optional,
+              no_regional_blackout_flag?: T::String.constrained(included_in: ['FOLLOW', 'IGNORE']).optional,
+              web_delivery_allowed_flag?: T::String.constrained(included_in: ['FOLLOW', 'IGNORE']).optional
+            ).lax
+
+            Scte35TimeSignalApos = T::Hash.schema(
+              ad_avail_offset?: T::Integer.optional,
+              no_regional_blackout_flag?: T::String.constrained(included_in: ['FOLLOW', 'IGNORE']).optional,
+              web_delivery_allowed_flag?: T::String.constrained(included_in: ['FOLLOW', 'IGNORE']).optional
+            ).lax
+
+            AvailSettings = T::Hash.schema(
+              scte35_splice_insert?: Scte35SpliceInsert.optional,
+              scte35_time_signal_apos?: Scte35TimeSignalApos.optional
+            ).lax
+
+            AvailConfiguration = T::Hash.schema(
+              avail_settings?: AvailSettings.optional
+            ).lax
+
+            # Blackout slate
+            BlackoutSlate = T::Hash.schema(
+              blackout_slate_image?: ImageInput.optional,
+              network_end_blackout?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional,
+              network_end_blackout_image?: ImageInput.optional,
+              network_id?: T::String.optional,
+              state?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional
+            ).lax
+
+            # Feature activations
+            FeatureActivations = T::Hash.schema(
+              input_prepare_schedule_actions?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional
+            ).lax
+
+            # Input loss behavior
+            InputLossBehavior = T::Hash.schema(
+              black_frame_msec?: T::Integer.optional,
+              input_loss_image_color?: T::String.optional,
+              input_loss_image_slate?: ImageInput.optional,
+              input_loss_image_type?: T::String.constrained(included_in: ['COLOR', 'SLATE']).optional,
+              repeat_frame_msec?: T::Integer.optional
+            ).lax
+
+            # Global configuration
+            GlobalConfiguration = T::Hash.schema(
+              initial_audio_gain?: T::Integer.optional,
+              input_end_action?: T::String.constrained(included_in: ['NONE', 'SWITCH_AND_LOOP_INPUTS']).optional,
+              input_loss_behavior?: InputLossBehavior.optional,
+              output_locking_mode?: T::String.constrained(included_in: ['EPOCH_LOCKING', 'PIPELINE_LOCKING']).optional,
+              output_timing_source?: T::String.constrained(included_in: ['INPUT_CLOCK', 'SYSTEM_CLOCK']).optional,
+              support_low_framerate_inputs?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional
+            ).lax
+
+            # Motion graphics configuration
+            MotionGraphicsSettings = T::Hash.schema(
+              html_motion_graphics_settings?: T::Hash.optional
+            ).lax
+
+            MotionGraphicsConfiguration = T::Hash.schema(
+              motion_graphics_insertion?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional,
+              motion_graphics_settings?: MotionGraphicsSettings.optional
+            ).lax
+
+            # Nielsen configuration
+            NielsenConfiguration = T::Hash.schema(
+              distributor_id?: T::String.optional,
+              nielsen_pcm_to_id3_tagging?: T::String.constrained(included_in: ['DISABLED', 'ENABLED']).optional
+            ).lax
+          end
+        end
+      end
+    end
+  end
+end