awscdk-construct-scte-scheduler 0.0.0

package/node_modules/@aws-sdk/client-medialive/dist-types/ts3.4/models/models_0.d.ts

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