@aws-sdk/client-medialive 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2930 @@
+
+export interface InputChannelLevel {
+    
+    Gain: number | undefined;
+    
+    InputChannel: number | undefined;
+}
+export declare namespace InputChannelLevel {
+    
+    const filterSensitiveLog: (obj: InputChannelLevel) => any;
+}
+
+export interface AudioChannelMapping {
+    
+    InputChannelLevels: InputChannelLevel[] | undefined;
+    
+    OutputChannel: number | undefined;
+}
+export declare namespace AudioChannelMapping {
+    
+    const filterSensitiveLog: (obj: AudioChannelMapping) => any;
+}
+export declare enum AudioNormalizationAlgorithm {
+    ITU_1770_1 = "ITU_1770_1",
+    ITU_1770_2 = "ITU_1770_2"
+}
+export declare enum AudioNormalizationAlgorithmControl {
+    CORRECT_AUDIO = "CORRECT_AUDIO"
+}
+
+export interface AudioNormalizationSettings {
+    
+    Algorithm?: AudioNormalizationAlgorithm | string;
+    
+    AlgorithmControl?: AudioNormalizationAlgorithmControl | string;
+    
+    TargetLkfs?: number;
+}
+export declare namespace AudioNormalizationSettings {
+    
+    const filterSensitiveLog: (obj: AudioNormalizationSettings) => any;
+}
+export declare enum AudioType {
+    CLEAN_EFFECTS = "CLEAN_EFFECTS",
+    HEARING_IMPAIRED = "HEARING_IMPAIRED",
+    UNDEFINED = "UNDEFINED",
+    VISUAL_IMPAIRED_COMMENTARY = "VISUAL_IMPAIRED_COMMENTARY"
+}
+export declare enum AudioDescriptionAudioTypeControl {
+    FOLLOW_INPUT = "FOLLOW_INPUT",
+    USE_CONFIGURED = "USE_CONFIGURED"
+}
+export declare enum NielsenWatermarksCbetStepaside {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface NielsenCBET {
+    
+    CbetCheckDigitString: string | undefined;
+    
+    CbetStepaside: NielsenWatermarksCbetStepaside | string | undefined;
+    
+    Csid: string | undefined;
+}
+export declare namespace NielsenCBET {
+    
+    const filterSensitiveLog: (obj: NielsenCBET) => any;
+}
+export declare enum NielsenWatermarksDistributionTypes {
+    FINAL_DISTRIBUTOR = "FINAL_DISTRIBUTOR",
+    PROGRAM_CONTENT = "PROGRAM_CONTENT"
+}
+
+export interface NielsenNaesIiNw {
+    
+    CheckDigitString: string | undefined;
+    
+    Sid: number | undefined;
+}
+export declare namespace NielsenNaesIiNw {
+    
+    const filterSensitiveLog: (obj: NielsenNaesIiNw) => any;
+}
+
+export interface NielsenWatermarksSettings {
+    
+    NielsenCbetSettings?: NielsenCBET;
+    
+    NielsenDistributionType?: NielsenWatermarksDistributionTypes | string;
+    
+    NielsenNaesIiNwSettings?: NielsenNaesIiNw;
+}
+export declare namespace NielsenWatermarksSettings {
+    
+    const filterSensitiveLog: (obj: NielsenWatermarksSettings) => any;
+}
+
+export interface AudioWatermarkSettings {
+    
+    NielsenWatermarksSettings?: NielsenWatermarksSettings;
+}
+export declare namespace AudioWatermarkSettings {
+    
+    const filterSensitiveLog: (obj: AudioWatermarkSettings) => any;
+}
+export declare enum AacCodingMode {
+    AD_RECEIVER_MIX = "AD_RECEIVER_MIX",
+    CODING_MODE_1_0 = "CODING_MODE_1_0",
+    CODING_MODE_1_1 = "CODING_MODE_1_1",
+    CODING_MODE_2_0 = "CODING_MODE_2_0",
+    CODING_MODE_5_1 = "CODING_MODE_5_1"
+}
+export declare enum AacInputType {
+    BROADCASTER_MIXED_AD = "BROADCASTER_MIXED_AD",
+    NORMAL = "NORMAL"
+}
+export declare enum AacProfile {
+    HEV1 = "HEV1",
+    HEV2 = "HEV2",
+    LC = "LC"
+}
+export declare enum AacRateControlMode {
+    CBR = "CBR",
+    VBR = "VBR"
+}
+export declare enum AacRawFormat {
+    LATM_LOAS = "LATM_LOAS",
+    NONE = "NONE"
+}
+export declare enum AacSpec {
+    MPEG2 = "MPEG2",
+    MPEG4 = "MPEG4"
+}
+export declare enum AacVbrQuality {
+    HIGH = "HIGH",
+    LOW = "LOW",
+    MEDIUM_HIGH = "MEDIUM_HIGH",
+    MEDIUM_LOW = "MEDIUM_LOW"
+}
+
+export interface AacSettings {
+    
+    Bitrate?: number;
+    
+    CodingMode?: AacCodingMode | string;
+    
+    InputType?: AacInputType | string;
+    
+    Profile?: AacProfile | string;
+    
+    RateControlMode?: AacRateControlMode | string;
+    
+    RawFormat?: AacRawFormat | string;
+    
+    SampleRate?: number;
+    
+    Spec?: AacSpec | string;
+    
+    VbrQuality?: AacVbrQuality | string;
+}
+export declare namespace AacSettings {
+    
+    const filterSensitiveLog: (obj: AacSettings) => any;
+}
+export declare enum Ac3BitstreamMode {
+    COMMENTARY = "COMMENTARY",
+    COMPLETE_MAIN = "COMPLETE_MAIN",
+    DIALOGUE = "DIALOGUE",
+    EMERGENCY = "EMERGENCY",
+    HEARING_IMPAIRED = "HEARING_IMPAIRED",
+    MUSIC_AND_EFFECTS = "MUSIC_AND_EFFECTS",
+    VISUALLY_IMPAIRED = "VISUALLY_IMPAIRED",
+    VOICE_OVER = "VOICE_OVER"
+}
+export declare enum Ac3CodingMode {
+    CODING_MODE_1_0 = "CODING_MODE_1_0",
+    CODING_MODE_1_1 = "CODING_MODE_1_1",
+    CODING_MODE_2_0 = "CODING_MODE_2_0",
+    CODING_MODE_3_2_LFE = "CODING_MODE_3_2_LFE"
+}
+export declare enum Ac3DrcProfile {
+    FILM_STANDARD = "FILM_STANDARD",
+    NONE = "NONE"
+}
+export declare enum Ac3LfeFilter {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum Ac3MetadataControl {
+    FOLLOW_INPUT = "FOLLOW_INPUT",
+    USE_CONFIGURED = "USE_CONFIGURED"
+}
+
+export interface Ac3Settings {
+    
+    Bitrate?: number;
+    
+    BitstreamMode?: Ac3BitstreamMode | string;
+    
+    CodingMode?: Ac3CodingMode | string;
+    
+    Dialnorm?: number;
+    
+    DrcProfile?: Ac3DrcProfile | string;
+    
+    LfeFilter?: Ac3LfeFilter | string;
+    
+    MetadataControl?: Ac3MetadataControl | string;
+}
+export declare namespace Ac3Settings {
+    
+    const filterSensitiveLog: (obj: Ac3Settings) => any;
+}
+export declare enum Eac3AttenuationControl {
+    ATTENUATE_3_DB = "ATTENUATE_3_DB",
+    NONE = "NONE"
+}
+export declare enum Eac3BitstreamMode {
+    COMMENTARY = "COMMENTARY",
+    COMPLETE_MAIN = "COMPLETE_MAIN",
+    EMERGENCY = "EMERGENCY",
+    HEARING_IMPAIRED = "HEARING_IMPAIRED",
+    VISUALLY_IMPAIRED = "VISUALLY_IMPAIRED"
+}
+export declare enum Eac3CodingMode {
+    CODING_MODE_1_0 = "CODING_MODE_1_0",
+    CODING_MODE_2_0 = "CODING_MODE_2_0",
+    CODING_MODE_3_2 = "CODING_MODE_3_2"
+}
+export declare enum Eac3DcFilter {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum Eac3DrcLine {
+    FILM_LIGHT = "FILM_LIGHT",
+    FILM_STANDARD = "FILM_STANDARD",
+    MUSIC_LIGHT = "MUSIC_LIGHT",
+    MUSIC_STANDARD = "MUSIC_STANDARD",
+    NONE = "NONE",
+    SPEECH = "SPEECH"
+}
+export declare enum Eac3DrcRf {
+    FILM_LIGHT = "FILM_LIGHT",
+    FILM_STANDARD = "FILM_STANDARD",
+    MUSIC_LIGHT = "MUSIC_LIGHT",
+    MUSIC_STANDARD = "MUSIC_STANDARD",
+    NONE = "NONE",
+    SPEECH = "SPEECH"
+}
+export declare enum Eac3LfeControl {
+    LFE = "LFE",
+    NO_LFE = "NO_LFE"
+}
+export declare enum Eac3LfeFilter {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum Eac3MetadataControl {
+    FOLLOW_INPUT = "FOLLOW_INPUT",
+    USE_CONFIGURED = "USE_CONFIGURED"
+}
+export declare enum Eac3PassthroughControl {
+    NO_PASSTHROUGH = "NO_PASSTHROUGH",
+    WHEN_POSSIBLE = "WHEN_POSSIBLE"
+}
+export declare enum Eac3PhaseControl {
+    NO_SHIFT = "NO_SHIFT",
+    SHIFT_90_DEGREES = "SHIFT_90_DEGREES"
+}
+export declare enum Eac3StereoDownmix {
+    DPL2 = "DPL2",
+    LO_RO = "LO_RO",
+    LT_RT = "LT_RT",
+    NOT_INDICATED = "NOT_INDICATED"
+}
+export declare enum Eac3SurroundExMode {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED",
+    NOT_INDICATED = "NOT_INDICATED"
+}
+export declare enum Eac3SurroundMode {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED",
+    NOT_INDICATED = "NOT_INDICATED"
+}
+
+export interface Eac3Settings {
+    
+    AttenuationControl?: Eac3AttenuationControl | string;
+    
+    Bitrate?: number;
+    
+    BitstreamMode?: Eac3BitstreamMode | string;
+    
+    CodingMode?: Eac3CodingMode | string;
+    
+    DcFilter?: Eac3DcFilter | string;
+    
+    Dialnorm?: number;
+    
+    DrcLine?: Eac3DrcLine | string;
+    
+    DrcRf?: Eac3DrcRf | string;
+    
+    LfeControl?: Eac3LfeControl | string;
+    
+    LfeFilter?: Eac3LfeFilter | string;
+    
+    LoRoCenterMixLevel?: number;
+    
+    LoRoSurroundMixLevel?: number;
+    
+    LtRtCenterMixLevel?: number;
+    
+    LtRtSurroundMixLevel?: number;
+    
+    MetadataControl?: Eac3MetadataControl | string;
+    
+    PassthroughControl?: Eac3PassthroughControl | string;
+    
+    PhaseControl?: Eac3PhaseControl | string;
+    
+    StereoDownmix?: Eac3StereoDownmix | string;
+    
+    SurroundExMode?: Eac3SurroundExMode | string;
+    
+    SurroundMode?: Eac3SurroundMode | string;
+}
+export declare namespace Eac3Settings {
+    
+    const filterSensitiveLog: (obj: Eac3Settings) => any;
+}
+export declare enum Mp2CodingMode {
+    CODING_MODE_1_0 = "CODING_MODE_1_0",
+    CODING_MODE_2_0 = "CODING_MODE_2_0"
+}
+
+export interface Mp2Settings {
+    
+    Bitrate?: number;
+    
+    CodingMode?: Mp2CodingMode | string;
+    
+    SampleRate?: number;
+}
+export declare namespace Mp2Settings {
+    
+    const filterSensitiveLog: (obj: Mp2Settings) => any;
+}
+
+export interface PassThroughSettings {
+}
+export declare namespace PassThroughSettings {
+    
+    const filterSensitiveLog: (obj: PassThroughSettings) => any;
+}
+export declare enum WavCodingMode {
+    CODING_MODE_1_0 = "CODING_MODE_1_0",
+    CODING_MODE_2_0 = "CODING_MODE_2_0",
+    CODING_MODE_4_0 = "CODING_MODE_4_0",
+    CODING_MODE_8_0 = "CODING_MODE_8_0"
+}
+
+export interface WavSettings {
+    
+    BitDepth?: number;
+    
+    CodingMode?: WavCodingMode | string;
+    
+    SampleRate?: number;
+}
+export declare namespace WavSettings {
+    
+    const filterSensitiveLog: (obj: WavSettings) => any;
+}
+
+export interface AudioCodecSettings {
+    
+    AacSettings?: AacSettings;
+    
+    Ac3Settings?: Ac3Settings;
+    
+    Eac3Settings?: Eac3Settings;
+    
+    Mp2Settings?: Mp2Settings;
+    
+    PassThroughSettings?: PassThroughSettings;
+    
+    WavSettings?: WavSettings;
+}
+export declare namespace AudioCodecSettings {
+    
+    const filterSensitiveLog: (obj: AudioCodecSettings) => any;
+}
+export declare enum AudioDescriptionLanguageCodeControl {
+    FOLLOW_INPUT = "FOLLOW_INPUT",
+    USE_CONFIGURED = "USE_CONFIGURED"
+}
+
+export interface RemixSettings {
+    
+    ChannelMappings: AudioChannelMapping[] | undefined;
+    
+    ChannelsIn?: number;
+    
+    ChannelsOut?: number;
+}
+export declare namespace RemixSettings {
+    
+    const filterSensitiveLog: (obj: RemixSettings) => any;
+}
+
+export interface AudioDescription {
+    
+    AudioNormalizationSettings?: AudioNormalizationSettings;
+    
+    AudioSelectorName: string | undefined;
+    
+    AudioType?: AudioType | string;
+    
+    AudioTypeControl?: AudioDescriptionAudioTypeControl | string;
+    
+    AudioWatermarkingSettings?: AudioWatermarkSettings;
+    
+    CodecSettings?: AudioCodecSettings;
+    
+    LanguageCode?: string;
+    
+    LanguageCodeControl?: AudioDescriptionLanguageCodeControl | string;
+    
+    Name: string | undefined;
+    
+    RemixSettings?: RemixSettings;
+    
+    StreamName?: string;
+}
+export declare namespace AudioDescription {
+    
+    const filterSensitiveLog: (obj: AudioDescription) => any;
+}
+
+export interface AudioHlsRenditionSelection {
+    
+    GroupId: string | undefined;
+    
+    Name: string | undefined;
+}
+export declare namespace AudioHlsRenditionSelection {
+    
+    const filterSensitiveLog: (obj: AudioHlsRenditionSelection) => any;
+}
+export declare enum AudioLanguageSelectionPolicy {
+    LOOSE = "LOOSE",
+    STRICT = "STRICT"
+}
+
+export interface AudioLanguageSelection {
+    
+    LanguageCode: string | undefined;
+    
+    LanguageSelectionPolicy?: AudioLanguageSelectionPolicy | string;
+}
+export declare namespace AudioLanguageSelection {
+    
+    const filterSensitiveLog: (obj: AudioLanguageSelection) => any;
+}
+
+export interface AudioPidSelection {
+    
+    Pid: number | undefined;
+}
+export declare namespace AudioPidSelection {
+    
+    const filterSensitiveLog: (obj: AudioPidSelection) => any;
+}
+
+export interface AudioTrack {
+    
+    Track: number | undefined;
+}
+export declare namespace AudioTrack {
+    
+    const filterSensitiveLog: (obj: AudioTrack) => any;
+}
+
+export interface AudioTrackSelection {
+    
+    Tracks: AudioTrack[] | undefined;
+}
+export declare namespace AudioTrackSelection {
+    
+    const filterSensitiveLog: (obj: AudioTrackSelection) => any;
+}
+
+export interface AudioSelectorSettings {
+    
+    AudioHlsRenditionSelection?: AudioHlsRenditionSelection;
+    
+    AudioLanguageSelection?: AudioLanguageSelection;
+    
+    AudioPidSelection?: AudioPidSelection;
+    
+    AudioTrackSelection?: AudioTrackSelection;
+}
+export declare namespace AudioSelectorSettings {
+    
+    const filterSensitiveLog: (obj: AudioSelectorSettings) => any;
+}
+
+export interface AudioSelector {
+    
+    Name: string | undefined;
+    
+    SelectorSettings?: AudioSelectorSettings;
+}
+export declare namespace AudioSelector {
+    
+    const filterSensitiveLog: (obj: AudioSelector) => any;
+}
+
+export interface BatchFailedResultModel {
+    
+    Arn?: string;
+    
+    Code?: string;
+    
+    Id?: string;
+    
+    Message?: string;
+}
+export declare namespace BatchFailedResultModel {
+    
+    const filterSensitiveLog: (obj: BatchFailedResultModel) => any;
+}
+
+export interface BatchSuccessfulResultModel {
+    
+    Arn?: string;
+    
+    Id?: string;
+    
+    State?: string;
+}
+export declare namespace BatchSuccessfulResultModel {
+    
+    const filterSensitiveLog: (obj: BatchSuccessfulResultModel) => any;
+}
+
+export interface AribDestinationSettings {
+}
+export declare namespace AribDestinationSettings {
+    
+    const filterSensitiveLog: (obj: AribDestinationSettings) => any;
+}
+export declare enum BurnInAlignment {
+    CENTERED = "CENTERED",
+    LEFT = "LEFT",
+    SMART = "SMART"
+}
+export declare enum BurnInBackgroundColor {
+    BLACK = "BLACK",
+    NONE = "NONE",
+    WHITE = "WHITE"
+}
+
+export interface InputLocation {
+    
+    PasswordParam?: string;
+    
+    Uri: string | undefined;
+    
+    Username?: string;
+}
+export declare namespace InputLocation {
+    
+    const filterSensitiveLog: (obj: InputLocation) => any;
+}
+export declare enum BurnInFontColor {
+    BLACK = "BLACK",
+    BLUE = "BLUE",
+    GREEN = "GREEN",
+    RED = "RED",
+    WHITE = "WHITE",
+    YELLOW = "YELLOW"
+}
+export declare enum BurnInOutlineColor {
+    BLACK = "BLACK",
+    BLUE = "BLUE",
+    GREEN = "GREEN",
+    RED = "RED",
+    WHITE = "WHITE",
+    YELLOW = "YELLOW"
+}
+export declare enum BurnInShadowColor {
+    BLACK = "BLACK",
+    NONE = "NONE",
+    WHITE = "WHITE"
+}
+export declare enum BurnInTeletextGridControl {
+    FIXED = "FIXED",
+    SCALED = "SCALED"
+}
+
+export interface BurnInDestinationSettings {
+    
+    Alignment?: BurnInAlignment | string;
+    
+    BackgroundColor?: BurnInBackgroundColor | string;
+    
+    BackgroundOpacity?: number;
+    
+    Font?: InputLocation;
+    
+    FontColor?: BurnInFontColor | string;
+    
+    FontOpacity?: number;
+    
+    FontResolution?: number;
+    
+    FontSize?: string;
+    
+    OutlineColor?: BurnInOutlineColor | string;
+    
+    OutlineSize?: number;
+    
+    ShadowColor?: BurnInShadowColor | string;
+    
+    ShadowOpacity?: number;
+    
+    ShadowXOffset?: number;
+    
+    ShadowYOffset?: number;
+    
+    TeletextGridControl?: BurnInTeletextGridControl | string;
+    
+    XPosition?: number;
+    
+    YPosition?: number;
+}
+export declare namespace BurnInDestinationSettings {
+    
+    const filterSensitiveLog: (obj: BurnInDestinationSettings) => any;
+}
+export declare enum DvbSubDestinationAlignment {
+    CENTERED = "CENTERED",
+    LEFT = "LEFT",
+    SMART = "SMART"
+}
+export declare enum DvbSubDestinationBackgroundColor {
+    BLACK = "BLACK",
+    NONE = "NONE",
+    WHITE = "WHITE"
+}
+export declare enum DvbSubDestinationFontColor {
+    BLACK = "BLACK",
+    BLUE = "BLUE",
+    GREEN = "GREEN",
+    RED = "RED",
+    WHITE = "WHITE",
+    YELLOW = "YELLOW"
+}
+export declare enum DvbSubDestinationOutlineColor {
+    BLACK = "BLACK",
+    BLUE = "BLUE",
+    GREEN = "GREEN",
+    RED = "RED",
+    WHITE = "WHITE",
+    YELLOW = "YELLOW"
+}
+export declare enum DvbSubDestinationShadowColor {
+    BLACK = "BLACK",
+    NONE = "NONE",
+    WHITE = "WHITE"
+}
+export declare enum DvbSubDestinationTeletextGridControl {
+    FIXED = "FIXED",
+    SCALED = "SCALED"
+}
+
+export interface DvbSubDestinationSettings {
+    
+    Alignment?: DvbSubDestinationAlignment | string;
+    
+    BackgroundColor?: DvbSubDestinationBackgroundColor | string;
+    
+    BackgroundOpacity?: number;
+    
+    Font?: InputLocation;
+    
+    FontColor?: DvbSubDestinationFontColor | string;
+    
+    FontOpacity?: number;
+    
+    FontResolution?: number;
+    
+    FontSize?: string;
+    
+    OutlineColor?: DvbSubDestinationOutlineColor | string;
+    
+    OutlineSize?: number;
+    
+    ShadowColor?: DvbSubDestinationShadowColor | string;
+    
+    ShadowOpacity?: number;
+    
+    ShadowXOffset?: number;
+    
+    ShadowYOffset?: number;
+    
+    TeletextGridControl?: DvbSubDestinationTeletextGridControl | string;
+    
+    XPosition?: number;
+    
+    YPosition?: number;
+}
+export declare namespace DvbSubDestinationSettings {
+    
+    const filterSensitiveLog: (obj: DvbSubDestinationSettings) => any;
+}
+export declare enum EbuTtDFillLineGapControl {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum EbuTtDDestinationStyleControl {
+    EXCLUDE = "EXCLUDE",
+    INCLUDE = "INCLUDE"
+}
+
+export interface EbuTtDDestinationSettings {
+    
+    CopyrightHolder?: string;
+    
+    FillLineGap?: EbuTtDFillLineGapControl | string;
+    
+    FontFamily?: string;
+    
+    StyleControl?: EbuTtDDestinationStyleControl | string;
+}
+export declare namespace EbuTtDDestinationSettings {
+    
+    const filterSensitiveLog: (obj: EbuTtDDestinationSettings) => any;
+}
+
+export interface EmbeddedDestinationSettings {
+}
+export declare namespace EmbeddedDestinationSettings {
+    
+    const filterSensitiveLog: (obj: EmbeddedDestinationSettings) => any;
+}
+
+export interface EmbeddedPlusScte20DestinationSettings {
+}
+export declare namespace EmbeddedPlusScte20DestinationSettings {
+    
+    const filterSensitiveLog: (obj: EmbeddedPlusScte20DestinationSettings) => any;
+}
+
+export interface RtmpCaptionInfoDestinationSettings {
+}
+export declare namespace RtmpCaptionInfoDestinationSettings {
+    
+    const filterSensitiveLog: (obj: RtmpCaptionInfoDestinationSettings) => any;
+}
+
+export interface Scte20PlusEmbeddedDestinationSettings {
+}
+export declare namespace Scte20PlusEmbeddedDestinationSettings {
+    
+    const filterSensitiveLog: (obj: Scte20PlusEmbeddedDestinationSettings) => any;
+}
+
+export interface Scte27DestinationSettings {
+}
+export declare namespace Scte27DestinationSettings {
+    
+    const filterSensitiveLog: (obj: Scte27DestinationSettings) => any;
+}
+
+export interface SmpteTtDestinationSettings {
+}
+export declare namespace SmpteTtDestinationSettings {
+    
+    const filterSensitiveLog: (obj: SmpteTtDestinationSettings) => any;
+}
+
+export interface TeletextDestinationSettings {
+}
+export declare namespace TeletextDestinationSettings {
+    
+    const filterSensitiveLog: (obj: TeletextDestinationSettings) => any;
+}
+export declare enum TtmlDestinationStyleControl {
+    PASSTHROUGH = "PASSTHROUGH",
+    USE_CONFIGURED = "USE_CONFIGURED"
+}
+
+export interface TtmlDestinationSettings {
+    
+    StyleControl?: TtmlDestinationStyleControl | string;
+}
+export declare namespace TtmlDestinationSettings {
+    
+    const filterSensitiveLog: (obj: TtmlDestinationSettings) => any;
+}
+export declare enum WebvttDestinationStyleControl {
+    NO_STYLE_DATA = "NO_STYLE_DATA",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+
+export interface WebvttDestinationSettings {
+    
+    StyleControl?: WebvttDestinationStyleControl | string;
+}
+export declare namespace WebvttDestinationSettings {
+    
+    const filterSensitiveLog: (obj: WebvttDestinationSettings) => any;
+}
+
+export interface CaptionDestinationSettings {
+    
+    AribDestinationSettings?: AribDestinationSettings;
+    
+    BurnInDestinationSettings?: BurnInDestinationSettings;
+    
+    DvbSubDestinationSettings?: DvbSubDestinationSettings;
+    
+    EbuTtDDestinationSettings?: EbuTtDDestinationSettings;
+    
+    EmbeddedDestinationSettings?: EmbeddedDestinationSettings;
+    
+    EmbeddedPlusScte20DestinationSettings?: EmbeddedPlusScte20DestinationSettings;
+    
+    RtmpCaptionInfoDestinationSettings?: RtmpCaptionInfoDestinationSettings;
+    
+    Scte20PlusEmbeddedDestinationSettings?: Scte20PlusEmbeddedDestinationSettings;
+    
+    Scte27DestinationSettings?: Scte27DestinationSettings;
+    
+    SmpteTtDestinationSettings?: SmpteTtDestinationSettings;
+    
+    TeletextDestinationSettings?: TeletextDestinationSettings;
+    
+    TtmlDestinationSettings?: TtmlDestinationSettings;
+    
+    WebvttDestinationSettings?: WebvttDestinationSettings;
+}
+export declare namespace CaptionDestinationSettings {
+    
+    const filterSensitiveLog: (obj: CaptionDestinationSettings) => any;
+}
+
+export interface CaptionDescription {
+    
+    CaptionSelectorName: string | undefined;
+    
+    DestinationSettings?: CaptionDestinationSettings;
+    
+    LanguageCode?: string;
+    
+    LanguageDescription?: string;
+    
+    Name: string | undefined;
+}
+export declare namespace CaptionDescription {
+    
+    const filterSensitiveLog: (obj: CaptionDescription) => any;
+}
+
+export interface CaptionLanguageMapping {
+    
+    CaptionChannel: number | undefined;
+    
+    LanguageCode: string | undefined;
+    
+    LanguageDescription: string | undefined;
+}
+export declare namespace CaptionLanguageMapping {
+    
+    const filterSensitiveLog: (obj: CaptionLanguageMapping) => any;
+}
+
+export interface AncillarySourceSettings {
+    
+    SourceAncillaryChannelNumber?: number;
+}
+export declare namespace AncillarySourceSettings {
+    
+    const filterSensitiveLog: (obj: AncillarySourceSettings) => any;
+}
+
+export interface AribSourceSettings {
+}
+export declare namespace AribSourceSettings {
+    
+    const filterSensitiveLog: (obj: AribSourceSettings) => any;
+}
+export declare enum DvbSubOcrLanguage {
+    DEU = "DEU",
+    ENG = "ENG",
+    FRA = "FRA",
+    NLD = "NLD",
+    POR = "POR",
+    SPA = "SPA"
+}
+
+export interface DvbSubSourceSettings {
+    
+    OcrLanguage?: DvbSubOcrLanguage | string;
+    
+    Pid?: number;
+}
+export declare namespace DvbSubSourceSettings {
+    
+    const filterSensitiveLog: (obj: DvbSubSourceSettings) => any;
+}
+export declare enum EmbeddedConvert608To708 {
+    DISABLED = "DISABLED",
+    UPCONVERT = "UPCONVERT"
+}
+export declare enum EmbeddedScte20Detection {
+    AUTO = "AUTO",
+    OFF = "OFF"
+}
+
+export interface EmbeddedSourceSettings {
+    
+    Convert608To708?: EmbeddedConvert608To708 | string;
+    
+    Scte20Detection?: EmbeddedScte20Detection | string;
+    
+    Source608ChannelNumber?: number;
+    
+    Source608TrackNumber?: number;
+}
+export declare namespace EmbeddedSourceSettings {
+    
+    const filterSensitiveLog: (obj: EmbeddedSourceSettings) => any;
+}
+export declare enum Scte20Convert608To708 {
+    DISABLED = "DISABLED",
+    UPCONVERT = "UPCONVERT"
+}
+
+export interface Scte20SourceSettings {
+    
+    Convert608To708?: Scte20Convert608To708 | string;
+    
+    Source608ChannelNumber?: number;
+}
+export declare namespace Scte20SourceSettings {
+    
+    const filterSensitiveLog: (obj: Scte20SourceSettings) => any;
+}
+export declare enum Scte27OcrLanguage {
+    DEU = "DEU",
+    ENG = "ENG",
+    FRA = "FRA",
+    NLD = "NLD",
+    POR = "POR",
+    SPA = "SPA"
+}
+
+export interface Scte27SourceSettings {
+    
+    OcrLanguage?: Scte27OcrLanguage | string;
+    
+    Pid?: number;
+}
+export declare namespace Scte27SourceSettings {
+    
+    const filterSensitiveLog: (obj: Scte27SourceSettings) => any;
+}
+
+export interface CaptionRectangle {
+    
+    Height: number | undefined;
+    
+    LeftOffset: number | undefined;
+    
+    TopOffset: number | undefined;
+    
+    Width: number | undefined;
+}
+export declare namespace CaptionRectangle {
+    
+    const filterSensitiveLog: (obj: CaptionRectangle) => any;
+}
+
+export interface TeletextSourceSettings {
+    
+    OutputRectangle?: CaptionRectangle;
+    
+    PageNumber?: string;
+}
+export declare namespace TeletextSourceSettings {
+    
+    const filterSensitiveLog: (obj: TeletextSourceSettings) => any;
+}
+
+export interface CaptionSelectorSettings {
+    
+    AncillarySourceSettings?: AncillarySourceSettings;
+    
+    AribSourceSettings?: AribSourceSettings;
+    
+    DvbSubSourceSettings?: DvbSubSourceSettings;
+    
+    EmbeddedSourceSettings?: EmbeddedSourceSettings;
+    
+    Scte20SourceSettings?: Scte20SourceSettings;
+    
+    Scte27SourceSettings?: Scte27SourceSettings;
+    
+    TeletextSourceSettings?: TeletextSourceSettings;
+}
+export declare namespace CaptionSelectorSettings {
+    
+    const filterSensitiveLog: (obj: CaptionSelectorSettings) => any;
+}
+
+export interface CaptionSelector {
+    
+    LanguageCode?: string;
+    
+    Name: string | undefined;
+    
+    SelectorSettings?: CaptionSelectorSettings;
+}
+export declare namespace CaptionSelector {
+    
+    const filterSensitiveLog: (obj: CaptionSelector) => any;
+}
+
+export interface ChannelEgressEndpoint {
+    
+    SourceIp?: string;
+}
+export declare namespace ChannelEgressEndpoint {
+    
+    const filterSensitiveLog: (obj: ChannelEgressEndpoint) => any;
+}
+export declare enum CdiInputResolution {
+    FHD = "FHD",
+    HD = "HD",
+    SD = "SD",
+    UHD = "UHD"
+}
+
+export interface CdiInputSpecification {
+    
+    Resolution?: CdiInputResolution | string;
+}
+export declare namespace CdiInputSpecification {
+    
+    const filterSensitiveLog: (obj: CdiInputSpecification) => any;
+}
+export declare enum ChannelClass {
+    SINGLE_PIPELINE = "SINGLE_PIPELINE",
+    STANDARD = "STANDARD"
+}
+
+export interface MediaPackageOutputDestinationSettings {
+    
+    ChannelId?: string;
+}
+export declare namespace MediaPackageOutputDestinationSettings {
+    
+    const filterSensitiveLog: (obj: MediaPackageOutputDestinationSettings) => any;
+}
+
+export interface MultiplexProgramChannelDestinationSettings {
+    
+    MultiplexId?: string;
+    
+    ProgramName?: string;
+}
+export declare namespace MultiplexProgramChannelDestinationSettings {
+    
+    const filterSensitiveLog: (obj: MultiplexProgramChannelDestinationSettings) => any;
+}
+
+export interface OutputDestinationSettings {
+    
+    PasswordParam?: string;
+    
+    StreamName?: string;
+    
+    Url?: string;
+    
+    Username?: string;
+}
+export declare namespace OutputDestinationSettings {
+    
+    const filterSensitiveLog: (obj: OutputDestinationSettings) => any;
+}
+
+export interface OutputDestination {
+    
+    Id?: string;
+    
+    MediaPackageSettings?: MediaPackageOutputDestinationSettings[];
+    
+    MultiplexSettings?: MultiplexProgramChannelDestinationSettings;
+    
+    Settings?: OutputDestinationSettings[];
+}
+export declare namespace OutputDestination {
+    
+    const filterSensitiveLog: (obj: OutputDestination) => any;
+}
+
+export interface AudioSilenceFailoverSettings {
+    
+    AudioSelectorName: string | undefined;
+    
+    AudioSilenceThresholdMsec?: number;
+}
+export declare namespace AudioSilenceFailoverSettings {
+    
+    const filterSensitiveLog: (obj: AudioSilenceFailoverSettings) => any;
+}
+
+export interface InputLossFailoverSettings {
+    
+    InputLossThresholdMsec?: number;
+}
+export declare namespace InputLossFailoverSettings {
+    
+    const filterSensitiveLog: (obj: InputLossFailoverSettings) => any;
+}
+
+export interface VideoBlackFailoverSettings {
+    
+    BlackDetectThreshold?: number;
+    
+    VideoBlackThresholdMsec?: number;
+}
+export declare namespace VideoBlackFailoverSettings {
+    
+    const filterSensitiveLog: (obj: VideoBlackFailoverSettings) => any;
+}
+
+export interface FailoverConditionSettings {
+    
+    AudioSilenceSettings?: AudioSilenceFailoverSettings;
+    
+    InputLossSettings?: InputLossFailoverSettings;
+    
+    VideoBlackSettings?: VideoBlackFailoverSettings;
+}
+export declare namespace FailoverConditionSettings {
+    
+    const filterSensitiveLog: (obj: FailoverConditionSettings) => any;
+}
+
+export interface FailoverCondition {
+    
+    FailoverConditionSettings?: FailoverConditionSettings;
+}
+export declare namespace FailoverCondition {
+    
+    const filterSensitiveLog: (obj: FailoverCondition) => any;
+}
+export declare enum InputPreference {
+    EQUAL_INPUT_PREFERENCE = "EQUAL_INPUT_PREFERENCE",
+    PRIMARY_INPUT_PREFERRED = "PRIMARY_INPUT_PREFERRED"
+}
+
+export interface AutomaticInputFailoverSettings {
+    
+    ErrorClearTimeMsec?: number;
+    
+    FailoverConditions?: FailoverCondition[];
+    
+    InputPreference?: InputPreference | string;
+    
+    SecondaryInputId: string | undefined;
+}
+export declare namespace AutomaticInputFailoverSettings {
+    
+    const filterSensitiveLog: (obj: AutomaticInputFailoverSettings) => any;
+}
+export declare enum InputDeblockFilter {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum InputDenoiseFilter {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum InputFilter {
+    AUTO = "AUTO",
+    DISABLED = "DISABLED",
+    FORCED = "FORCED"
+}
+export declare enum HlsScte35SourceType {
+    MANIFEST = "MANIFEST",
+    SEGMENTS = "SEGMENTS"
+}
+
+export interface HlsInputSettings {
+    
+    Bandwidth?: number;
+    
+    BufferSegments?: number;
+    
+    Retries?: number;
+    
+    RetryInterval?: number;
+    
+    Scte35Source?: HlsScte35SourceType | string;
+}
+export declare namespace HlsInputSettings {
+    
+    const filterSensitiveLog: (obj: HlsInputSettings) => any;
+}
+export declare enum NetworkInputServerValidation {
+    CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME = "CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME",
+    CHECK_CRYPTOGRAPHY_ONLY = "CHECK_CRYPTOGRAPHY_ONLY"
+}
+
+export interface NetworkInputSettings {
+    
+    HlsInputSettings?: HlsInputSettings;
+    
+    ServerValidation?: NetworkInputServerValidation | string;
+}
+export declare namespace NetworkInputSettings {
+    
+    const filterSensitiveLog: (obj: NetworkInputSettings) => any;
+}
+export declare enum Smpte2038DataPreference {
+    IGNORE = "IGNORE",
+    PREFER = "PREFER"
+}
+export declare enum InputSourceEndBehavior {
+    CONTINUE = "CONTINUE",
+    LOOP = "LOOP"
+}
+export declare enum VideoSelectorColorSpace {
+    FOLLOW = "FOLLOW",
+    HDR10 = "HDR10",
+    HLG_2020 = "HLG_2020",
+    REC_601 = "REC_601",
+    REC_709 = "REC_709"
+}
+
+export interface Hdr10Settings {
+    
+    MaxCll?: number;
+    
+    MaxFall?: number;
+}
+export declare namespace Hdr10Settings {
+    
+    const filterSensitiveLog: (obj: Hdr10Settings) => any;
+}
+
+export interface VideoSelectorColorSpaceSettings {
+    
+    Hdr10Settings?: Hdr10Settings;
+}
+export declare namespace VideoSelectorColorSpaceSettings {
+    
+    const filterSensitiveLog: (obj: VideoSelectorColorSpaceSettings) => any;
+}
+export declare enum VideoSelectorColorSpaceUsage {
+    FALLBACK = "FALLBACK",
+    FORCE = "FORCE"
+}
+
+export interface VideoSelectorPid {
+    
+    Pid?: number;
+}
+export declare namespace VideoSelectorPid {
+    
+    const filterSensitiveLog: (obj: VideoSelectorPid) => any;
+}
+
+export interface VideoSelectorProgramId {
+    
+    ProgramId?: number;
+}
+export declare namespace VideoSelectorProgramId {
+    
+    const filterSensitiveLog: (obj: VideoSelectorProgramId) => any;
+}
+
+export interface VideoSelectorSettings {
+    
+    VideoSelectorPid?: VideoSelectorPid;
+    
+    VideoSelectorProgramId?: VideoSelectorProgramId;
+}
+export declare namespace VideoSelectorSettings {
+    
+    const filterSensitiveLog: (obj: VideoSelectorSettings) => any;
+}
+
+export interface VideoSelector {
+    
+    ColorSpace?: VideoSelectorColorSpace | string;
+    
+    ColorSpaceSettings?: VideoSelectorColorSpaceSettings;
+    
+    ColorSpaceUsage?: VideoSelectorColorSpaceUsage | string;
+    
+    SelectorSettings?: VideoSelectorSettings;
+}
+export declare namespace VideoSelector {
+    
+    const filterSensitiveLog: (obj: VideoSelector) => any;
+}
+
+export interface InputSettings {
+    
+    AudioSelectors?: AudioSelector[];
+    
+    CaptionSelectors?: CaptionSelector[];
+    
+    DeblockFilter?: InputDeblockFilter | string;
+    
+    DenoiseFilter?: InputDenoiseFilter | string;
+    
+    FilterStrength?: number;
+    
+    InputFilter?: InputFilter | string;
+    
+    NetworkInputSettings?: NetworkInputSettings;
+    
+    Scte35Pid?: number;
+    
+    Smpte2038DataPreference?: Smpte2038DataPreference | string;
+    
+    SourceEndBehavior?: InputSourceEndBehavior | string;
+    
+    VideoSelector?: VideoSelector;
+}
+export declare namespace InputSettings {
+    
+    const filterSensitiveLog: (obj: InputSettings) => any;
+}
+
+export interface InputAttachment {
+    
+    AutomaticInputFailoverSettings?: AutomaticInputFailoverSettings;
+    
+    InputAttachmentName?: string;
+    
+    InputId?: string;
+    
+    InputSettings?: InputSettings;
+}
+export declare namespace InputAttachment {
+    
+    const filterSensitiveLog: (obj: InputAttachment) => any;
+}
+export declare enum InputCodec {
+    AVC = "AVC",
+    HEVC = "HEVC",
+    MPEG2 = "MPEG2"
+}
+export declare enum InputMaximumBitrate {
+    MAX_10_MBPS = "MAX_10_MBPS",
+    MAX_20_MBPS = "MAX_20_MBPS",
+    MAX_50_MBPS = "MAX_50_MBPS"
+}
+export declare enum InputResolution {
+    HD = "HD",
+    SD = "SD",
+    UHD = "UHD"
+}
+
+export interface InputSpecification {
+    
+    Codec?: InputCodec | string;
+    
+    MaximumBitrate?: InputMaximumBitrate | string;
+    
+    Resolution?: InputResolution | string;
+}
+export declare namespace InputSpecification {
+    
+    const filterSensitiveLog: (obj: InputSpecification) => any;
+}
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    DISABLED = "DISABLED",
+    ERROR = "ERROR",
+    INFO = "INFO",
+    WARNING = "WARNING"
+}
+export declare enum ChannelState {
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DELETING = "DELETING",
+    IDLE = "IDLE",
+    RECOVERING = "RECOVERING",
+    RUNNING = "RUNNING",
+    STARTING = "STARTING",
+    STOPPING = "STOPPING",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATING = "UPDATING"
+}
+
+export interface VpcOutputSettingsDescription {
+    
+    AvailabilityZones?: string[];
+    
+    NetworkInterfaceIds?: string[];
+    
+    SecurityGroupIds?: string[];
+    
+    SubnetIds?: string[];
+}
+export declare namespace VpcOutputSettingsDescription {
+    
+    const filterSensitiveLog: (obj: VpcOutputSettingsDescription) => any;
+}
+
+export interface ChannelSummary {
+    
+    Arn?: string;
+    
+    CdiInputSpecification?: CdiInputSpecification;
+    
+    ChannelClass?: ChannelClass | string;
+    
+    Destinations?: OutputDestination[];
+    
+    EgressEndpoints?: ChannelEgressEndpoint[];
+    
+    Id?: string;
+    
+    InputAttachments?: InputAttachment[];
+    
+    InputSpecification?: InputSpecification;
+    
+    LogLevel?: LogLevel | string;
+    
+    Name?: string;
+    
+    PipelinesRunningCount?: number;
+    
+    RoleArn?: string;
+    
+    State?: ChannelState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Vpc?: VpcOutputSettingsDescription;
+}
+export declare namespace ChannelSummary {
+    
+    const filterSensitiveLog: (obj: ChannelSummary) => any;
+}
+export declare enum HlsAdMarkers {
+    ADOBE = "ADOBE",
+    ELEMENTAL = "ELEMENTAL",
+    ELEMENTAL_SCTE35 = "ELEMENTAL_SCTE35"
+}
+
+export interface InputDestinationVpc {
+    
+    AvailabilityZone?: string;
+    
+    NetworkInterfaceId?: string;
+}
+export declare namespace InputDestinationVpc {
+    
+    const filterSensitiveLog: (obj: InputDestinationVpc) => any;
+}
+
+export interface InputDestination {
+    
+    Ip?: string;
+    
+    Port?: string;
+    
+    Url?: string;
+    
+    Vpc?: InputDestinationVpc;
+}
+export declare namespace InputDestination {
+    
+    const filterSensitiveLog: (obj: InputDestination) => any;
+}
+export declare enum InputClass {
+    SINGLE_PIPELINE = "SINGLE_PIPELINE",
+    STANDARD = "STANDARD"
+}
+
+export interface InputDeviceSettings {
+    
+    Id?: string;
+}
+export declare namespace InputDeviceSettings {
+    
+    const filterSensitiveLog: (obj: InputDeviceSettings) => any;
+}
+export declare enum InputSourceType {
+    DYNAMIC = "DYNAMIC",
+    STATIC = "STATIC"
+}
+
+export interface MediaConnectFlow {
+    
+    FlowArn?: string;
+}
+export declare namespace MediaConnectFlow {
+    
+    const filterSensitiveLog: (obj: MediaConnectFlow) => any;
+}
+
+export interface InputSource {
+    
+    PasswordParam?: string;
+    
+    Url?: string;
+    
+    Username?: string;
+}
+export declare namespace InputSource {
+    
+    const filterSensitiveLog: (obj: InputSource) => any;
+}
+export declare enum InputState {
+    ATTACHED = "ATTACHED",
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DELETING = "DELETING",
+    DETACHED = "DETACHED"
+}
+export declare enum InputType {
+    AWS_CDI = "AWS_CDI",
+    INPUT_DEVICE = "INPUT_DEVICE",
+    MEDIACONNECT = "MEDIACONNECT",
+    MP4_FILE = "MP4_FILE",
+    RTMP_PULL = "RTMP_PULL",
+    RTMP_PUSH = "RTMP_PUSH",
+    RTP_PUSH = "RTP_PUSH",
+    TS_FILE = "TS_FILE",
+    UDP_PUSH = "UDP_PUSH",
+    URL_PULL = "URL_PULL"
+}
+
+export interface Input {
+    
+    Arn?: string;
+    
+    AttachedChannels?: string[];
+    
+    Destinations?: InputDestination[];
+    
+    Id?: string;
+    
+    InputClass?: InputClass | string;
+    
+    InputDevices?: InputDeviceSettings[];
+    
+    InputPartnerIds?: string[];
+    
+    InputSourceType?: InputSourceType | string;
+    
+    MediaConnectFlows?: MediaConnectFlow[];
+    
+    Name?: string;
+    
+    RoleArn?: string;
+    
+    SecurityGroups?: string[];
+    
+    Sources?: InputSource[];
+    
+    State?: InputState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Type?: InputType | string;
+}
+export declare namespace Input {
+    
+    const filterSensitiveLog: (obj: Input) => any;
+}
+
+export interface InputDestinationRequest {
+    
+    StreamName?: string;
+}
+export declare namespace InputDestinationRequest {
+    
+    const filterSensitiveLog: (obj: InputDestinationRequest) => any;
+}
+
+export interface InputDeviceRequest {
+    
+    Id?: string;
+}
+export declare namespace InputDeviceRequest {
+    
+    const filterSensitiveLog: (obj: InputDeviceRequest) => any;
+}
+export declare enum InputDeviceConnectionState {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED"
+}
+export declare enum DeviceSettingsSyncState {
+    SYNCED = "SYNCED",
+    SYNCING = "SYNCING"
+}
+export declare enum DeviceUpdateStatus {
+    NOT_UP_TO_DATE = "NOT_UP_TO_DATE",
+    UP_TO_DATE = "UP_TO_DATE"
+}
+export declare enum InputDeviceActiveInput {
+    HDMI = "HDMI",
+    SDI = "SDI"
+}
+export declare enum InputDeviceConfiguredInput {
+    AUTO = "AUTO",
+    HDMI = "HDMI",
+    SDI = "SDI"
+}
+export declare enum InputDeviceState {
+    IDLE = "IDLE",
+    STREAMING = "STREAMING"
+}
+export declare enum InputDeviceScanType {
+    INTERLACED = "INTERLACED",
+    PROGRESSIVE = "PROGRESSIVE"
+}
+
+export interface InputDeviceHdSettings {
+    
+    ActiveInput?: InputDeviceActiveInput | string;
+    
+    ConfiguredInput?: InputDeviceConfiguredInput | string;
+    
+    DeviceState?: InputDeviceState | string;
+    
+    Framerate?: number;
+    
+    Height?: number;
+    
+    MaxBitrate?: number;
+    
+    ScanType?: InputDeviceScanType | string;
+    
+    Width?: number;
+}
+export declare namespace InputDeviceHdSettings {
+    
+    const filterSensitiveLog: (obj: InputDeviceHdSettings) => any;
+}
+export declare enum InputDeviceIpScheme {
+    DHCP = "DHCP",
+    STATIC = "STATIC"
+}
+
+export interface InputDeviceNetworkSettings {
+    
+    DnsAddresses?: string[];
+    
+    Gateway?: string;
+    
+    IpAddress?: string;
+    
+    IpScheme?: InputDeviceIpScheme | string;
+    
+    SubnetMask?: string;
+}
+export declare namespace InputDeviceNetworkSettings {
+    
+    const filterSensitiveLog: (obj: InputDeviceNetworkSettings) => any;
+}
+export declare enum InputDeviceType {
+    HD = "HD"
+}
+
+export interface InputDeviceUhdSettings {
+    
+    ActiveInput?: InputDeviceActiveInput | string;
+    
+    ConfiguredInput?: InputDeviceConfiguredInput | string;
+    
+    DeviceState?: InputDeviceState | string;
+    
+    Framerate?: number;
+    
+    Height?: number;
+    
+    MaxBitrate?: number;
+    
+    ScanType?: InputDeviceScanType | string;
+    
+    Width?: number;
+}
+export declare namespace InputDeviceUhdSettings {
+    
+    const filterSensitiveLog: (obj: InputDeviceUhdSettings) => any;
+}
+
+export interface InputDeviceSummary {
+    
+    Arn?: string;
+    
+    ConnectionState?: InputDeviceConnectionState | string;
+    
+    DeviceSettingsSyncState?: DeviceSettingsSyncState | string;
+    
+    DeviceUpdateStatus?: DeviceUpdateStatus | string;
+    
+    HdDeviceSettings?: InputDeviceHdSettings;
+    
+    Id?: string;
+    
+    MacAddress?: string;
+    
+    Name?: string;
+    
+    NetworkSettings?: InputDeviceNetworkSettings;
+    
+    SerialNumber?: string;
+    
+    Type?: InputDeviceType | string;
+    
+    UhdDeviceSettings?: InputDeviceUhdSettings;
+}
+export declare namespace InputDeviceSummary {
+    
+    const filterSensitiveLog: (obj: InputDeviceSummary) => any;
+}
+export declare enum InputSecurityGroupState {
+    DELETED = "DELETED",
+    IDLE = "IDLE",
+    IN_USE = "IN_USE",
+    UPDATING = "UPDATING"
+}
+
+export interface InputWhitelistRule {
+    
+    Cidr?: string;
+}
+export declare namespace InputWhitelistRule {
+    
+    const filterSensitiveLog: (obj: InputWhitelistRule) => any;
+}
+
+export interface InputSecurityGroup {
+    
+    Arn?: string;
+    
+    Id?: string;
+    
+    Inputs?: string[];
+    
+    State?: InputSecurityGroupState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    WhitelistRules?: InputWhitelistRule[];
+}
+export declare namespace InputSecurityGroup {
+    
+    const filterSensitiveLog: (obj: InputSecurityGroup) => any;
+}
+
+export interface InputSourceRequest {
+    
+    PasswordParam?: string;
+    
+    Url?: string;
+    
+    Username?: string;
+}
+export declare namespace InputSourceRequest {
+    
+    const filterSensitiveLog: (obj: InputSourceRequest) => any;
+}
+
+export interface InputWhitelistRuleCidr {
+    
+    Cidr?: string;
+}
+export declare namespace InputWhitelistRuleCidr {
+    
+    const filterSensitiveLog: (obj: InputWhitelistRuleCidr) => any;
+}
+
+export interface MediaConnectFlowRequest {
+    
+    FlowArn?: string;
+}
+export declare namespace MediaConnectFlowRequest {
+    
+    const filterSensitiveLog: (obj: MediaConnectFlowRequest) => any;
+}
+
+export interface MultiplexMediaConnectOutputDestinationSettings {
+    
+    EntitlementArn?: string;
+}
+export declare namespace MultiplexMediaConnectOutputDestinationSettings {
+    
+    const filterSensitiveLog: (obj: MultiplexMediaConnectOutputDestinationSettings) => any;
+}
+
+export interface MultiplexOutputDestination {
+    
+    MediaConnectSettings?: MultiplexMediaConnectOutputDestinationSettings;
+}
+export declare namespace MultiplexOutputDestination {
+    
+    const filterSensitiveLog: (obj: MultiplexOutputDestination) => any;
+}
+
+export interface MultiplexProgramPipelineDetail {
+    
+    ActiveChannelPipeline?: string;
+    
+    PipelineId?: string;
+}
+export declare namespace MultiplexProgramPipelineDetail {
+    
+    const filterSensitiveLog: (obj: MultiplexProgramPipelineDetail) => any;
+}
+
+export interface MultiplexProgramSummary {
+    
+    ChannelId?: string;
+    
+    ProgramName?: string;
+}
+export declare namespace MultiplexProgramSummary {
+    
+    const filterSensitiveLog: (obj: MultiplexProgramSummary) => any;
+}
+
+export interface MultiplexSettingsSummary {
+    
+    TransportStreamBitrate?: number;
+}
+export declare namespace MultiplexSettingsSummary {
+    
+    const filterSensitiveLog: (obj: MultiplexSettingsSummary) => any;
+}
+export declare enum MultiplexState {
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DELETING = "DELETING",
+    IDLE = "IDLE",
+    RECOVERING = "RECOVERING",
+    RUNNING = "RUNNING",
+    STARTING = "STARTING",
+    STOPPING = "STOPPING"
+}
+
+export interface MultiplexSummary {
+    
+    Arn?: string;
+    
+    AvailabilityZones?: string[];
+    
+    Id?: string;
+    
+    MultiplexSettings?: MultiplexSettingsSummary;
+    
+    Name?: string;
+    
+    PipelinesRunningCount?: number;
+    
+    ProgramCount?: number;
+    
+    State?: MultiplexState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace MultiplexSummary {
+    
+    const filterSensitiveLog: (obj: MultiplexSummary) => any;
+}
+export declare enum OfferingDurationUnits {
+    MONTHS = "MONTHS"
+}
+export declare enum OfferingType {
+    NO_UPFRONT = "NO_UPFRONT"
+}
+export declare enum ReservationCodec {
+    AUDIO = "AUDIO",
+    AVC = "AVC",
+    HEVC = "HEVC",
+    LINK = "LINK",
+    MPEG2 = "MPEG2"
+}
+export declare enum ReservationMaximumBitrate {
+    MAX_10_MBPS = "MAX_10_MBPS",
+    MAX_20_MBPS = "MAX_20_MBPS",
+    MAX_50_MBPS = "MAX_50_MBPS"
+}
+export declare enum ReservationMaximumFramerate {
+    MAX_30_FPS = "MAX_30_FPS",
+    MAX_60_FPS = "MAX_60_FPS"
+}
+export declare enum ReservationResolution {
+    FHD = "FHD",
+    HD = "HD",
+    SD = "SD",
+    UHD = "UHD"
+}
+export declare enum ReservationResourceType {
+    CHANNEL = "CHANNEL",
+    INPUT = "INPUT",
+    MULTIPLEX = "MULTIPLEX",
+    OUTPUT = "OUTPUT"
+}
+export declare enum ReservationSpecialFeature {
+    ADVANCED_AUDIO = "ADVANCED_AUDIO",
+    AUDIO_NORMALIZATION = "AUDIO_NORMALIZATION",
+    MGHD = "MGHD",
+    MGUHD = "MGUHD"
+}
+export declare enum ReservationVideoQuality {
+    ENHANCED = "ENHANCED",
+    PREMIUM = "PREMIUM",
+    STANDARD = "STANDARD"
+}
+
+export interface ReservationResourceSpecification {
+    
+    ChannelClass?: ChannelClass | string;
+    
+    Codec?: ReservationCodec | string;
+    
+    MaximumBitrate?: ReservationMaximumBitrate | string;
+    
+    MaximumFramerate?: ReservationMaximumFramerate | string;
+    
+    Resolution?: ReservationResolution | string;
+    
+    ResourceType?: ReservationResourceType | string;
+    
+    SpecialFeature?: ReservationSpecialFeature | string;
+    
+    VideoQuality?: ReservationVideoQuality | string;
+}
+export declare namespace ReservationResourceSpecification {
+    
+    const filterSensitiveLog: (obj: ReservationResourceSpecification) => any;
+}
+
+export interface Offering {
+    
+    Arn?: string;
+    
+    CurrencyCode?: string;
+    
+    Duration?: number;
+    
+    DurationUnits?: OfferingDurationUnits | string;
+    
+    FixedPrice?: number;
+    
+    OfferingDescription?: string;
+    
+    OfferingId?: string;
+    
+    OfferingType?: OfferingType | string;
+    
+    Region?: string;
+    
+    ResourceSpecification?: ReservationResourceSpecification;
+    
+    UsagePrice?: number;
+}
+export declare namespace Offering {
+    
+    const filterSensitiveLog: (obj: Offering) => any;
+}
+export declare enum M2tsAbsentInputAudioBehavior {
+    DROP = "DROP",
+    ENCODE_SILENCE = "ENCODE_SILENCE"
+}
+export declare enum M2tsArib {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum M2tsAribCaptionsPidControl {
+    AUTO = "AUTO",
+    USE_CONFIGURED = "USE_CONFIGURED"
+}
+export declare enum M2tsAudioBufferModel {
+    ATSC = "ATSC",
+    DVB = "DVB"
+}
+export declare enum M2tsAudioStreamType {
+    ATSC = "ATSC",
+    DVB = "DVB"
+}
+export declare enum M2tsBufferModel {
+    MULTIPLEX = "MULTIPLEX",
+    NONE = "NONE"
+}
+export declare enum M2tsCcDescriptor {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface DvbNitSettings {
+    
+    NetworkId: number | undefined;
+    
+    NetworkName: string | undefined;
+    
+    RepInterval?: number;
+}
+export declare namespace DvbNitSettings {
+    
+    const filterSensitiveLog: (obj: DvbNitSettings) => any;
+}
+export declare enum DvbSdtOutputSdt {
+    SDT_FOLLOW = "SDT_FOLLOW",
+    SDT_FOLLOW_IF_PRESENT = "SDT_FOLLOW_IF_PRESENT",
+    SDT_MANUAL = "SDT_MANUAL",
+    SDT_NONE = "SDT_NONE"
+}
+
+export interface DvbSdtSettings {
+    
+    OutputSdt?: DvbSdtOutputSdt | string;
+    
+    RepInterval?: number;
+    
+    ServiceName?: string;
+    
+    ServiceProviderName?: string;
+}
+export declare namespace DvbSdtSettings {
+    
+    const filterSensitiveLog: (obj: DvbSdtSettings) => any;
+}
+
+export interface DvbTdtSettings {
+    
+    RepInterval?: number;
+}
+export declare namespace DvbTdtSettings {
+    
+    const filterSensitiveLog: (obj: DvbTdtSettings) => any;
+}
+export declare enum M2tsEbifControl {
+    NONE = "NONE",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+export declare enum M2tsAudioInterval {
+    VIDEO_AND_FIXED_INTERVALS = "VIDEO_AND_FIXED_INTERVALS",
+    VIDEO_INTERVAL = "VIDEO_INTERVAL"
+}
+export declare enum M2tsEbpPlacement {
+    VIDEO_AND_AUDIO_PIDS = "VIDEO_AND_AUDIO_PIDS",
+    VIDEO_PID = "VIDEO_PID"
+}
+export declare enum M2tsEsRateInPes {
+    EXCLUDE = "EXCLUDE",
+    INCLUDE = "INCLUDE"
+}
+export declare enum M2tsKlv {
+    NONE = "NONE",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+export declare enum M2tsNielsenId3Behavior {
+    NO_PASSTHROUGH = "NO_PASSTHROUGH",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+export declare enum M2tsPcrControl {
+    CONFIGURED_PCR_PERIOD = "CONFIGURED_PCR_PERIOD",
+    PCR_EVERY_PES_PACKET = "PCR_EVERY_PES_PACKET"
+}
+export declare enum M2tsRateMode {
+    CBR = "CBR",
+    VBR = "VBR"
+}
+export declare enum M2tsScte35Control {
+    NONE = "NONE",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+export declare enum M2tsSegmentationMarkers {
+    EBP = "EBP",
+    EBP_LEGACY = "EBP_LEGACY",
+    NONE = "NONE",
+    PSI_SEGSTART = "PSI_SEGSTART",
+    RAI_ADAPT = "RAI_ADAPT",
+    RAI_SEGSTART = "RAI_SEGSTART"
+}
+export declare enum M2tsSegmentationStyle {
+    MAINTAIN_CADENCE = "MAINTAIN_CADENCE",
+    RESET_CADENCE = "RESET_CADENCE"
+}
+export declare enum M2tsTimedMetadataBehavior {
+    NO_PASSTHROUGH = "NO_PASSTHROUGH",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+
+export interface M2tsSettings {
+    
+    AbsentInputAudioBehavior?: M2tsAbsentInputAudioBehavior | string;
+    
+    Arib?: M2tsArib | string;
+    
+    AribCaptionsPid?: string;
+    
+    AribCaptionsPidControl?: M2tsAribCaptionsPidControl | string;
+    
+    AudioBufferModel?: M2tsAudioBufferModel | string;
+    
+    AudioFramesPerPes?: number;
+    
+    AudioPids?: string;
+    
+    AudioStreamType?: M2tsAudioStreamType | string;
+    
+    Bitrate?: number;
+    
+    BufferModel?: M2tsBufferModel | string;
+    
+    CcDescriptor?: M2tsCcDescriptor | string;
+    
+    DvbNitSettings?: DvbNitSettings;
+    
+    DvbSdtSettings?: DvbSdtSettings;
+    
+    DvbSubPids?: string;
+    
+    DvbTdtSettings?: DvbTdtSettings;
+    
+    DvbTeletextPid?: string;
+    
+    Ebif?: M2tsEbifControl | string;
+    
+    EbpAudioInterval?: M2tsAudioInterval | string;
+    
+    EbpLookaheadMs?: number;
+    
+    EbpPlacement?: M2tsEbpPlacement | string;
+    
+    EcmPid?: string;
+    
+    EsRateInPes?: M2tsEsRateInPes | string;
+    
+    EtvPlatformPid?: string;
+    
+    EtvSignalPid?: string;
+    
+    FragmentTime?: number;
+    
+    Klv?: M2tsKlv | string;
+    
+    KlvDataPids?: string;
+    
+    NielsenId3Behavior?: M2tsNielsenId3Behavior | string;
+    
+    NullPacketBitrate?: number;
+    
+    PatInterval?: number;
+    
+    PcrControl?: M2tsPcrControl | string;
+    
+    PcrPeriod?: number;
+    
+    PcrPid?: string;
+    
+    PmtInterval?: number;
+    
+    PmtPid?: string;
+    
+    ProgramNum?: number;
+    
+    RateMode?: M2tsRateMode | string;
+    
+    Scte27Pids?: string;
+    
+    Scte35Control?: M2tsScte35Control | string;
+    
+    Scte35Pid?: string;
+    
+    SegmentationMarkers?: M2tsSegmentationMarkers | string;
+    
+    SegmentationStyle?: M2tsSegmentationStyle | string;
+    
+    SegmentationTime?: number;
+    
+    TimedMetadataBehavior?: M2tsTimedMetadataBehavior | string;
+    
+    TimedMetadataPid?: string;
+    
+    TransportStreamId?: number;
+    
+    VideoPid?: string;
+}
+export declare namespace M2tsSettings {
+    
+    const filterSensitiveLog: (obj: M2tsSettings) => any;
+}
+
+export interface RawSettings {
+}
+export declare namespace RawSettings {
+    
+    const filterSensitiveLog: (obj: RawSettings) => any;
+}
+
+export interface ArchiveContainerSettings {
+    
+    M2tsSettings?: M2tsSettings;
+    
+    RawSettings?: RawSettings;
+}
+export declare namespace ArchiveContainerSettings {
+    
+    const filterSensitiveLog: (obj: ArchiveContainerSettings) => any;
+}
+
+export interface ArchiveOutputSettings {
+    
+    ContainerSettings: ArchiveContainerSettings | undefined;
+    
+    Extension?: string;
+    
+    NameModifier?: string;
+}
+export declare namespace ArchiveOutputSettings {
+    
+    const filterSensitiveLog: (obj: ArchiveOutputSettings) => any;
+}
+
+export interface FrameCaptureOutputSettings {
+    
+    NameModifier?: string;
+}
+export declare namespace FrameCaptureOutputSettings {
+    
+    const filterSensitiveLog: (obj: FrameCaptureOutputSettings) => any;
+}
+export declare enum HlsH265PackagingType {
+    HEV1 = "HEV1",
+    HVC1 = "HVC1"
+}
+export declare enum AudioOnlyHlsTrackType {
+    ALTERNATE_AUDIO_AUTO_SELECT = "ALTERNATE_AUDIO_AUTO_SELECT",
+    ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT = "ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT",
+    ALTERNATE_AUDIO_NOT_AUTO_SELECT = "ALTERNATE_AUDIO_NOT_AUTO_SELECT",
+    AUDIO_ONLY_VARIANT_STREAM = "AUDIO_ONLY_VARIANT_STREAM"
+}
+export declare enum AudioOnlyHlsSegmentType {
+    AAC = "AAC",
+    FMP4 = "FMP4"
+}
+
+export interface AudioOnlyHlsSettings {
+    
+    AudioGroupId?: string;
+    
+    AudioOnlyImage?: InputLocation;
+    
+    AudioTrackType?: AudioOnlyHlsTrackType | string;
+    
+    SegmentType?: AudioOnlyHlsSegmentType | string;
+}
+export declare namespace AudioOnlyHlsSettings {
+    
+    const filterSensitiveLog: (obj: AudioOnlyHlsSettings) => any;
+}
+export declare enum Fmp4NielsenId3Behavior {
+    NO_PASSTHROUGH = "NO_PASSTHROUGH",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+export declare enum Fmp4TimedMetadataBehavior {
+    NO_PASSTHROUGH = "NO_PASSTHROUGH",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+
+export interface Fmp4HlsSettings {
+    
+    AudioRenditionSets?: string;
+    
+    NielsenId3Behavior?: Fmp4NielsenId3Behavior | string;
+    
+    TimedMetadataBehavior?: Fmp4TimedMetadataBehavior | string;
+}
+export declare namespace Fmp4HlsSettings {
+    
+    const filterSensitiveLog: (obj: Fmp4HlsSettings) => any;
+}
+
+export interface FrameCaptureHlsSettings {
+}
+export declare namespace FrameCaptureHlsSettings {
+    
+    const filterSensitiveLog: (obj: FrameCaptureHlsSettings) => any;
+}
+export declare enum M3u8NielsenId3Behavior {
+    NO_PASSTHROUGH = "NO_PASSTHROUGH",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+export declare enum M3u8PcrControl {
+    CONFIGURED_PCR_PERIOD = "CONFIGURED_PCR_PERIOD",
+    PCR_EVERY_PES_PACKET = "PCR_EVERY_PES_PACKET"
+}
+export declare enum M3u8Scte35Behavior {
+    NO_PASSTHROUGH = "NO_PASSTHROUGH",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+export declare enum M3u8TimedMetadataBehavior {
+    NO_PASSTHROUGH = "NO_PASSTHROUGH",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+
+export interface M3u8Settings {
+    
+    AudioFramesPerPes?: number;
+    
+    AudioPids?: string;
+    
+    EcmPid?: string;
+    
+    NielsenId3Behavior?: M3u8NielsenId3Behavior | string;
+    
+    PatInterval?: number;
+    
+    PcrControl?: M3u8PcrControl | string;
+    
+    PcrPeriod?: number;
+    
+    PcrPid?: string;
+    
+    PmtInterval?: number;
+    
+    PmtPid?: string;
+    
+    ProgramNum?: number;
+    
+    Scte35Behavior?: M3u8Scte35Behavior | string;
+    
+    Scte35Pid?: string;
+    
+    TimedMetadataBehavior?: M3u8TimedMetadataBehavior | string;
+    
+    TimedMetadataPid?: string;
+    
+    TransportStreamId?: number;
+    
+    VideoPid?: string;
+}
+export declare namespace M3u8Settings {
+    
+    const filterSensitiveLog: (obj: M3u8Settings) => any;
+}
+
+export interface StandardHlsSettings {
+    
+    AudioRenditionSets?: string;
+    
+    M3u8Settings: M3u8Settings | undefined;
+}
+export declare namespace StandardHlsSettings {
+    
+    const filterSensitiveLog: (obj: StandardHlsSettings) => any;
+}
+
+export interface HlsSettings {
+    
+    AudioOnlyHlsSettings?: AudioOnlyHlsSettings;
+    
+    Fmp4HlsSettings?: Fmp4HlsSettings;
+    
+    FrameCaptureHlsSettings?: FrameCaptureHlsSettings;
+    
+    StandardHlsSettings?: StandardHlsSettings;
+}
+export declare namespace HlsSettings {
+    
+    const filterSensitiveLog: (obj: HlsSettings) => any;
+}
+
+export interface HlsOutputSettings {
+    
+    H265PackagingType?: HlsH265PackagingType | string;
+    
+    HlsSettings: HlsSettings | undefined;
+    
+    NameModifier?: string;
+    
+    SegmentModifier?: string;
+}
+export declare namespace HlsOutputSettings {
+    
+    const filterSensitiveLog: (obj: HlsOutputSettings) => any;
+}
+
+export interface MediaPackageOutputSettings {
+}
+export declare namespace MediaPackageOutputSettings {
+    
+    const filterSensitiveLog: (obj: MediaPackageOutputSettings) => any;
+}
+export declare enum MsSmoothH265PackagingType {
+    HEV1 = "HEV1",
+    HVC1 = "HVC1"
+}
+
+export interface MsSmoothOutputSettings {
+    
+    H265PackagingType?: MsSmoothH265PackagingType | string;
+    
+    NameModifier?: string;
+}
+export declare namespace MsSmoothOutputSettings {
+    
+    const filterSensitiveLog: (obj: MsSmoothOutputSettings) => any;
+}
+
+export interface OutputLocationRef {
+    
+    DestinationRefId?: string;
+}
+export declare namespace OutputLocationRef {
+    
+    const filterSensitiveLog: (obj: OutputLocationRef) => any;
+}
+
+export interface MultiplexOutputSettings {
+    
+    Destination: OutputLocationRef | undefined;
+}
+export declare namespace MultiplexOutputSettings {
+    
+    const filterSensitiveLog: (obj: MultiplexOutputSettings) => any;
+}
+export declare enum RtmpOutputCertificateMode {
+    SELF_SIGNED = "SELF_SIGNED",
+    VERIFY_AUTHENTICITY = "VERIFY_AUTHENTICITY"
+}
+
+export interface RtmpOutputSettings {
+    
+    CertificateMode?: RtmpOutputCertificateMode | string;
+    
+    ConnectionRetryInterval?: number;
+    
+    Destination: OutputLocationRef | undefined;
+    
+    NumRetries?: number;
+}
+export declare namespace RtmpOutputSettings {
+    
+    const filterSensitiveLog: (obj: RtmpOutputSettings) => any;
+}
+
+export interface UdpContainerSettings {
+    
+    M2tsSettings?: M2tsSettings;
+}
+export declare namespace UdpContainerSettings {
+    
+    const filterSensitiveLog: (obj: UdpContainerSettings) => any;
+}
+export declare enum FecOutputIncludeFec {
+    COLUMN = "COLUMN",
+    COLUMN_AND_ROW = "COLUMN_AND_ROW"
+}
+
+export interface FecOutputSettings {
+    
+    ColumnDepth?: number;
+    
+    IncludeFec?: FecOutputIncludeFec | string;
+    
+    RowLength?: number;
+}
+export declare namespace FecOutputSettings {
+    
+    const filterSensitiveLog: (obj: FecOutputSettings) => any;
+}
+
+export interface UdpOutputSettings {
+    
+    BufferMsec?: number;
+    
+    ContainerSettings: UdpContainerSettings | undefined;
+    
+    Destination: OutputLocationRef | undefined;
+    
+    FecOutputSettings?: FecOutputSettings;
+}
+export declare namespace UdpOutputSettings {
+    
+    const filterSensitiveLog: (obj: UdpOutputSettings) => any;
+}
+
+export interface OutputSettings {
+    
+    ArchiveOutputSettings?: ArchiveOutputSettings;
+    
+    FrameCaptureOutputSettings?: FrameCaptureOutputSettings;
+    
+    HlsOutputSettings?: HlsOutputSettings;
+    
+    MediaPackageOutputSettings?: MediaPackageOutputSettings;
+    
+    MsSmoothOutputSettings?: MsSmoothOutputSettings;
+    
+    MultiplexOutputSettings?: MultiplexOutputSettings;
+    
+    RtmpOutputSettings?: RtmpOutputSettings;
+    
+    UdpOutputSettings?: UdpOutputSettings;
+}
+export declare namespace OutputSettings {
+    
+    const filterSensitiveLog: (obj: OutputSettings) => any;
+}
+
+export interface Output {
+    
+    AudioDescriptionNames?: string[];
+    
+    CaptionDescriptionNames?: string[];
+    
+    OutputName?: string;
+    
+    OutputSettings: OutputSettings | undefined;
+    
+    VideoDescriptionName?: string;
+}
+export declare namespace Output {
+    
+    const filterSensitiveLog: (obj: Output) => any;
+}
+export declare enum S3CannedAcl {
+    AUTHENTICATED_READ = "AUTHENTICATED_READ",
+    BUCKET_OWNER_FULL_CONTROL = "BUCKET_OWNER_FULL_CONTROL",
+    BUCKET_OWNER_READ = "BUCKET_OWNER_READ",
+    PUBLIC_READ = "PUBLIC_READ"
+}
+
+export interface ArchiveS3Settings {
+    
+    CannedAcl?: S3CannedAcl | string;
+}
+export declare namespace ArchiveS3Settings {
+    
+    const filterSensitiveLog: (obj: ArchiveS3Settings) => any;
+}
+
+export interface ArchiveCdnSettings {
+    
+    ArchiveS3Settings?: ArchiveS3Settings;
+}
+export declare namespace ArchiveCdnSettings {
+    
+    const filterSensitiveLog: (obj: ArchiveCdnSettings) => any;
+}
+
+export interface ArchiveGroupSettings {
+    
+    ArchiveCdnSettings?: ArchiveCdnSettings;
+    
+    Destination: OutputLocationRef | undefined;
+    
+    RolloverInterval?: number;
+}
+export declare namespace ArchiveGroupSettings {
+    
+    const filterSensitiveLog: (obj: ArchiveGroupSettings) => any;
+}
+
+export interface FrameCaptureS3Settings {
+    
+    CannedAcl?: S3CannedAcl | string;
+}
+export declare namespace FrameCaptureS3Settings {
+    
+    const filterSensitiveLog: (obj: FrameCaptureS3Settings) => any;
+}
+
+export interface FrameCaptureCdnSettings {
+    
+    FrameCaptureS3Settings?: FrameCaptureS3Settings;
+}
+export declare namespace FrameCaptureCdnSettings {
+    
+    const filterSensitiveLog: (obj: FrameCaptureCdnSettings) => any;
+}
+
+export interface FrameCaptureGroupSettings {
+    
+    Destination: OutputLocationRef | undefined;
+    
+    FrameCaptureCdnSettings?: FrameCaptureCdnSettings;
+}
+export declare namespace FrameCaptureGroupSettings {
+    
+    const filterSensitiveLog: (obj: FrameCaptureGroupSettings) => any;
+}
+export declare enum HlsCaptionLanguageSetting {
+    INSERT = "INSERT",
+    NONE = "NONE",
+    OMIT = "OMIT"
+}
+export declare enum HlsClientCache {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum HlsCodecSpecification {
+    RFC_4281 = "RFC_4281",
+    RFC_6381 = "RFC_6381"
+}
+export declare enum HlsDirectoryStructure {
+    SINGLE_DIRECTORY = "SINGLE_DIRECTORY",
+    SUBDIRECTORY_PER_STREAM = "SUBDIRECTORY_PER_STREAM"
+}
+export declare enum HlsDiscontinuityTags {
+    INSERT = "INSERT",
+    NEVER_INSERT = "NEVER_INSERT"
+}
+export declare enum HlsEncryptionType {
+    AES128 = "AES128",
+    SAMPLE_AES = "SAMPLE_AES"
+}
+export declare enum HlsAkamaiHttpTransferMode {
+    CHUNKED = "CHUNKED",
+    NON_CHUNKED = "NON_CHUNKED"
+}
+
+export interface HlsAkamaiSettings {
+    
+    ConnectionRetryInterval?: number;
+    
+    FilecacheDuration?: number;
+    
+    HttpTransferMode?: HlsAkamaiHttpTransferMode | string;
+    
+    NumRetries?: number;
+    
+    RestartDelay?: number;
+    
+    Salt?: string;
+    
+    Token?: string;
+}
+export declare namespace HlsAkamaiSettings {
+    
+    const filterSensitiveLog: (obj: HlsAkamaiSettings) => any;
+}
+
+export interface HlsBasicPutSettings {
+    
+    ConnectionRetryInterval?: number;
+    
+    FilecacheDuration?: number;
+    
+    NumRetries?: number;
+    
+    RestartDelay?: number;
+}
+export declare namespace HlsBasicPutSettings {
+    
+    const filterSensitiveLog: (obj: HlsBasicPutSettings) => any;
+}
+export declare enum HlsMediaStoreStorageClass {
+    TEMPORAL = "TEMPORAL"
+}
+
+export interface HlsMediaStoreSettings {
+    
+    ConnectionRetryInterval?: number;
+    
+    FilecacheDuration?: number;
+    
+    MediaStoreStorageClass?: HlsMediaStoreStorageClass | string;
+    
+    NumRetries?: number;
+    
+    RestartDelay?: number;
+}
+export declare namespace HlsMediaStoreSettings {
+    
+    const filterSensitiveLog: (obj: HlsMediaStoreSettings) => any;
+}
+
+export interface HlsS3Settings {
+    
+    CannedAcl?: S3CannedAcl | string;
+}
+export declare namespace HlsS3Settings {
+    
+    const filterSensitiveLog: (obj: HlsS3Settings) => any;
+}
+export declare enum HlsWebdavHttpTransferMode {
+    CHUNKED = "CHUNKED",
+    NON_CHUNKED = "NON_CHUNKED"
+}
+
+export interface HlsWebdavSettings {
+    
+    ConnectionRetryInterval?: number;
+    
+    FilecacheDuration?: number;
+    
+    HttpTransferMode?: HlsWebdavHttpTransferMode | string;
+    
+    NumRetries?: number;
+    
+    RestartDelay?: number;
+}
+export declare namespace HlsWebdavSettings {
+    
+    const filterSensitiveLog: (obj: HlsWebdavSettings) => any;
+}
+
+export interface HlsCdnSettings {
+    
+    HlsAkamaiSettings?: HlsAkamaiSettings;
+    
+    HlsBasicPutSettings?: HlsBasicPutSettings;
+    
+    HlsMediaStoreSettings?: HlsMediaStoreSettings;
+    
+    HlsS3Settings?: HlsS3Settings;
+    
+    HlsWebdavSettings?: HlsWebdavSettings;
+}
+export declare namespace HlsCdnSettings {
+    
+    const filterSensitiveLog: (obj: HlsCdnSettings) => any;
+}
+export declare enum HlsId3SegmentTaggingState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum IFrameOnlyPlaylistType {
+    DISABLED = "DISABLED",
+    STANDARD = "STANDARD"
+}
+export declare enum HlsIncompleteSegmentBehavior {
+    AUTO = "AUTO",
+    SUPPRESS = "SUPPRESS"
+}
+export declare enum InputLossActionForHlsOut {
+    EMIT_OUTPUT = "EMIT_OUTPUT",
+    PAUSE_OUTPUT = "PAUSE_OUTPUT"
+}
+export declare enum HlsIvInManifest {
+    EXCLUDE = "EXCLUDE",
+    INCLUDE = "INCLUDE"
+}
+export declare enum HlsIvSource {
+    EXPLICIT = "EXPLICIT",
+    FOLLOWS_SEGMENT_NUMBER = "FOLLOWS_SEGMENT_NUMBER"
+}
+
+export interface StaticKeySettings {
+    
+    KeyProviderServer?: InputLocation;
+    
+    StaticKeyValue: string | undefined;
+}
+export declare namespace StaticKeySettings {
+    
+    const filterSensitiveLog: (obj: StaticKeySettings) => any;
+}
+
+export interface KeyProviderSettings {
+    
+    StaticKeySettings?: StaticKeySettings;
+}
+export declare namespace KeyProviderSettings {
+    
+    const filterSensitiveLog: (obj: KeyProviderSettings) => any;
+}
+export declare enum HlsManifestCompression {
+    GZIP = "GZIP",
+    NONE = "NONE"
+}
+export declare enum HlsManifestDurationFormat {
+    FLOATING_POINT = "FLOATING_POINT",
+    INTEGER = "INTEGER"
+}
+export declare enum HlsMode {
+    LIVE = "LIVE",
+    VOD = "VOD"
+}
+export declare enum HlsOutputSelection {
+    MANIFESTS_AND_SEGMENTS = "MANIFESTS_AND_SEGMENTS",
+    SEGMENTS_ONLY = "SEGMENTS_ONLY",
+    VARIANT_MANIFESTS_AND_SEGMENTS = "VARIANT_MANIFESTS_AND_SEGMENTS"
+}
+export declare enum HlsProgramDateTime {
+    EXCLUDE = "EXCLUDE",
+    INCLUDE = "INCLUDE"
+}
+export declare enum HlsProgramDateTimeClock {
+    INITIALIZE_FROM_OUTPUT_TIMECODE = "INITIALIZE_FROM_OUTPUT_TIMECODE",
+    SYSTEM_CLOCK = "SYSTEM_CLOCK"
+}
+export declare enum HlsRedundantManifest {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum HlsSegmentationMode {
+    USE_INPUT_SEGMENTATION = "USE_INPUT_SEGMENTATION",
+    USE_SEGMENT_DURATION = "USE_SEGMENT_DURATION"
+}
+export declare enum HlsStreamInfResolution {
+    EXCLUDE = "EXCLUDE",
+    INCLUDE = "INCLUDE"
+}
+export declare enum HlsTimedMetadataId3Frame {
+    NONE = "NONE",
+    PRIV = "PRIV",
+    TDRL = "TDRL"
+}
+export declare enum HlsTsFileMode {
+    SEGMENTED_FILES = "SEGMENTED_FILES",
+    SINGLE_FILE = "SINGLE_FILE"
+}
+
+export interface HlsGroupSettings {
+    
+    AdMarkers?: (HlsAdMarkers | string)[];
+    
+    BaseUrlContent?: string;
+    
+    BaseUrlContent1?: string;
+    
+    BaseUrlManifest?: string;
+    
+    BaseUrlManifest1?: string;
+    
+    CaptionLanguageMappings?: CaptionLanguageMapping[];
+    
+    CaptionLanguageSetting?: HlsCaptionLanguageSetting | string;
+    
+    ClientCache?: HlsClientCache | string;
+    
+    CodecSpecification?: HlsCodecSpecification | string;
+    
+    ConstantIv?: string;
+    
+    Destination: OutputLocationRef | undefined;
+    
+    DirectoryStructure?: HlsDirectoryStructure | string;
+    
+    DiscontinuityTags?: HlsDiscontinuityTags | string;
+    
+    EncryptionType?: HlsEncryptionType | string;
+    
+    HlsCdnSettings?: HlsCdnSettings;
+    
+    HlsId3SegmentTagging?: HlsId3SegmentTaggingState | string;
+    
+    IFrameOnlyPlaylists?: IFrameOnlyPlaylistType | string;
+    
+    IncompleteSegmentBehavior?: HlsIncompleteSegmentBehavior | string;
+    
+    IndexNSegments?: number;
+    
+    InputLossAction?: InputLossActionForHlsOut | string;
+    
+    IvInManifest?: HlsIvInManifest | string;
+    
+    IvSource?: HlsIvSource | string;
+    
+    KeepSegments?: number;
+    
+    KeyFormat?: string;
+    
+    KeyFormatVersions?: string;
+    
+    KeyProviderSettings?: KeyProviderSettings;
+    
+    ManifestCompression?: HlsManifestCompression | string;
+    
+    ManifestDurationFormat?: HlsManifestDurationFormat | string;
+    
+    MinSegmentLength?: number;
+    
+    Mode?: HlsMode | string;
+    
+    OutputSelection?: HlsOutputSelection | string;
+    
+    ProgramDateTime?: HlsProgramDateTime | string;
+    
+    ProgramDateTimeClock?: HlsProgramDateTimeClock | string;
+    
+    ProgramDateTimePeriod?: number;
+    
+    RedundantManifest?: HlsRedundantManifest | string;
+    
+    SegmentLength?: number;
+    
+    SegmentationMode?: HlsSegmentationMode | string;
+    
+    SegmentsPerSubdirectory?: number;
+    
+    StreamInfResolution?: HlsStreamInfResolution | string;
+    
+    TimedMetadataId3Frame?: HlsTimedMetadataId3Frame | string;
+    
+    TimedMetadataId3Period?: number;
+    
+    TimestampDeltaMilliseconds?: number;
+    
+    TsFileMode?: HlsTsFileMode | string;
+}
+export declare namespace HlsGroupSettings {
+    
+    const filterSensitiveLog: (obj: HlsGroupSettings) => any;
+}