@aws-sdk/client-medialive 3.50.0 → 3.53.0

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

@@ -0,0 +1,3563 @@
+
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { Readable } from "stream";
+import { MediaLiveServiceException as __BaseException } from "./MediaLiveServiceException";
+import { ArchiveGroupSettings, AudioDescription, BatchFailedResultModel, BatchSuccessfulResultModel, CaptionDescription, CdiInputSpecification, ChannelClass, ChannelEgressEndpoint, ChannelState, ChannelSummary, DeviceSettingsSyncState, DeviceUpdateStatus, FrameCaptureGroupSettings, Hdr10Settings, HlsGroupSettings, Input, InputAttachment, InputClass, InputDestination, InputDestinationRequest, InputDeviceConfiguredInput, InputDeviceConnectionState, InputDeviceHdSettings, InputDeviceNetworkSettings, InputDeviceRequest, InputDeviceSettings, InputDeviceSummary, InputDeviceType, InputDeviceUhdSettings, InputLocation, InputSecurityGroup, InputSecurityGroupState, InputSource, InputSourceRequest, InputSourceType, InputSpecification, InputState, InputType, InputWhitelistRule, InputWhitelistRuleCidr, LogLevel, MediaConnectFlow, MediaConnectFlowRequest, MultiplexOutputDestination, MultiplexProgramPipelineDetail, MultiplexProgramSummary, MultiplexState, MultiplexSummary, Offering, OfferingDurationUnits, OfferingType, Output, OutputDestination, OutputLocationRef, ReservationResourceSpecification, VpcOutputSettingsDescription } from "./models_0";
+
+export interface MediaPackageGroupSettings {
+    
+    Destination: OutputLocationRef | undefined;
+}
+export declare namespace MediaPackageGroupSettings {
+    
+    const filterSensitiveLog: (obj: MediaPackageGroupSettings) => any;
+}
+export declare enum SmoothGroupAudioOnlyTimecodeControl {
+    PASSTHROUGH = "PASSTHROUGH",
+    USE_CONFIGURED_CLOCK = "USE_CONFIGURED_CLOCK"
+}
+export declare enum SmoothGroupCertificateMode {
+    SELF_SIGNED = "SELF_SIGNED",
+    VERIFY_AUTHENTICITY = "VERIFY_AUTHENTICITY"
+}
+export declare enum SmoothGroupEventIdMode {
+    NO_EVENT_ID = "NO_EVENT_ID",
+    USE_CONFIGURED = "USE_CONFIGURED",
+    USE_TIMESTAMP = "USE_TIMESTAMP"
+}
+export declare enum SmoothGroupEventStopBehavior {
+    NONE = "NONE",
+    SEND_EOS = "SEND_EOS"
+}
+export declare enum InputLossActionForMsSmoothOut {
+    EMIT_OUTPUT = "EMIT_OUTPUT",
+    PAUSE_OUTPUT = "PAUSE_OUTPUT"
+}
+export declare enum SmoothGroupSegmentationMode {
+    USE_INPUT_SEGMENTATION = "USE_INPUT_SEGMENTATION",
+    USE_SEGMENT_DURATION = "USE_SEGMENT_DURATION"
+}
+export declare enum SmoothGroupSparseTrackType {
+    NONE = "NONE",
+    SCTE_35 = "SCTE_35",
+    SCTE_35_WITHOUT_SEGMENTATION = "SCTE_35_WITHOUT_SEGMENTATION"
+}
+export declare enum SmoothGroupStreamManifestBehavior {
+    DO_NOT_SEND = "DO_NOT_SEND",
+    SEND = "SEND"
+}
+export declare enum SmoothGroupTimestampOffsetMode {
+    USE_CONFIGURED_OFFSET = "USE_CONFIGURED_OFFSET",
+    USE_EVENT_START_DATE = "USE_EVENT_START_DATE"
+}
+
+export interface MsSmoothGroupSettings {
+    
+    AcquisitionPointId?: string;
+    
+    AudioOnlyTimecodeControl?: SmoothGroupAudioOnlyTimecodeControl | string;
+    
+    CertificateMode?: SmoothGroupCertificateMode | string;
+    
+    ConnectionRetryInterval?: number;
+    
+    Destination: OutputLocationRef | undefined;
+    
+    EventId?: string;
+    
+    EventIdMode?: SmoothGroupEventIdMode | string;
+    
+    EventStopBehavior?: SmoothGroupEventStopBehavior | string;
+    
+    FilecacheDuration?: number;
+    
+    FragmentLength?: number;
+    
+    InputLossAction?: InputLossActionForMsSmoothOut | string;
+    
+    NumRetries?: number;
+    
+    RestartDelay?: number;
+    
+    SegmentationMode?: SmoothGroupSegmentationMode | string;
+    
+    SendDelayMs?: number;
+    
+    SparseTrackType?: SmoothGroupSparseTrackType | string;
+    
+    StreamManifestBehavior?: SmoothGroupStreamManifestBehavior | string;
+    
+    TimestampOffset?: string;
+    
+    TimestampOffsetMode?: SmoothGroupTimestampOffsetMode | string;
+}
+export declare namespace MsSmoothGroupSettings {
+    
+    const filterSensitiveLog: (obj: MsSmoothGroupSettings) => any;
+}
+
+export interface MultiplexGroupSettings {
+}
+export declare namespace MultiplexGroupSettings {
+    
+    const filterSensitiveLog: (obj: MultiplexGroupSettings) => any;
+}
+export declare enum RtmpAdMarkers {
+    ON_CUE_POINT_SCTE35 = "ON_CUE_POINT_SCTE35"
+}
+export declare enum AuthenticationScheme {
+    AKAMAI = "AKAMAI",
+    COMMON = "COMMON"
+}
+export declare enum RtmpCacheFullBehavior {
+    DISCONNECT_IMMEDIATELY = "DISCONNECT_IMMEDIATELY",
+    WAIT_FOR_SERVER = "WAIT_FOR_SERVER"
+}
+export declare enum RtmpCaptionData {
+    ALL = "ALL",
+    FIELD1_608 = "FIELD1_608",
+    FIELD1_AND_FIELD2_608 = "FIELD1_AND_FIELD2_608"
+}
+export declare enum InputLossActionForRtmpOut {
+    EMIT_OUTPUT = "EMIT_OUTPUT",
+    PAUSE_OUTPUT = "PAUSE_OUTPUT"
+}
+
+export interface RtmpGroupSettings {
+    
+    AdMarkers?: (RtmpAdMarkers | string)[];
+    
+    AuthenticationScheme?: AuthenticationScheme | string;
+    
+    CacheFullBehavior?: RtmpCacheFullBehavior | string;
+    
+    CacheLength?: number;
+    
+    CaptionData?: RtmpCaptionData | string;
+    
+    InputLossAction?: InputLossActionForRtmpOut | string;
+    
+    RestartDelay?: number;
+}
+export declare namespace RtmpGroupSettings {
+    
+    const filterSensitiveLog: (obj: RtmpGroupSettings) => any;
+}
+export declare enum InputLossActionForUdpOut {
+    DROP_PROGRAM = "DROP_PROGRAM",
+    DROP_TS = "DROP_TS",
+    EMIT_PROGRAM = "EMIT_PROGRAM"
+}
+export declare enum UdpTimedMetadataId3Frame {
+    NONE = "NONE",
+    PRIV = "PRIV",
+    TDRL = "TDRL"
+}
+
+export interface UdpGroupSettings {
+    
+    InputLossAction?: InputLossActionForUdpOut | string;
+    
+    TimedMetadataId3Frame?: UdpTimedMetadataId3Frame | string;
+    
+    TimedMetadataId3Period?: number;
+}
+export declare namespace UdpGroupSettings {
+    
+    const filterSensitiveLog: (obj: UdpGroupSettings) => any;
+}
+
+export interface OutputGroupSettings {
+    
+    ArchiveGroupSettings?: ArchiveGroupSettings;
+    
+    FrameCaptureGroupSettings?: FrameCaptureGroupSettings;
+    
+    HlsGroupSettings?: HlsGroupSettings;
+    
+    MediaPackageGroupSettings?: MediaPackageGroupSettings;
+    
+    MsSmoothGroupSettings?: MsSmoothGroupSettings;
+    
+    MultiplexGroupSettings?: MultiplexGroupSettings;
+    
+    RtmpGroupSettings?: RtmpGroupSettings;
+    
+    UdpGroupSettings?: UdpGroupSettings;
+}
+export declare namespace OutputGroupSettings {
+    
+    const filterSensitiveLog: (obj: OutputGroupSettings) => any;
+}
+
+export interface OutputGroup {
+    
+    Name?: string;
+    
+    OutputGroupSettings: OutputGroupSettings | undefined;
+    
+    Outputs: Output[] | undefined;
+}
+export declare namespace OutputGroup {
+    
+    const filterSensitiveLog: (obj: OutputGroup) => any;
+}
+
+export interface PipelineDetail {
+    
+    ActiveInputAttachmentName?: string;
+    
+    ActiveInputSwitchActionName?: string;
+    
+    ActiveMotionGraphicsActionName?: string;
+    
+    ActiveMotionGraphicsUri?: string;
+    
+    PipelineId?: string;
+}
+export declare namespace PipelineDetail {
+    
+    const filterSensitiveLog: (obj: PipelineDetail) => any;
+}
+export declare enum PipelineId {
+    PIPELINE_0 = "PIPELINE_0",
+    PIPELINE_1 = "PIPELINE_1"
+}
+
+export interface PipelinePauseStateSettings {
+    
+    PipelineId: PipelineId | string | undefined;
+}
+export declare namespace PipelinePauseStateSettings {
+    
+    const filterSensitiveLog: (obj: PipelinePauseStateSettings) => any;
+}
+export declare enum ReservationState {
+    ACTIVE = "ACTIVE",
+    CANCELED = "CANCELED",
+    DELETED = "DELETED",
+    EXPIRED = "EXPIRED"
+}
+
+export interface Reservation {
+    
+    Arn?: string;
+    
+    Count?: number;
+    
+    CurrencyCode?: string;
+    
+    Duration?: number;
+    
+    DurationUnits?: OfferingDurationUnits | string;
+    
+    End?: string;
+    
+    FixedPrice?: number;
+    
+    Name?: string;
+    
+    OfferingDescription?: string;
+    
+    OfferingId?: string;
+    
+    OfferingType?: OfferingType | string;
+    
+    Region?: string;
+    
+    ReservationId?: string;
+    
+    ResourceSpecification?: ReservationResourceSpecification;
+    
+    Start?: string;
+    
+    State?: ReservationState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    UsagePrice?: number;
+}
+export declare namespace Reservation {
+    
+    const filterSensitiveLog: (obj: Reservation) => any;
+}
+
+export interface HlsId3SegmentTaggingScheduleActionSettings {
+    
+    Tag: string | undefined;
+}
+export declare namespace HlsId3SegmentTaggingScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: HlsId3SegmentTaggingScheduleActionSettings) => any;
+}
+
+export interface HlsTimedMetadataScheduleActionSettings {
+    
+    Id3: string | undefined;
+}
+export declare namespace HlsTimedMetadataScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: HlsTimedMetadataScheduleActionSettings) => any;
+}
+export declare enum InputTimecodeSource {
+    EMBEDDED = "EMBEDDED",
+    ZEROBASED = "ZEROBASED"
+}
+
+export interface StartTimecode {
+    
+    Timecode?: string;
+}
+export declare namespace StartTimecode {
+    
+    const filterSensitiveLog: (obj: StartTimecode) => any;
+}
+export declare enum LastFrameClippingBehavior {
+    EXCLUDE_LAST_FRAME = "EXCLUDE_LAST_FRAME",
+    INCLUDE_LAST_FRAME = "INCLUDE_LAST_FRAME"
+}
+
+export interface StopTimecode {
+    
+    LastFrameClippingBehavior?: LastFrameClippingBehavior | string;
+    
+    Timecode?: string;
+}
+export declare namespace StopTimecode {
+    
+    const filterSensitiveLog: (obj: StopTimecode) => any;
+}
+
+export interface InputClippingSettings {
+    
+    InputTimecodeSource: InputTimecodeSource | string | undefined;
+    
+    StartTimecode?: StartTimecode;
+    
+    StopTimecode?: StopTimecode;
+}
+export declare namespace InputClippingSettings {
+    
+    const filterSensitiveLog: (obj: InputClippingSettings) => any;
+}
+
+export interface InputPrepareScheduleActionSettings {
+    
+    InputAttachmentNameReference?: string;
+    
+    InputClippingSettings?: InputClippingSettings;
+    
+    UrlPath?: string[];
+}
+export declare namespace InputPrepareScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: InputPrepareScheduleActionSettings) => any;
+}
+
+export interface InputSwitchScheduleActionSettings {
+    
+    InputAttachmentNameReference: string | undefined;
+    
+    InputClippingSettings?: InputClippingSettings;
+    
+    UrlPath?: string[];
+}
+export declare namespace InputSwitchScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: InputSwitchScheduleActionSettings) => any;
+}
+
+export interface MotionGraphicsActivateScheduleActionSettings {
+    
+    Duration?: number;
+    
+    PasswordParam?: string;
+    
+    Url?: string;
+    
+    Username?: string;
+}
+export declare namespace MotionGraphicsActivateScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: MotionGraphicsActivateScheduleActionSettings) => any;
+}
+
+export interface MotionGraphicsDeactivateScheduleActionSettings {
+}
+export declare namespace MotionGraphicsDeactivateScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: MotionGraphicsDeactivateScheduleActionSettings) => any;
+}
+
+export interface PauseStateScheduleActionSettings {
+    
+    Pipelines?: PipelinePauseStateSettings[];
+}
+export declare namespace PauseStateScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: PauseStateScheduleActionSettings) => any;
+}
+
+export interface Scte35ReturnToNetworkScheduleActionSettings {
+    
+    SpliceEventId: number | undefined;
+}
+export declare namespace Scte35ReturnToNetworkScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: Scte35ReturnToNetworkScheduleActionSettings) => any;
+}
+
+export interface Scte35SpliceInsertScheduleActionSettings {
+    
+    Duration?: number;
+    
+    SpliceEventId: number | undefined;
+}
+export declare namespace Scte35SpliceInsertScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: Scte35SpliceInsertScheduleActionSettings) => any;
+}
+export declare enum Scte35ArchiveAllowedFlag {
+    ARCHIVE_ALLOWED = "ARCHIVE_ALLOWED",
+    ARCHIVE_NOT_ALLOWED = "ARCHIVE_NOT_ALLOWED"
+}
+export declare enum Scte35DeviceRestrictions {
+    NONE = "NONE",
+    RESTRICT_GROUP0 = "RESTRICT_GROUP0",
+    RESTRICT_GROUP1 = "RESTRICT_GROUP1",
+    RESTRICT_GROUP2 = "RESTRICT_GROUP2"
+}
+export declare enum Scte35NoRegionalBlackoutFlag {
+    NO_REGIONAL_BLACKOUT = "NO_REGIONAL_BLACKOUT",
+    REGIONAL_BLACKOUT = "REGIONAL_BLACKOUT"
+}
+export declare enum Scte35WebDeliveryAllowedFlag {
+    WEB_DELIVERY_ALLOWED = "WEB_DELIVERY_ALLOWED",
+    WEB_DELIVERY_NOT_ALLOWED = "WEB_DELIVERY_NOT_ALLOWED"
+}
+
+export interface Scte35DeliveryRestrictions {
+    
+    ArchiveAllowedFlag: Scte35ArchiveAllowedFlag | string | undefined;
+    
+    DeviceRestrictions: Scte35DeviceRestrictions | string | undefined;
+    
+    NoRegionalBlackoutFlag: Scte35NoRegionalBlackoutFlag | string | undefined;
+    
+    WebDeliveryAllowedFlag: Scte35WebDeliveryAllowedFlag | string | undefined;
+}
+export declare namespace Scte35DeliveryRestrictions {
+    
+    const filterSensitiveLog: (obj: Scte35DeliveryRestrictions) => any;
+}
+export declare enum Scte35SegmentationCancelIndicator {
+    SEGMENTATION_EVENT_CANCELED = "SEGMENTATION_EVENT_CANCELED",
+    SEGMENTATION_EVENT_NOT_CANCELED = "SEGMENTATION_EVENT_NOT_CANCELED"
+}
+
+export interface Scte35SegmentationDescriptor {
+    
+    DeliveryRestrictions?: Scte35DeliveryRestrictions;
+    
+    SegmentNum?: number;
+    
+    SegmentationCancelIndicator: Scte35SegmentationCancelIndicator | string | undefined;
+    
+    SegmentationDuration?: number;
+    
+    SegmentationEventId: number | undefined;
+    
+    SegmentationTypeId?: number;
+    
+    SegmentationUpid?: string;
+    
+    SegmentationUpidType?: number;
+    
+    SegmentsExpected?: number;
+    
+    SubSegmentNum?: number;
+    
+    SubSegmentsExpected?: number;
+}
+export declare namespace Scte35SegmentationDescriptor {
+    
+    const filterSensitiveLog: (obj: Scte35SegmentationDescriptor) => any;
+}
+
+export interface Scte35DescriptorSettings {
+    
+    SegmentationDescriptorScte35DescriptorSettings: Scte35SegmentationDescriptor | undefined;
+}
+export declare namespace Scte35DescriptorSettings {
+    
+    const filterSensitiveLog: (obj: Scte35DescriptorSettings) => any;
+}
+
+export interface Scte35Descriptor {
+    
+    Scte35DescriptorSettings: Scte35DescriptorSettings | undefined;
+}
+export declare namespace Scte35Descriptor {
+    
+    const filterSensitiveLog: (obj: Scte35Descriptor) => any;
+}
+
+export interface Scte35TimeSignalScheduleActionSettings {
+    
+    Scte35Descriptors: Scte35Descriptor[] | undefined;
+}
+export declare namespace Scte35TimeSignalScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: Scte35TimeSignalScheduleActionSettings) => any;
+}
+
+export interface StaticImageActivateScheduleActionSettings {
+    
+    Duration?: number;
+    
+    FadeIn?: number;
+    
+    FadeOut?: number;
+    
+    Height?: number;
+    
+    Image: InputLocation | undefined;
+    
+    ImageX?: number;
+    
+    ImageY?: number;
+    
+    Layer?: number;
+    
+    Opacity?: number;
+    
+    Width?: number;
+}
+export declare namespace StaticImageActivateScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: StaticImageActivateScheduleActionSettings) => any;
+}
+
+export interface StaticImageDeactivateScheduleActionSettings {
+    
+    FadeOut?: number;
+    
+    Layer?: number;
+}
+export declare namespace StaticImageDeactivateScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: StaticImageDeactivateScheduleActionSettings) => any;
+}
+
+export interface ScheduleActionSettings {
+    
+    HlsId3SegmentTaggingSettings?: HlsId3SegmentTaggingScheduleActionSettings;
+    
+    HlsTimedMetadataSettings?: HlsTimedMetadataScheduleActionSettings;
+    
+    InputPrepareSettings?: InputPrepareScheduleActionSettings;
+    
+    InputSwitchSettings?: InputSwitchScheduleActionSettings;
+    
+    MotionGraphicsImageActivateSettings?: MotionGraphicsActivateScheduleActionSettings;
+    
+    MotionGraphicsImageDeactivateSettings?: MotionGraphicsDeactivateScheduleActionSettings;
+    
+    PauseStateSettings?: PauseStateScheduleActionSettings;
+    
+    Scte35ReturnToNetworkSettings?: Scte35ReturnToNetworkScheduleActionSettings;
+    
+    Scte35SpliceInsertSettings?: Scte35SpliceInsertScheduleActionSettings;
+    
+    Scte35TimeSignalSettings?: Scte35TimeSignalScheduleActionSettings;
+    
+    StaticImageActivateSettings?: StaticImageActivateScheduleActionSettings;
+    
+    StaticImageDeactivateSettings?: StaticImageDeactivateScheduleActionSettings;
+}
+export declare namespace ScheduleActionSettings {
+    
+    const filterSensitiveLog: (obj: ScheduleActionSettings) => any;
+}
+
+export interface FixedModeScheduleActionStartSettings {
+    
+    Time: string | undefined;
+}
+export declare namespace FixedModeScheduleActionStartSettings {
+    
+    const filterSensitiveLog: (obj: FixedModeScheduleActionStartSettings) => any;
+}
+export declare enum FollowPoint {
+    END = "END",
+    START = "START"
+}
+
+export interface FollowModeScheduleActionStartSettings {
+    
+    FollowPoint: FollowPoint | string | undefined;
+    
+    ReferenceActionName: string | undefined;
+}
+export declare namespace FollowModeScheduleActionStartSettings {
+    
+    const filterSensitiveLog: (obj: FollowModeScheduleActionStartSettings) => any;
+}
+
+export interface ImmediateModeScheduleActionStartSettings {
+}
+export declare namespace ImmediateModeScheduleActionStartSettings {
+    
+    const filterSensitiveLog: (obj: ImmediateModeScheduleActionStartSettings) => any;
+}
+
+export interface ScheduleActionStartSettings {
+    
+    FixedModeScheduleActionStartSettings?: FixedModeScheduleActionStartSettings;
+    
+    FollowModeScheduleActionStartSettings?: FollowModeScheduleActionStartSettings;
+    
+    ImmediateModeScheduleActionStartSettings?: ImmediateModeScheduleActionStartSettings;
+}
+export declare namespace ScheduleActionStartSettings {
+    
+    const filterSensitiveLog: (obj: ScheduleActionStartSettings) => any;
+}
+
+export interface ScheduleAction {
+    
+    ActionName: string | undefined;
+    
+    ScheduleActionSettings: ScheduleActionSettings | undefined;
+    
+    ScheduleActionStartSettings: ScheduleActionStartSettings | undefined;
+}
+export declare namespace ScheduleAction {
+    
+    const filterSensitiveLog: (obj: ScheduleAction) => any;
+}
+export declare enum InputDeviceTransferType {
+    INCOMING = "INCOMING",
+    OUTGOING = "OUTGOING"
+}
+
+export interface TransferringInputDeviceSummary {
+    
+    Id?: string;
+    
+    Message?: string;
+    
+    TargetCustomerId?: string;
+    
+    TransferType?: InputDeviceTransferType | string;
+}
+export declare namespace TransferringInputDeviceSummary {
+    
+    const filterSensitiveLog: (obj: TransferringInputDeviceSummary) => any;
+}
+
+export interface ValidationError {
+    
+    ElementPath?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace ValidationError {
+    
+    const filterSensitiveLog: (obj: ValidationError) => any;
+}
+export declare enum FrameCaptureIntervalUnit {
+    MILLISECONDS = "MILLISECONDS",
+    SECONDS = "SECONDS"
+}
+
+export interface FrameCaptureSettings {
+    
+    CaptureInterval?: number;
+    
+    CaptureIntervalUnits?: FrameCaptureIntervalUnit | string;
+}
+export declare namespace FrameCaptureSettings {
+    
+    const filterSensitiveLog: (obj: FrameCaptureSettings) => any;
+}
+export declare enum H264AdaptiveQuantization {
+    AUTO = "AUTO",
+    HIGH = "HIGH",
+    HIGHER = "HIGHER",
+    LOW = "LOW",
+    MAX = "MAX",
+    MEDIUM = "MEDIUM",
+    OFF = "OFF"
+}
+export declare enum AfdSignaling {
+    AUTO = "AUTO",
+    FIXED = "FIXED",
+    NONE = "NONE"
+}
+export declare enum H264ColorMetadata {
+    IGNORE = "IGNORE",
+    INSERT = "INSERT"
+}
+
+export interface ColorSpacePassthroughSettings {
+}
+export declare namespace ColorSpacePassthroughSettings {
+    
+    const filterSensitiveLog: (obj: ColorSpacePassthroughSettings) => any;
+}
+
+export interface Rec601Settings {
+}
+export declare namespace Rec601Settings {
+    
+    const filterSensitiveLog: (obj: Rec601Settings) => any;
+}
+
+export interface Rec709Settings {
+}
+export declare namespace Rec709Settings {
+    
+    const filterSensitiveLog: (obj: Rec709Settings) => any;
+}
+
+export interface H264ColorSpaceSettings {
+    
+    ColorSpacePassthroughSettings?: ColorSpacePassthroughSettings;
+    
+    Rec601Settings?: Rec601Settings;
+    
+    Rec709Settings?: Rec709Settings;
+}
+export declare namespace H264ColorSpaceSettings {
+    
+    const filterSensitiveLog: (obj: H264ColorSpaceSettings) => any;
+}
+export declare enum H264EntropyEncoding {
+    CABAC = "CABAC",
+    CAVLC = "CAVLC"
+}
+export declare enum TemporalFilterPostFilterSharpening {
+    AUTO = "AUTO",
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum TemporalFilterStrength {
+    AUTO = "AUTO",
+    STRENGTH_1 = "STRENGTH_1",
+    STRENGTH_10 = "STRENGTH_10",
+    STRENGTH_11 = "STRENGTH_11",
+    STRENGTH_12 = "STRENGTH_12",
+    STRENGTH_13 = "STRENGTH_13",
+    STRENGTH_14 = "STRENGTH_14",
+    STRENGTH_15 = "STRENGTH_15",
+    STRENGTH_16 = "STRENGTH_16",
+    STRENGTH_2 = "STRENGTH_2",
+    STRENGTH_3 = "STRENGTH_3",
+    STRENGTH_4 = "STRENGTH_4",
+    STRENGTH_5 = "STRENGTH_5",
+    STRENGTH_6 = "STRENGTH_6",
+    STRENGTH_7 = "STRENGTH_7",
+    STRENGTH_8 = "STRENGTH_8",
+    STRENGTH_9 = "STRENGTH_9"
+}
+
+export interface TemporalFilterSettings {
+    
+    PostFilterSharpening?: TemporalFilterPostFilterSharpening | string;
+    
+    Strength?: TemporalFilterStrength | string;
+}
+export declare namespace TemporalFilterSettings {
+    
+    const filterSensitiveLog: (obj: TemporalFilterSettings) => any;
+}
+
+export interface H264FilterSettings {
+    
+    TemporalFilterSettings?: TemporalFilterSettings;
+}
+export declare namespace H264FilterSettings {
+    
+    const filterSensitiveLog: (obj: H264FilterSettings) => any;
+}
+export declare enum FixedAfd {
+    AFD_0000 = "AFD_0000",
+    AFD_0010 = "AFD_0010",
+    AFD_0011 = "AFD_0011",
+    AFD_0100 = "AFD_0100",
+    AFD_1000 = "AFD_1000",
+    AFD_1001 = "AFD_1001",
+    AFD_1010 = "AFD_1010",
+    AFD_1011 = "AFD_1011",
+    AFD_1101 = "AFD_1101",
+    AFD_1110 = "AFD_1110",
+    AFD_1111 = "AFD_1111"
+}
+export declare enum H264FlickerAq {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum H264ForceFieldPictures {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum H264FramerateControl {
+    INITIALIZE_FROM_SOURCE = "INITIALIZE_FROM_SOURCE",
+    SPECIFIED = "SPECIFIED"
+}
+export declare enum H264GopBReference {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum H264GopSizeUnits {
+    FRAMES = "FRAMES",
+    SECONDS = "SECONDS"
+}
+export declare enum H264Level {
+    H264_LEVEL_1 = "H264_LEVEL_1",
+    H264_LEVEL_1_1 = "H264_LEVEL_1_1",
+    H264_LEVEL_1_2 = "H264_LEVEL_1_2",
+    H264_LEVEL_1_3 = "H264_LEVEL_1_3",
+    H264_LEVEL_2 = "H264_LEVEL_2",
+    H264_LEVEL_2_1 = "H264_LEVEL_2_1",
+    H264_LEVEL_2_2 = "H264_LEVEL_2_2",
+    H264_LEVEL_3 = "H264_LEVEL_3",
+    H264_LEVEL_3_1 = "H264_LEVEL_3_1",
+    H264_LEVEL_3_2 = "H264_LEVEL_3_2",
+    H264_LEVEL_4 = "H264_LEVEL_4",
+    H264_LEVEL_4_1 = "H264_LEVEL_4_1",
+    H264_LEVEL_4_2 = "H264_LEVEL_4_2",
+    H264_LEVEL_5 = "H264_LEVEL_5",
+    H264_LEVEL_5_1 = "H264_LEVEL_5_1",
+    H264_LEVEL_5_2 = "H264_LEVEL_5_2",
+    H264_LEVEL_AUTO = "H264_LEVEL_AUTO"
+}
+export declare enum H264LookAheadRateControl {
+    HIGH = "HIGH",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM"
+}
+export declare enum H264ParControl {
+    INITIALIZE_FROM_SOURCE = "INITIALIZE_FROM_SOURCE",
+    SPECIFIED = "SPECIFIED"
+}
+export declare enum H264Profile {
+    BASELINE = "BASELINE",
+    HIGH = "HIGH",
+    HIGH_10BIT = "HIGH_10BIT",
+    HIGH_422 = "HIGH_422",
+    HIGH_422_10BIT = "HIGH_422_10BIT",
+    MAIN = "MAIN"
+}
+export declare enum H264QualityLevel {
+    ENHANCED_QUALITY = "ENHANCED_QUALITY",
+    STANDARD_QUALITY = "STANDARD_QUALITY"
+}
+export declare enum H264RateControlMode {
+    CBR = "CBR",
+    MULTIPLEX = "MULTIPLEX",
+    QVBR = "QVBR",
+    VBR = "VBR"
+}
+export declare enum H264ScanType {
+    INTERLACED = "INTERLACED",
+    PROGRESSIVE = "PROGRESSIVE"
+}
+export declare enum H264SceneChangeDetect {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum H264SpatialAq {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum H264SubGopLength {
+    DYNAMIC = "DYNAMIC",
+    FIXED = "FIXED"
+}
+export declare enum H264Syntax {
+    DEFAULT = "DEFAULT",
+    RP2027 = "RP2027"
+}
+export declare enum H264TemporalAq {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum H264TimecodeInsertionBehavior {
+    DISABLED = "DISABLED",
+    PIC_TIMING_SEI = "PIC_TIMING_SEI"
+}
+
+export interface H264Settings {
+    
+    AdaptiveQuantization?: H264AdaptiveQuantization | string;
+    
+    AfdSignaling?: AfdSignaling | string;
+    
+    Bitrate?: number;
+    
+    BufFillPct?: number;
+    
+    BufSize?: number;
+    
+    ColorMetadata?: H264ColorMetadata | string;
+    
+    ColorSpaceSettings?: H264ColorSpaceSettings;
+    
+    EntropyEncoding?: H264EntropyEncoding | string;
+    
+    FilterSettings?: H264FilterSettings;
+    
+    FixedAfd?: FixedAfd | string;
+    
+    FlickerAq?: H264FlickerAq | string;
+    
+    ForceFieldPictures?: H264ForceFieldPictures | string;
+    
+    FramerateControl?: H264FramerateControl | string;
+    
+    FramerateDenominator?: number;
+    
+    FramerateNumerator?: number;
+    
+    GopBReference?: H264GopBReference | string;
+    
+    GopClosedCadence?: number;
+    
+    GopNumBFrames?: number;
+    
+    GopSize?: number;
+    
+    GopSizeUnits?: H264GopSizeUnits | string;
+    
+    Level?: H264Level | string;
+    
+    LookAheadRateControl?: H264LookAheadRateControl | string;
+    
+    MaxBitrate?: number;
+    
+    MinIInterval?: number;
+    
+    NumRefFrames?: number;
+    
+    ParControl?: H264ParControl | string;
+    
+    ParDenominator?: number;
+    
+    ParNumerator?: number;
+    
+    Profile?: H264Profile | string;
+    
+    QualityLevel?: H264QualityLevel | string;
+    
+    QvbrQualityLevel?: number;
+    
+    RateControlMode?: H264RateControlMode | string;
+    
+    ScanType?: H264ScanType | string;
+    
+    SceneChangeDetect?: H264SceneChangeDetect | string;
+    
+    Slices?: number;
+    
+    Softness?: number;
+    
+    SpatialAq?: H264SpatialAq | string;
+    
+    SubgopLength?: H264SubGopLength | string;
+    
+    Syntax?: H264Syntax | string;
+    
+    TemporalAq?: H264TemporalAq | string;
+    
+    TimecodeInsertion?: H264TimecodeInsertionBehavior | string;
+}
+export declare namespace H264Settings {
+    
+    const filterSensitiveLog: (obj: H264Settings) => any;
+}
+export declare enum H265AdaptiveQuantization {
+    AUTO = "AUTO",
+    HIGH = "HIGH",
+    HIGHER = "HIGHER",
+    LOW = "LOW",
+    MAX = "MAX",
+    MEDIUM = "MEDIUM",
+    OFF = "OFF"
+}
+export declare enum H265AlternativeTransferFunction {
+    INSERT = "INSERT",
+    OMIT = "OMIT"
+}
+export declare enum H265ColorMetadata {
+    IGNORE = "IGNORE",
+    INSERT = "INSERT"
+}
+
+export interface H265ColorSpaceSettings {
+    
+    ColorSpacePassthroughSettings?: ColorSpacePassthroughSettings;
+    
+    Hdr10Settings?: Hdr10Settings;
+    
+    Rec601Settings?: Rec601Settings;
+    
+    Rec709Settings?: Rec709Settings;
+}
+export declare namespace H265ColorSpaceSettings {
+    
+    const filterSensitiveLog: (obj: H265ColorSpaceSettings) => any;
+}
+
+export interface H265FilterSettings {
+    
+    TemporalFilterSettings?: TemporalFilterSettings;
+}
+export declare namespace H265FilterSettings {
+    
+    const filterSensitiveLog: (obj: H265FilterSettings) => any;
+}
+export declare enum H265FlickerAq {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum H265GopSizeUnits {
+    FRAMES = "FRAMES",
+    SECONDS = "SECONDS"
+}
+export declare enum H265Level {
+    H265_LEVEL_1 = "H265_LEVEL_1",
+    H265_LEVEL_2 = "H265_LEVEL_2",
+    H265_LEVEL_2_1 = "H265_LEVEL_2_1",
+    H265_LEVEL_3 = "H265_LEVEL_3",
+    H265_LEVEL_3_1 = "H265_LEVEL_3_1",
+    H265_LEVEL_4 = "H265_LEVEL_4",
+    H265_LEVEL_4_1 = "H265_LEVEL_4_1",
+    H265_LEVEL_5 = "H265_LEVEL_5",
+    H265_LEVEL_5_1 = "H265_LEVEL_5_1",
+    H265_LEVEL_5_2 = "H265_LEVEL_5_2",
+    H265_LEVEL_6 = "H265_LEVEL_6",
+    H265_LEVEL_6_1 = "H265_LEVEL_6_1",
+    H265_LEVEL_6_2 = "H265_LEVEL_6_2",
+    H265_LEVEL_AUTO = "H265_LEVEL_AUTO"
+}
+export declare enum H265LookAheadRateControl {
+    HIGH = "HIGH",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM"
+}
+export declare enum H265Profile {
+    MAIN = "MAIN",
+    MAIN_10BIT = "MAIN_10BIT"
+}
+export declare enum H265RateControlMode {
+    CBR = "CBR",
+    MULTIPLEX = "MULTIPLEX",
+    QVBR = "QVBR"
+}
+export declare enum H265ScanType {
+    INTERLACED = "INTERLACED",
+    PROGRESSIVE = "PROGRESSIVE"
+}
+export declare enum H265SceneChangeDetect {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum H265Tier {
+    HIGH = "HIGH",
+    MAIN = "MAIN"
+}
+export declare enum H265TimecodeInsertionBehavior {
+    DISABLED = "DISABLED",
+    PIC_TIMING_SEI = "PIC_TIMING_SEI"
+}
+
+export interface H265Settings {
+    
+    AdaptiveQuantization?: H265AdaptiveQuantization | string;
+    
+    AfdSignaling?: AfdSignaling | string;
+    
+    AlternativeTransferFunction?: H265AlternativeTransferFunction | string;
+    
+    Bitrate?: number;
+    
+    BufSize?: number;
+    
+    ColorMetadata?: H265ColorMetadata | string;
+    
+    ColorSpaceSettings?: H265ColorSpaceSettings;
+    
+    FilterSettings?: H265FilterSettings;
+    
+    FixedAfd?: FixedAfd | string;
+    
+    FlickerAq?: H265FlickerAq | string;
+    
+    FramerateDenominator: number | undefined;
+    
+    FramerateNumerator: number | undefined;
+    
+    GopClosedCadence?: number;
+    
+    GopSize?: number;
+    
+    GopSizeUnits?: H265GopSizeUnits | string;
+    
+    Level?: H265Level | string;
+    
+    LookAheadRateControl?: H265LookAheadRateControl | string;
+    
+    MaxBitrate?: number;
+    
+    MinIInterval?: number;
+    
+    ParDenominator?: number;
+    
+    ParNumerator?: number;
+    
+    Profile?: H265Profile | string;
+    
+    QvbrQualityLevel?: number;
+    
+    RateControlMode?: H265RateControlMode | string;
+    
+    ScanType?: H265ScanType | string;
+    
+    SceneChangeDetect?: H265SceneChangeDetect | string;
+    
+    Slices?: number;
+    
+    Tier?: H265Tier | string;
+    
+    TimecodeInsertion?: H265TimecodeInsertionBehavior | string;
+}
+export declare namespace H265Settings {
+    
+    const filterSensitiveLog: (obj: H265Settings) => any;
+}
+export declare enum Mpeg2AdaptiveQuantization {
+    AUTO = "AUTO",
+    HIGH = "HIGH",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    OFF = "OFF"
+}
+export declare enum Mpeg2ColorMetadata {
+    IGNORE = "IGNORE",
+    INSERT = "INSERT"
+}
+export declare enum Mpeg2ColorSpace {
+    AUTO = "AUTO",
+    PASSTHROUGH = "PASSTHROUGH"
+}
+export declare enum Mpeg2DisplayRatio {
+    DISPLAYRATIO16X9 = "DISPLAYRATIO16X9",
+    DISPLAYRATIO4X3 = "DISPLAYRATIO4X3"
+}
+
+export interface Mpeg2FilterSettings {
+    
+    TemporalFilterSettings?: TemporalFilterSettings;
+}
+export declare namespace Mpeg2FilterSettings {
+    
+    const filterSensitiveLog: (obj: Mpeg2FilterSettings) => any;
+}
+export declare enum Mpeg2GopSizeUnits {
+    FRAMES = "FRAMES",
+    SECONDS = "SECONDS"
+}
+export declare enum Mpeg2ScanType {
+    INTERLACED = "INTERLACED",
+    PROGRESSIVE = "PROGRESSIVE"
+}
+export declare enum Mpeg2SubGopLength {
+    DYNAMIC = "DYNAMIC",
+    FIXED = "FIXED"
+}
+export declare enum Mpeg2TimecodeInsertionBehavior {
+    DISABLED = "DISABLED",
+    GOP_TIMECODE = "GOP_TIMECODE"
+}
+
+export interface Mpeg2Settings {
+    
+    AdaptiveQuantization?: Mpeg2AdaptiveQuantization | string;
+    
+    AfdSignaling?: AfdSignaling | string;
+    
+    ColorMetadata?: Mpeg2ColorMetadata | string;
+    
+    ColorSpace?: Mpeg2ColorSpace | string;
+    
+    DisplayAspectRatio?: Mpeg2DisplayRatio | string;
+    
+    FilterSettings?: Mpeg2FilterSettings;
+    
+    FixedAfd?: FixedAfd | string;
+    
+    FramerateDenominator: number | undefined;
+    
+    FramerateNumerator: number | undefined;
+    
+    GopClosedCadence?: number;
+    
+    GopNumBFrames?: number;
+    
+    GopSize?: number;
+    
+    GopSizeUnits?: Mpeg2GopSizeUnits | string;
+    
+    ScanType?: Mpeg2ScanType | string;
+    
+    SubgopLength?: Mpeg2SubGopLength | string;
+    
+    TimecodeInsertion?: Mpeg2TimecodeInsertionBehavior | string;
+}
+export declare namespace Mpeg2Settings {
+    
+    const filterSensitiveLog: (obj: Mpeg2Settings) => any;
+}
+
+export interface VideoCodecSettings {
+    
+    FrameCaptureSettings?: FrameCaptureSettings;
+    
+    H264Settings?: H264Settings;
+    
+    H265Settings?: H265Settings;
+    
+    Mpeg2Settings?: Mpeg2Settings;
+}
+export declare namespace VideoCodecSettings {
+    
+    const filterSensitiveLog: (obj: VideoCodecSettings) => any;
+}
+export declare enum VideoDescriptionRespondToAfd {
+    NONE = "NONE",
+    PASSTHROUGH = "PASSTHROUGH",
+    RESPOND = "RESPOND"
+}
+export declare enum VideoDescriptionScalingBehavior {
+    DEFAULT = "DEFAULT",
+    STRETCH_TO_OUTPUT = "STRETCH_TO_OUTPUT"
+}
+
+export interface VideoDescription {
+    
+    CodecSettings?: VideoCodecSettings;
+    
+    Height?: number;
+    
+    Name: string | undefined;
+    
+    RespondToAfd?: VideoDescriptionRespondToAfd | string;
+    
+    ScalingBehavior?: VideoDescriptionScalingBehavior | string;
+    
+    Sharpness?: number;
+    
+    Width?: number;
+}
+export declare namespace VideoDescription {
+    
+    const filterSensitiveLog: (obj: VideoDescription) => any;
+}
+export declare enum AcceptHeader {
+    image_jpeg = "image/jpeg"
+}
+
+export interface AcceptInputDeviceTransferRequest {
+    
+    InputDeviceId: string | undefined;
+}
+export declare namespace AcceptInputDeviceTransferRequest {
+    
+    const filterSensitiveLog: (obj: AcceptInputDeviceTransferRequest) => any;
+}
+
+export interface AcceptInputDeviceTransferResponse {
+}
+export declare namespace AcceptInputDeviceTransferResponse {
+    
+    const filterSensitiveLog: (obj: AcceptInputDeviceTransferResponse) => any;
+}
+
+export declare class BadGatewayException extends __BaseException {
+    readonly name: "BadGatewayException";
+    readonly $fault: "server";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<BadGatewayException, __BaseException>);
+}
+
+export declare class BadRequestException extends __BaseException {
+    readonly name: "BadRequestException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+
+export declare class GatewayTimeoutException extends __BaseException {
+    readonly name: "GatewayTimeoutException";
+    readonly $fault: "server";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<GatewayTimeoutException, __BaseException>);
+}
+
+export declare class InternalServerErrorException extends __BaseException {
+    readonly name: "InternalServerErrorException";
+    readonly $fault: "server";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerErrorException, __BaseException>);
+}
+
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
+
+export declare class TooManyRequestsException extends __BaseException {
+    readonly name: "TooManyRequestsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>);
+}
+
+export declare class UnprocessableEntityException extends __BaseException {
+    readonly name: "UnprocessableEntityException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    ValidationErrors?: ValidationError[];
+    
+    constructor(opts: __ExceptionOptionType<UnprocessableEntityException, __BaseException>);
+}
+export declare enum AvailBlankingState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface AvailBlanking {
+    
+    AvailBlankingImage?: InputLocation;
+    
+    State?: AvailBlankingState | string;
+}
+export declare namespace AvailBlanking {
+    
+    const filterSensitiveLog: (obj: AvailBlanking) => any;
+}
+export declare enum Scte35SpliceInsertNoRegionalBlackoutBehavior {
+    FOLLOW = "FOLLOW",
+    IGNORE = "IGNORE"
+}
+export declare enum Scte35SpliceInsertWebDeliveryAllowedBehavior {
+    FOLLOW = "FOLLOW",
+    IGNORE = "IGNORE"
+}
+
+export interface Scte35SpliceInsert {
+    
+    AdAvailOffset?: number;
+    
+    NoRegionalBlackoutFlag?: Scte35SpliceInsertNoRegionalBlackoutBehavior | string;
+    
+    WebDeliveryAllowedFlag?: Scte35SpliceInsertWebDeliveryAllowedBehavior | string;
+}
+export declare namespace Scte35SpliceInsert {
+    
+    const filterSensitiveLog: (obj: Scte35SpliceInsert) => any;
+}
+export declare enum Scte35AposNoRegionalBlackoutBehavior {
+    FOLLOW = "FOLLOW",
+    IGNORE = "IGNORE"
+}
+export declare enum Scte35AposWebDeliveryAllowedBehavior {
+    FOLLOW = "FOLLOW",
+    IGNORE = "IGNORE"
+}
+
+export interface Scte35TimeSignalApos {
+    
+    AdAvailOffset?: number;
+    
+    NoRegionalBlackoutFlag?: Scte35AposNoRegionalBlackoutBehavior | string;
+    
+    WebDeliveryAllowedFlag?: Scte35AposWebDeliveryAllowedBehavior | string;
+}
+export declare namespace Scte35TimeSignalApos {
+    
+    const filterSensitiveLog: (obj: Scte35TimeSignalApos) => any;
+}
+
+export interface AvailSettings {
+    
+    Scte35SpliceInsert?: Scte35SpliceInsert;
+    
+    Scte35TimeSignalApos?: Scte35TimeSignalApos;
+}
+export declare namespace AvailSettings {
+    
+    const filterSensitiveLog: (obj: AvailSettings) => any;
+}
+
+export interface AvailConfiguration {
+    
+    AvailSettings?: AvailSettings;
+}
+export declare namespace AvailConfiguration {
+    
+    const filterSensitiveLog: (obj: AvailConfiguration) => any;
+}
+
+export interface BatchDeleteRequest {
+    
+    ChannelIds?: string[];
+    
+    InputIds?: string[];
+    
+    InputSecurityGroupIds?: string[];
+    
+    MultiplexIds?: string[];
+}
+export declare namespace BatchDeleteRequest {
+    
+    const filterSensitiveLog: (obj: BatchDeleteRequest) => any;
+}
+
+export interface BatchDeleteResponse {
+    
+    Failed?: BatchFailedResultModel[];
+    
+    Successful?: BatchSuccessfulResultModel[];
+}
+export declare namespace BatchDeleteResponse {
+    
+    const filterSensitiveLog: (obj: BatchDeleteResponse) => any;
+}
+
+export interface BatchScheduleActionCreateRequest {
+    
+    ScheduleActions: ScheduleAction[] | undefined;
+}
+export declare namespace BatchScheduleActionCreateRequest {
+    
+    const filterSensitiveLog: (obj: BatchScheduleActionCreateRequest) => any;
+}
+
+export interface BatchScheduleActionCreateResult {
+    
+    ScheduleActions: ScheduleAction[] | undefined;
+}
+export declare namespace BatchScheduleActionCreateResult {
+    
+    const filterSensitiveLog: (obj: BatchScheduleActionCreateResult) => any;
+}
+
+export interface BatchScheduleActionDeleteRequest {
+    
+    ActionNames: string[] | undefined;
+}
+export declare namespace BatchScheduleActionDeleteRequest {
+    
+    const filterSensitiveLog: (obj: BatchScheduleActionDeleteRequest) => any;
+}
+
+export interface BatchScheduleActionDeleteResult {
+    
+    ScheduleActions: ScheduleAction[] | undefined;
+}
+export declare namespace BatchScheduleActionDeleteResult {
+    
+    const filterSensitiveLog: (obj: BatchScheduleActionDeleteResult) => any;
+}
+
+export interface BatchStartRequest {
+    
+    ChannelIds?: string[];
+    
+    MultiplexIds?: string[];
+}
+export declare namespace BatchStartRequest {
+    
+    const filterSensitiveLog: (obj: BatchStartRequest) => any;
+}
+
+export interface BatchStartResponse {
+    
+    Failed?: BatchFailedResultModel[];
+    
+    Successful?: BatchSuccessfulResultModel[];
+}
+export declare namespace BatchStartResponse {
+    
+    const filterSensitiveLog: (obj: BatchStartResponse) => any;
+}
+
+export interface BatchStopRequest {
+    
+    ChannelIds?: string[];
+    
+    MultiplexIds?: string[];
+}
+export declare namespace BatchStopRequest {
+    
+    const filterSensitiveLog: (obj: BatchStopRequest) => any;
+}
+
+export interface BatchStopResponse {
+    
+    Failed?: BatchFailedResultModel[];
+    
+    Successful?: BatchSuccessfulResultModel[];
+}
+export declare namespace BatchStopResponse {
+    
+    const filterSensitiveLog: (obj: BatchStopResponse) => any;
+}
+
+export interface BatchUpdateScheduleRequest {
+    
+    ChannelId: string | undefined;
+    
+    Creates?: BatchScheduleActionCreateRequest;
+    
+    Deletes?: BatchScheduleActionDeleteRequest;
+}
+export declare namespace BatchUpdateScheduleRequest {
+    
+    const filterSensitiveLog: (obj: BatchUpdateScheduleRequest) => any;
+}
+
+export interface BatchUpdateScheduleResponse {
+    
+    Creates?: BatchScheduleActionCreateResult;
+    
+    Deletes?: BatchScheduleActionDeleteResult;
+}
+export declare namespace BatchUpdateScheduleResponse {
+    
+    const filterSensitiveLog: (obj: BatchUpdateScheduleResponse) => any;
+}
+export declare enum BlackoutSlateNetworkEndBlackout {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum BlackoutSlateState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface BlackoutSlate {
+    
+    BlackoutSlateImage?: InputLocation;
+    
+    NetworkEndBlackout?: BlackoutSlateNetworkEndBlackout | string;
+    
+    NetworkEndBlackoutImage?: InputLocation;
+    
+    NetworkId?: string;
+    
+    State?: BlackoutSlateState | string;
+}
+export declare namespace BlackoutSlate {
+    
+    const filterSensitiveLog: (obj: BlackoutSlate) => any;
+}
+
+export interface CancelInputDeviceTransferRequest {
+    
+    InputDeviceId: string | undefined;
+}
+export declare namespace CancelInputDeviceTransferRequest {
+    
+    const filterSensitiveLog: (obj: CancelInputDeviceTransferRequest) => any;
+}
+
+export interface CancelInputDeviceTransferResponse {
+}
+export declare namespace CancelInputDeviceTransferResponse {
+    
+    const filterSensitiveLog: (obj: CancelInputDeviceTransferResponse) => any;
+}
+export declare enum FeatureActivationsInputPrepareScheduleActions {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface FeatureActivations {
+    
+    InputPrepareScheduleActions?: FeatureActivationsInputPrepareScheduleActions | string;
+}
+export declare namespace FeatureActivations {
+    
+    const filterSensitiveLog: (obj: FeatureActivations) => any;
+}
+export declare enum GlobalConfigurationInputEndAction {
+    NONE = "NONE",
+    SWITCH_AND_LOOP_INPUTS = "SWITCH_AND_LOOP_INPUTS"
+}
+export declare enum InputLossImageType {
+    COLOR = "COLOR",
+    SLATE = "SLATE"
+}
+
+export interface InputLossBehavior {
+    
+    BlackFrameMsec?: number;
+    
+    InputLossImageColor?: string;
+    
+    InputLossImageSlate?: InputLocation;
+    
+    InputLossImageType?: InputLossImageType | string;
+    
+    RepeatFrameMsec?: number;
+}
+export declare namespace InputLossBehavior {
+    
+    const filterSensitiveLog: (obj: InputLossBehavior) => any;
+}
+export declare enum GlobalConfigurationOutputLockingMode {
+    EPOCH_LOCKING = "EPOCH_LOCKING",
+    PIPELINE_LOCKING = "PIPELINE_LOCKING"
+}
+export declare enum GlobalConfigurationOutputTimingSource {
+    INPUT_CLOCK = "INPUT_CLOCK",
+    SYSTEM_CLOCK = "SYSTEM_CLOCK"
+}
+export declare enum GlobalConfigurationLowFramerateInputs {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface GlobalConfiguration {
+    
+    InitialAudioGain?: number;
+    
+    InputEndAction?: GlobalConfigurationInputEndAction | string;
+    
+    InputLossBehavior?: InputLossBehavior;
+    
+    OutputLockingMode?: GlobalConfigurationOutputLockingMode | string;
+    
+    OutputTimingSource?: GlobalConfigurationOutputTimingSource | string;
+    
+    SupportLowFramerateInputs?: GlobalConfigurationLowFramerateInputs | string;
+}
+export declare namespace GlobalConfiguration {
+    
+    const filterSensitiveLog: (obj: GlobalConfiguration) => any;
+}
+export declare enum MotionGraphicsInsertion {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface HtmlMotionGraphicsSettings {
+}
+export declare namespace HtmlMotionGraphicsSettings {
+    
+    const filterSensitiveLog: (obj: HtmlMotionGraphicsSettings) => any;
+}
+
+export interface MotionGraphicsSettings {
+    
+    HtmlMotionGraphicsSettings?: HtmlMotionGraphicsSettings;
+}
+export declare namespace MotionGraphicsSettings {
+    
+    const filterSensitiveLog: (obj: MotionGraphicsSettings) => any;
+}
+
+export interface MotionGraphicsConfiguration {
+    
+    MotionGraphicsInsertion?: MotionGraphicsInsertion | string;
+    
+    MotionGraphicsSettings: MotionGraphicsSettings | undefined;
+}
+export declare namespace MotionGraphicsConfiguration {
+    
+    const filterSensitiveLog: (obj: MotionGraphicsConfiguration) => any;
+}
+export declare enum NielsenPcmToId3TaggingState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface NielsenConfiguration {
+    
+    DistributorId?: string;
+    
+    NielsenPcmToId3Tagging?: NielsenPcmToId3TaggingState | string;
+}
+export declare namespace NielsenConfiguration {
+    
+    const filterSensitiveLog: (obj: NielsenConfiguration) => any;
+}
+export declare enum TimecodeConfigSource {
+    EMBEDDED = "EMBEDDED",
+    SYSTEMCLOCK = "SYSTEMCLOCK",
+    ZEROBASED = "ZEROBASED"
+}
+
+export interface TimecodeConfig {
+    
+    Source: TimecodeConfigSource | string | undefined;
+    
+    SyncThreshold?: number;
+}
+export declare namespace TimecodeConfig {
+    
+    const filterSensitiveLog: (obj: TimecodeConfig) => any;
+}
+
+export interface EncoderSettings {
+    
+    AudioDescriptions: AudioDescription[] | undefined;
+    
+    AvailBlanking?: AvailBlanking;
+    
+    AvailConfiguration?: AvailConfiguration;
+    
+    BlackoutSlate?: BlackoutSlate;
+    
+    CaptionDescriptions?: CaptionDescription[];
+    
+    FeatureActivations?: FeatureActivations;
+    
+    GlobalConfiguration?: GlobalConfiguration;
+    
+    MotionGraphicsConfiguration?: MotionGraphicsConfiguration;
+    
+    NielsenConfiguration?: NielsenConfiguration;
+    
+    OutputGroups: OutputGroup[] | undefined;
+    
+    TimecodeConfig: TimecodeConfig | undefined;
+    
+    VideoDescriptions: VideoDescription[] | undefined;
+}
+export declare namespace EncoderSettings {
+    
+    const filterSensitiveLog: (obj: EncoderSettings) => any;
+}
+
+export interface Channel {
+    
+    Arn?: string;
+    
+    CdiInputSpecification?: CdiInputSpecification;
+    
+    ChannelClass?: ChannelClass | string;
+    
+    Destinations?: OutputDestination[];
+    
+    EgressEndpoints?: ChannelEgressEndpoint[];
+    
+    EncoderSettings?: EncoderSettings;
+    
+    Id?: string;
+    
+    InputAttachments?: InputAttachment[];
+    
+    InputSpecification?: InputSpecification;
+    
+    LogLevel?: LogLevel | string;
+    
+    Name?: string;
+    
+    PipelineDetails?: PipelineDetail[];
+    
+    PipelinesRunningCount?: number;
+    
+    RoleArn?: string;
+    
+    State?: ChannelState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Vpc?: VpcOutputSettingsDescription;
+}
+export declare namespace Channel {
+    
+    const filterSensitiveLog: (obj: Channel) => any;
+}
+
+export interface ClaimDeviceRequest {
+    
+    Id?: string;
+}
+export declare namespace ClaimDeviceRequest {
+    
+    const filterSensitiveLog: (obj: ClaimDeviceRequest) => any;
+}
+
+export interface ClaimDeviceResponse {
+}
+export declare namespace ClaimDeviceResponse {
+    
+    const filterSensitiveLog: (obj: ClaimDeviceResponse) => any;
+}
+export declare enum ContentType {
+    image_jpeg = "image/jpeg"
+}
+
+export interface VpcOutputSettings {
+    
+    PublicAddressAllocationIds?: string[];
+    
+    SecurityGroupIds?: string[];
+    
+    SubnetIds: string[] | undefined;
+}
+export declare namespace VpcOutputSettings {
+    
+    const filterSensitiveLog: (obj: VpcOutputSettings) => any;
+}
+
+export interface CreateChannelRequest {
+    
+    CdiInputSpecification?: CdiInputSpecification;
+    
+    ChannelClass?: ChannelClass | string;
+    
+    Destinations?: OutputDestination[];
+    
+    EncoderSettings?: EncoderSettings;
+    
+    InputAttachments?: InputAttachment[];
+    
+    InputSpecification?: InputSpecification;
+    
+    LogLevel?: LogLevel | string;
+    
+    Name?: string;
+    
+    RequestId?: string;
+    
+    Reserved?: string;
+    
+    RoleArn?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Vpc?: VpcOutputSettings;
+}
+export declare namespace CreateChannelRequest {
+    
+    const filterSensitiveLog: (obj: CreateChannelRequest) => any;
+}
+
+export interface CreateChannelResponse {
+    
+    Channel?: Channel;
+}
+export declare namespace CreateChannelResponse {
+    
+    const filterSensitiveLog: (obj: CreateChannelResponse) => any;
+}
+
+export interface InputVpcRequest {
+    
+    SecurityGroupIds?: string[];
+    
+    SubnetIds: string[] | undefined;
+}
+export declare namespace InputVpcRequest {
+    
+    const filterSensitiveLog: (obj: InputVpcRequest) => any;
+}
+
+export interface CreateInputRequest {
+    
+    Destinations?: InputDestinationRequest[];
+    
+    InputDevices?: InputDeviceSettings[];
+    
+    InputSecurityGroups?: string[];
+    
+    MediaConnectFlows?: MediaConnectFlowRequest[];
+    
+    Name?: string;
+    
+    RequestId?: string;
+    
+    RoleArn?: string;
+    
+    Sources?: InputSourceRequest[];
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Type?: InputType | string;
+    
+    Vpc?: InputVpcRequest;
+}
+export declare namespace CreateInputRequest {
+    
+    const filterSensitiveLog: (obj: CreateInputRequest) => any;
+}
+
+export interface CreateInputResponse {
+    
+    Input?: Input;
+}
+export declare namespace CreateInputResponse {
+    
+    const filterSensitiveLog: (obj: CreateInputResponse) => any;
+}
+
+export interface CreateInputSecurityGroupRequest {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    WhitelistRules?: InputWhitelistRuleCidr[];
+}
+export declare namespace CreateInputSecurityGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateInputSecurityGroupRequest) => any;
+}
+
+export interface CreateInputSecurityGroupResponse {
+    
+    SecurityGroup?: InputSecurityGroup;
+}
+export declare namespace CreateInputSecurityGroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateInputSecurityGroupResponse) => any;
+}
+
+export interface MultiplexSettings {
+    
+    MaximumVideoBufferDelayMilliseconds?: number;
+    
+    TransportStreamBitrate: number | undefined;
+    
+    TransportStreamId: number | undefined;
+    
+    TransportStreamReservedBitrate?: number;
+}
+export declare namespace MultiplexSettings {
+    
+    const filterSensitiveLog: (obj: MultiplexSettings) => any;
+}
+
+export interface CreateMultiplexRequest {
+    
+    AvailabilityZones: string[] | undefined;
+    
+    MultiplexSettings: MultiplexSettings | undefined;
+    
+    Name: string | undefined;
+    
+    RequestId?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateMultiplexRequest {
+    
+    const filterSensitiveLog: (obj: CreateMultiplexRequest) => any;
+}
+
+export interface Multiplex {
+    
+    Arn?: string;
+    
+    AvailabilityZones?: string[];
+    
+    Destinations?: MultiplexOutputDestination[];
+    
+    Id?: string;
+    
+    MultiplexSettings?: MultiplexSettings;
+    
+    Name?: string;
+    
+    PipelinesRunningCount?: number;
+    
+    ProgramCount?: number;
+    
+    State?: MultiplexState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Multiplex {
+    
+    const filterSensitiveLog: (obj: Multiplex) => any;
+}
+
+export interface CreateMultiplexResponse {
+    
+    Multiplex?: Multiplex;
+}
+export declare namespace CreateMultiplexResponse {
+    
+    const filterSensitiveLog: (obj: CreateMultiplexResponse) => any;
+}
+export declare enum PreferredChannelPipeline {
+    CURRENTLY_ACTIVE = "CURRENTLY_ACTIVE",
+    PIPELINE_0 = "PIPELINE_0",
+    PIPELINE_1 = "PIPELINE_1"
+}
+
+export interface MultiplexProgramServiceDescriptor {
+    
+    ProviderName: string | undefined;
+    
+    ServiceName: string | undefined;
+}
+export declare namespace MultiplexProgramServiceDescriptor {
+    
+    const filterSensitiveLog: (obj: MultiplexProgramServiceDescriptor) => any;
+}
+
+export interface MultiplexStatmuxVideoSettings {
+    
+    MaximumBitrate?: number;
+    
+    MinimumBitrate?: number;
+    
+    Priority?: number;
+}
+export declare namespace MultiplexStatmuxVideoSettings {
+    
+    const filterSensitiveLog: (obj: MultiplexStatmuxVideoSettings) => any;
+}
+
+export interface MultiplexVideoSettings {
+    
+    ConstantBitrate?: number;
+    
+    StatmuxSettings?: MultiplexStatmuxVideoSettings;
+}
+export declare namespace MultiplexVideoSettings {
+    
+    const filterSensitiveLog: (obj: MultiplexVideoSettings) => any;
+}
+
+export interface MultiplexProgramSettings {
+    
+    PreferredChannelPipeline?: PreferredChannelPipeline | string;
+    
+    ProgramNumber: number | undefined;
+    
+    ServiceDescriptor?: MultiplexProgramServiceDescriptor;
+    
+    VideoSettings?: MultiplexVideoSettings;
+}
+export declare namespace MultiplexProgramSettings {
+    
+    const filterSensitiveLog: (obj: MultiplexProgramSettings) => any;
+}
+
+export interface CreateMultiplexProgramRequest {
+    
+    MultiplexId: string | undefined;
+    
+    MultiplexProgramSettings: MultiplexProgramSettings | undefined;
+    
+    ProgramName: string | undefined;
+    
+    RequestId?: string;
+}
+export declare namespace CreateMultiplexProgramRequest {
+    
+    const filterSensitiveLog: (obj: CreateMultiplexProgramRequest) => any;
+}
+
+export interface MultiplexProgramPacketIdentifiersMap {
+    
+    AudioPids?: number[];
+    
+    DvbSubPids?: number[];
+    
+    DvbTeletextPid?: number;
+    
+    EtvPlatformPid?: number;
+    
+    EtvSignalPid?: number;
+    
+    KlvDataPids?: number[];
+    
+    PcrPid?: number;
+    
+    PmtPid?: number;
+    
+    PrivateMetadataPid?: number;
+    
+    Scte27Pids?: number[];
+    
+    Scte35Pid?: number;
+    
+    TimedMetadataPid?: number;
+    
+    VideoPid?: number;
+}
+export declare namespace MultiplexProgramPacketIdentifiersMap {
+    
+    const filterSensitiveLog: (obj: MultiplexProgramPacketIdentifiersMap) => any;
+}
+
+export interface MultiplexProgram {
+    
+    ChannelId?: string;
+    
+    MultiplexProgramSettings?: MultiplexProgramSettings;
+    
+    PacketIdentifiersMap?: MultiplexProgramPacketIdentifiersMap;
+    
+    PipelineDetails?: MultiplexProgramPipelineDetail[];
+    
+    ProgramName?: string;
+}
+export declare namespace MultiplexProgram {
+    
+    const filterSensitiveLog: (obj: MultiplexProgram) => any;
+}
+
+export interface CreateMultiplexProgramResponse {
+    
+    MultiplexProgram?: MultiplexProgram;
+}
+export declare namespace CreateMultiplexProgramResponse {
+    
+    const filterSensitiveLog: (obj: CreateMultiplexProgramResponse) => any;
+}
+
+export interface CreatePartnerInputRequest {
+    
+    InputId: string | undefined;
+    
+    RequestId?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreatePartnerInputRequest {
+    
+    const filterSensitiveLog: (obj: CreatePartnerInputRequest) => any;
+}
+
+export interface CreatePartnerInputResponse {
+    
+    Input?: Input;
+}
+export declare namespace CreatePartnerInputResponse {
+    
+    const filterSensitiveLog: (obj: CreatePartnerInputResponse) => any;
+}
+
+export interface CreateTagsRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateTagsRequest {
+    
+    const filterSensitiveLog: (obj: CreateTagsRequest) => any;
+}
+
+export interface DeleteChannelRequest {
+    
+    ChannelId: string | undefined;
+}
+export declare namespace DeleteChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelRequest) => any;
+}
+
+export interface DeleteChannelResponse {
+    
+    Arn?: string;
+    
+    CdiInputSpecification?: CdiInputSpecification;
+    
+    ChannelClass?: ChannelClass | string;
+    
+    Destinations?: OutputDestination[];
+    
+    EgressEndpoints?: ChannelEgressEndpoint[];
+    
+    EncoderSettings?: EncoderSettings;
+    
+    Id?: string;
+    
+    InputAttachments?: InputAttachment[];
+    
+    InputSpecification?: InputSpecification;
+    
+    LogLevel?: LogLevel | string;
+    
+    Name?: string;
+    
+    PipelineDetails?: PipelineDetail[];
+    
+    PipelinesRunningCount?: number;
+    
+    RoleArn?: string;
+    
+    State?: ChannelState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Vpc?: VpcOutputSettingsDescription;
+}
+export declare namespace DeleteChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteChannelResponse) => any;
+}
+
+export interface DeleteInputRequest {
+    
+    InputId: string | undefined;
+}
+export declare namespace DeleteInputRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInputRequest) => any;
+}
+
+export interface DeleteInputResponse {
+}
+export declare namespace DeleteInputResponse {
+    
+    const filterSensitiveLog: (obj: DeleteInputResponse) => any;
+}
+
+export interface DeleteInputSecurityGroupRequest {
+    
+    InputSecurityGroupId: string | undefined;
+}
+export declare namespace DeleteInputSecurityGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInputSecurityGroupRequest) => any;
+}
+
+export interface DeleteInputSecurityGroupResponse {
+}
+export declare namespace DeleteInputSecurityGroupResponse {
+    
+    const filterSensitiveLog: (obj: DeleteInputSecurityGroupResponse) => any;
+}
+
+export interface DeleteMultiplexRequest {
+    
+    MultiplexId: string | undefined;
+}
+export declare namespace DeleteMultiplexRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMultiplexRequest) => any;
+}
+
+export interface DeleteMultiplexResponse {
+    
+    Arn?: string;
+    
+    AvailabilityZones?: string[];
+    
+    Destinations?: MultiplexOutputDestination[];
+    
+    Id?: string;
+    
+    MultiplexSettings?: MultiplexSettings;
+    
+    Name?: string;
+    
+    PipelinesRunningCount?: number;
+    
+    ProgramCount?: number;
+    
+    State?: MultiplexState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DeleteMultiplexResponse {
+    
+    const filterSensitiveLog: (obj: DeleteMultiplexResponse) => any;
+}
+
+export interface DeleteMultiplexProgramRequest {
+    
+    MultiplexId: string | undefined;
+    
+    ProgramName: string | undefined;
+}
+export declare namespace DeleteMultiplexProgramRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMultiplexProgramRequest) => any;
+}
+
+export interface DeleteMultiplexProgramResponse {
+    
+    ChannelId?: string;
+    
+    MultiplexProgramSettings?: MultiplexProgramSettings;
+    
+    PacketIdentifiersMap?: MultiplexProgramPacketIdentifiersMap;
+    
+    PipelineDetails?: MultiplexProgramPipelineDetail[];
+    
+    ProgramName?: string;
+}
+export declare namespace DeleteMultiplexProgramResponse {
+    
+    const filterSensitiveLog: (obj: DeleteMultiplexProgramResponse) => any;
+}
+
+export interface DeleteReservationRequest {
+    
+    ReservationId: string | undefined;
+}
+export declare namespace DeleteReservationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteReservationRequest) => any;
+}
+
+export interface DeleteReservationResponse {
+    
+    Arn?: string;
+    
+    Count?: number;
+    
+    CurrencyCode?: string;
+    
+    Duration?: number;
+    
+    DurationUnits?: OfferingDurationUnits | string;
+    
+    End?: string;
+    
+    FixedPrice?: number;
+    
+    Name?: string;
+    
+    OfferingDescription?: string;
+    
+    OfferingId?: string;
+    
+    OfferingType?: OfferingType | string;
+    
+    Region?: string;
+    
+    ReservationId?: string;
+    
+    ResourceSpecification?: ReservationResourceSpecification;
+    
+    Start?: string;
+    
+    State?: ReservationState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    UsagePrice?: number;
+}
+export declare namespace DeleteReservationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteReservationResponse) => any;
+}
+
+export interface DeleteScheduleRequest {
+    
+    ChannelId: string | undefined;
+}
+export declare namespace DeleteScheduleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteScheduleRequest) => any;
+}
+
+export interface DeleteScheduleResponse {
+}
+export declare namespace DeleteScheduleResponse {
+    
+    const filterSensitiveLog: (obj: DeleteScheduleResponse) => any;
+}
+
+export interface DeleteTagsRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace DeleteTagsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTagsRequest) => any;
+}
+
+export interface DescribeChannelRequest {
+    
+    ChannelId: string | undefined;
+}
+export declare namespace DescribeChannelRequest {
+    
+    const filterSensitiveLog: (obj: DescribeChannelRequest) => any;
+}
+
+export interface DescribeChannelResponse {
+    
+    Arn?: string;
+    
+    CdiInputSpecification?: CdiInputSpecification;
+    
+    ChannelClass?: ChannelClass | string;
+    
+    Destinations?: OutputDestination[];
+    
+    EgressEndpoints?: ChannelEgressEndpoint[];
+    
+    EncoderSettings?: EncoderSettings;
+    
+    Id?: string;
+    
+    InputAttachments?: InputAttachment[];
+    
+    InputSpecification?: InputSpecification;
+    
+    LogLevel?: LogLevel | string;
+    
+    Name?: string;
+    
+    PipelineDetails?: PipelineDetail[];
+    
+    PipelinesRunningCount?: number;
+    
+    RoleArn?: string;
+    
+    State?: ChannelState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Vpc?: VpcOutputSettingsDescription;
+}
+export declare namespace DescribeChannelResponse {
+    
+    const filterSensitiveLog: (obj: DescribeChannelResponse) => any;
+}
+
+export interface DescribeInputRequest {
+    
+    InputId: string | undefined;
+}
+export declare namespace DescribeInputRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInputRequest) => any;
+}
+
+export interface DescribeInputResponse {
+    
+    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 DescribeInputResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInputResponse) => any;
+}
+
+export interface DescribeInputDeviceRequest {
+    
+    InputDeviceId: string | undefined;
+}
+export declare namespace DescribeInputDeviceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInputDeviceRequest) => any;
+}
+
+export interface DescribeInputDeviceResponse {
+    
+    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 DescribeInputDeviceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInputDeviceResponse) => any;
+}
+
+export interface DescribeInputDeviceThumbnailRequest {
+    
+    InputDeviceId: string | undefined;
+    
+    Accept: AcceptHeader | string | undefined;
+}
+export declare namespace DescribeInputDeviceThumbnailRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInputDeviceThumbnailRequest) => any;
+}
+
+export interface DescribeInputDeviceThumbnailResponse {
+    
+    Body?: Readable | ReadableStream | Blob;
+    
+    ContentType?: ContentType | string;
+    
+    ContentLength?: number;
+    
+    ETag?: string;
+    
+    LastModified?: Date;
+}
+export declare namespace DescribeInputDeviceThumbnailResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInputDeviceThumbnailResponse) => any;
+}
+
+export interface DescribeInputSecurityGroupRequest {
+    
+    InputSecurityGroupId: string | undefined;
+}
+export declare namespace DescribeInputSecurityGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInputSecurityGroupRequest) => any;
+}
+
+export interface DescribeInputSecurityGroupResponse {
+    
+    Arn?: string;
+    
+    Id?: string;
+    
+    Inputs?: string[];
+    
+    State?: InputSecurityGroupState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    WhitelistRules?: InputWhitelistRule[];
+}
+export declare namespace DescribeInputSecurityGroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInputSecurityGroupResponse) => any;
+}
+
+export interface DescribeMultiplexRequest {
+    
+    MultiplexId: string | undefined;
+}
+export declare namespace DescribeMultiplexRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMultiplexRequest) => any;
+}
+
+export interface DescribeMultiplexResponse {
+    
+    Arn?: string;
+    
+    AvailabilityZones?: string[];
+    
+    Destinations?: MultiplexOutputDestination[];
+    
+    Id?: string;
+    
+    MultiplexSettings?: MultiplexSettings;
+    
+    Name?: string;
+    
+    PipelinesRunningCount?: number;
+    
+    ProgramCount?: number;
+    
+    State?: MultiplexState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DescribeMultiplexResponse {
+    
+    const filterSensitiveLog: (obj: DescribeMultiplexResponse) => any;
+}
+
+export interface DescribeMultiplexProgramRequest {
+    
+    MultiplexId: string | undefined;
+    
+    ProgramName: string | undefined;
+}
+export declare namespace DescribeMultiplexProgramRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMultiplexProgramRequest) => any;
+}
+
+export interface DescribeMultiplexProgramResponse {
+    
+    ChannelId?: string;
+    
+    MultiplexProgramSettings?: MultiplexProgramSettings;
+    
+    PacketIdentifiersMap?: MultiplexProgramPacketIdentifiersMap;
+    
+    PipelineDetails?: MultiplexProgramPipelineDetail[];
+    
+    ProgramName?: string;
+}
+export declare namespace DescribeMultiplexProgramResponse {
+    
+    const filterSensitiveLog: (obj: DescribeMultiplexProgramResponse) => any;
+}
+
+export interface DescribeOfferingRequest {
+    
+    OfferingId: string | undefined;
+}
+export declare namespace DescribeOfferingRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOfferingRequest) => any;
+}
+
+export interface DescribeOfferingResponse {
+    
+    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 DescribeOfferingResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOfferingResponse) => any;
+}
+
+export interface DescribeReservationRequest {
+    
+    ReservationId: string | undefined;
+}
+export declare namespace DescribeReservationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeReservationRequest) => any;
+}
+
+export interface DescribeReservationResponse {
+    
+    Arn?: string;
+    
+    Count?: number;
+    
+    CurrencyCode?: string;
+    
+    Duration?: number;
+    
+    DurationUnits?: OfferingDurationUnits | string;
+    
+    End?: string;
+    
+    FixedPrice?: number;
+    
+    Name?: string;
+    
+    OfferingDescription?: string;
+    
+    OfferingId?: string;
+    
+    OfferingType?: OfferingType | string;
+    
+    Region?: string;
+    
+    ReservationId?: string;
+    
+    ResourceSpecification?: ReservationResourceSpecification;
+    
+    Start?: string;
+    
+    State?: ReservationState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    UsagePrice?: number;
+}
+export declare namespace DescribeReservationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeReservationResponse) => any;
+}
+
+export interface DescribeScheduleRequest {
+    
+    ChannelId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeScheduleRequest {
+    
+    const filterSensitiveLog: (obj: DescribeScheduleRequest) => any;
+}
+
+export interface DescribeScheduleResponse {
+    
+    NextToken?: string;
+    
+    ScheduleActions?: ScheduleAction[];
+}
+export declare namespace DescribeScheduleResponse {
+    
+    const filterSensitiveLog: (obj: DescribeScheduleResponse) => any;
+}
+
+export interface InputDeviceConfigurableSettings {
+    
+    ConfiguredInput?: InputDeviceConfiguredInput | string;
+    
+    MaxBitrate?: number;
+}
+export declare namespace InputDeviceConfigurableSettings {
+    
+    const filterSensitiveLog: (obj: InputDeviceConfigurableSettings) => any;
+}
+
+export interface ListChannelsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListChannelsRequest {
+    
+    const filterSensitiveLog: (obj: ListChannelsRequest) => any;
+}
+
+export interface ListChannelsResponse {
+    
+    Channels?: ChannelSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListChannelsResponse {
+    
+    const filterSensitiveLog: (obj: ListChannelsResponse) => any;
+}
+
+export interface ListInputDevicesRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListInputDevicesRequest {
+    
+    const filterSensitiveLog: (obj: ListInputDevicesRequest) => any;
+}
+
+export interface ListInputDevicesResponse {
+    
+    InputDevices?: InputDeviceSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInputDevicesResponse {
+    
+    const filterSensitiveLog: (obj: ListInputDevicesResponse) => any;
+}
+
+export interface ListInputDeviceTransfersRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    TransferType: string | undefined;
+}
+export declare namespace ListInputDeviceTransfersRequest {
+    
+    const filterSensitiveLog: (obj: ListInputDeviceTransfersRequest) => any;
+}
+
+export interface ListInputDeviceTransfersResponse {
+    
+    InputDeviceTransfers?: TransferringInputDeviceSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInputDeviceTransfersResponse {
+    
+    const filterSensitiveLog: (obj: ListInputDeviceTransfersResponse) => any;
+}
+
+export interface ListInputsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListInputsRequest {
+    
+    const filterSensitiveLog: (obj: ListInputsRequest) => any;
+}
+
+export interface ListInputsResponse {
+    
+    Inputs?: Input[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInputsResponse {
+    
+    const filterSensitiveLog: (obj: ListInputsResponse) => any;
+}
+
+export interface ListInputSecurityGroupsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListInputSecurityGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListInputSecurityGroupsRequest) => any;
+}
+
+export interface ListInputSecurityGroupsResponse {
+    
+    InputSecurityGroups?: InputSecurityGroup[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInputSecurityGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListInputSecurityGroupsResponse) => any;
+}
+
+export interface ListMultiplexesRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListMultiplexesRequest {
+    
+    const filterSensitiveLog: (obj: ListMultiplexesRequest) => any;
+}
+
+export interface ListMultiplexesResponse {
+    
+    Multiplexes?: MultiplexSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListMultiplexesResponse {
+    
+    const filterSensitiveLog: (obj: ListMultiplexesResponse) => any;
+}
+
+export interface ListMultiplexProgramsRequest {
+    
+    MaxResults?: number;
+    
+    MultiplexId: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListMultiplexProgramsRequest {
+    
+    const filterSensitiveLog: (obj: ListMultiplexProgramsRequest) => any;
+}
+
+export interface ListMultiplexProgramsResponse {
+    
+    MultiplexPrograms?: MultiplexProgramSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListMultiplexProgramsResponse {
+    
+    const filterSensitiveLog: (obj: ListMultiplexProgramsResponse) => any;
+}
+
+export interface ListOfferingsRequest {
+    
+    ChannelClass?: string;
+    
+    ChannelConfiguration?: string;
+    
+    Codec?: string;
+    
+    Duration?: string;
+    
+    MaxResults?: number;
+    
+    MaximumBitrate?: string;
+    
+    MaximumFramerate?: string;
+    
+    NextToken?: string;
+    
+    Resolution?: string;
+    
+    ResourceType?: string;
+    
+    SpecialFeature?: string;
+    
+    VideoQuality?: string;
+}
+export declare namespace ListOfferingsRequest {
+    
+    const filterSensitiveLog: (obj: ListOfferingsRequest) => any;
+}
+
+export interface ListOfferingsResponse {
+    
+    NextToken?: string;
+    
+    Offerings?: Offering[];
+}
+export declare namespace ListOfferingsResponse {
+    
+    const filterSensitiveLog: (obj: ListOfferingsResponse) => any;
+}
+
+export interface ListReservationsRequest {
+    
+    ChannelClass?: string;
+    
+    Codec?: string;
+    
+    MaxResults?: number;
+    
+    MaximumBitrate?: string;
+    
+    MaximumFramerate?: string;
+    
+    NextToken?: string;
+    
+    Resolution?: string;
+    
+    ResourceType?: string;
+    
+    SpecialFeature?: string;
+    
+    VideoQuality?: string;
+}
+export declare namespace ListReservationsRequest {
+    
+    const filterSensitiveLog: (obj: ListReservationsRequest) => any;
+}
+
+export interface ListReservationsResponse {
+    
+    NextToken?: string;
+    
+    Reservations?: Reservation[];
+}
+export declare namespace ListReservationsResponse {
+    
+    const filterSensitiveLog: (obj: ListReservationsResponse) => any;
+}
+
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+
+export interface ListTagsForResourceResponse {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface PurchaseOfferingRequest {
+    
+    Count: number | undefined;
+    
+    Name?: string;
+    
+    OfferingId: string | undefined;
+    
+    RequestId?: string;
+    
+    Start?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PurchaseOfferingRequest {
+    
+    const filterSensitiveLog: (obj: PurchaseOfferingRequest) => any;
+}
+
+export interface PurchaseOfferingResponse {
+    
+    Reservation?: Reservation;
+}
+export declare namespace PurchaseOfferingResponse {
+    
+    const filterSensitiveLog: (obj: PurchaseOfferingResponse) => any;
+}
+
+export interface RejectInputDeviceTransferRequest {
+    
+    InputDeviceId: string | undefined;
+}
+export declare namespace RejectInputDeviceTransferRequest {
+    
+    const filterSensitiveLog: (obj: RejectInputDeviceTransferRequest) => any;
+}
+
+export interface RejectInputDeviceTransferResponse {
+}
+export declare namespace RejectInputDeviceTransferResponse {
+    
+    const filterSensitiveLog: (obj: RejectInputDeviceTransferResponse) => any;
+}
+
+export interface StartChannelRequest {
+    
+    ChannelId: string | undefined;
+}
+export declare namespace StartChannelRequest {
+    
+    const filterSensitiveLog: (obj: StartChannelRequest) => any;
+}
+
+export interface StartChannelResponse {
+    
+    Arn?: string;
+    
+    CdiInputSpecification?: CdiInputSpecification;
+    
+    ChannelClass?: ChannelClass | string;
+    
+    Destinations?: OutputDestination[];
+    
+    EgressEndpoints?: ChannelEgressEndpoint[];
+    
+    EncoderSettings?: EncoderSettings;
+    
+    Id?: string;
+    
+    InputAttachments?: InputAttachment[];
+    
+    InputSpecification?: InputSpecification;
+    
+    LogLevel?: LogLevel | string;
+    
+    Name?: string;
+    
+    PipelineDetails?: PipelineDetail[];
+    
+    PipelinesRunningCount?: number;
+    
+    RoleArn?: string;
+    
+    State?: ChannelState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Vpc?: VpcOutputSettingsDescription;
+}
+export declare namespace StartChannelResponse {
+    
+    const filterSensitiveLog: (obj: StartChannelResponse) => any;
+}
+
+export interface StartMultiplexRequest {
+    
+    MultiplexId: string | undefined;
+}
+export declare namespace StartMultiplexRequest {
+    
+    const filterSensitiveLog: (obj: StartMultiplexRequest) => any;
+}
+
+export interface StartMultiplexResponse {
+    
+    Arn?: string;
+    
+    AvailabilityZones?: string[];
+    
+    Destinations?: MultiplexOutputDestination[];
+    
+    Id?: string;
+    
+    MultiplexSettings?: MultiplexSettings;
+    
+    Name?: string;
+    
+    PipelinesRunningCount?: number;
+    
+    ProgramCount?: number;
+    
+    State?: MultiplexState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StartMultiplexResponse {
+    
+    const filterSensitiveLog: (obj: StartMultiplexResponse) => any;
+}
+
+export interface StopChannelRequest {
+    
+    ChannelId: string | undefined;
+}
+export declare namespace StopChannelRequest {
+    
+    const filterSensitiveLog: (obj: StopChannelRequest) => any;
+}
+
+export interface StopChannelResponse {
+    
+    Arn?: string;
+    
+    CdiInputSpecification?: CdiInputSpecification;
+    
+    ChannelClass?: ChannelClass | string;
+    
+    Destinations?: OutputDestination[];
+    
+    EgressEndpoints?: ChannelEgressEndpoint[];
+    
+    EncoderSettings?: EncoderSettings;
+    
+    Id?: string;
+    
+    InputAttachments?: InputAttachment[];
+    
+    InputSpecification?: InputSpecification;
+    
+    LogLevel?: LogLevel | string;
+    
+    Name?: string;
+    
+    PipelineDetails?: PipelineDetail[];
+    
+    PipelinesRunningCount?: number;
+    
+    RoleArn?: string;
+    
+    State?: ChannelState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Vpc?: VpcOutputSettingsDescription;
+}
+export declare namespace StopChannelResponse {
+    
+    const filterSensitiveLog: (obj: StopChannelResponse) => any;
+}
+
+export interface StopMultiplexRequest {
+    
+    MultiplexId: string | undefined;
+}
+export declare namespace StopMultiplexRequest {
+    
+    const filterSensitiveLog: (obj: StopMultiplexRequest) => any;
+}
+
+export interface StopMultiplexResponse {
+    
+    Arn?: string;
+    
+    AvailabilityZones?: string[];
+    
+    Destinations?: MultiplexOutputDestination[];
+    
+    Id?: string;
+    
+    MultiplexSettings?: MultiplexSettings;
+    
+    Name?: string;
+    
+    PipelinesRunningCount?: number;
+    
+    ProgramCount?: number;
+    
+    State?: MultiplexState | string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StopMultiplexResponse {
+    
+    const filterSensitiveLog: (obj: StopMultiplexResponse) => any;
+}
+
+export interface TransferInputDeviceRequest {
+    
+    InputDeviceId: string | undefined;
+    
+    TargetCustomerId?: string;
+    
+    TargetRegion?: string;
+    
+    TransferMessage?: string;
+}
+export declare namespace TransferInputDeviceRequest {
+    
+    const filterSensitiveLog: (obj: TransferInputDeviceRequest) => any;
+}
+
+export interface TransferInputDeviceResponse {
+}
+export declare namespace TransferInputDeviceResponse {
+    
+    const filterSensitiveLog: (obj: TransferInputDeviceResponse) => any;
+}
+
+export interface UpdateChannelRequest {
+    
+    CdiInputSpecification?: CdiInputSpecification;
+    
+    ChannelId: string | undefined;
+    
+    Destinations?: OutputDestination[];
+    
+    EncoderSettings?: EncoderSettings;
+    
+    InputAttachments?: InputAttachment[];
+    
+    InputSpecification?: InputSpecification;
+    
+    LogLevel?: LogLevel | string;
+    
+    Name?: string;
+    
+    RoleArn?: string;
+}
+export declare namespace UpdateChannelRequest {
+    
+    const filterSensitiveLog: (obj: UpdateChannelRequest) => any;
+}
+
+export interface UpdateChannelResponse {
+    
+    Channel?: Channel;
+}
+export declare namespace UpdateChannelResponse {
+    
+    const filterSensitiveLog: (obj: UpdateChannelResponse) => any;
+}
+
+export interface UpdateChannelClassRequest {
+    
+    ChannelClass: ChannelClass | string | undefined;
+    
+    ChannelId: string | undefined;
+    
+    Destinations?: OutputDestination[];
+}
+export declare namespace UpdateChannelClassRequest {
+    
+    const filterSensitiveLog: (obj: UpdateChannelClassRequest) => any;
+}
+
+export interface UpdateChannelClassResponse {
+    
+    Channel?: Channel;
+}
+export declare namespace UpdateChannelClassResponse {
+    
+    const filterSensitiveLog: (obj: UpdateChannelClassResponse) => any;
+}
+
+export interface UpdateInputRequest {
+    
+    Destinations?: InputDestinationRequest[];
+    
+    InputDevices?: InputDeviceRequest[];
+    
+    InputId: string | undefined;
+    
+    InputSecurityGroups?: string[];
+    
+    MediaConnectFlows?: MediaConnectFlowRequest[];
+    
+    Name?: string;
+    
+    RoleArn?: string;
+    
+    Sources?: InputSourceRequest[];
+}
+export declare namespace UpdateInputRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInputRequest) => any;
+}
+
+export interface UpdateInputResponse {
+    
+    Input?: Input;
+}
+export declare namespace UpdateInputResponse {
+    
+    const filterSensitiveLog: (obj: UpdateInputResponse) => any;
+}
+
+export interface UpdateInputDeviceRequest {
+    
+    HdDeviceSettings?: InputDeviceConfigurableSettings;
+    
+    InputDeviceId: string | undefined;
+    
+    Name?: string;
+    
+    UhdDeviceSettings?: InputDeviceConfigurableSettings;
+}
+export declare namespace UpdateInputDeviceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInputDeviceRequest) => any;
+}
+
+export interface UpdateInputDeviceResponse {
+    
+    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 UpdateInputDeviceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateInputDeviceResponse) => any;
+}
+
+export interface UpdateInputSecurityGroupRequest {
+    
+    InputSecurityGroupId: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    WhitelistRules?: InputWhitelistRuleCidr[];
+}
+export declare namespace UpdateInputSecurityGroupRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInputSecurityGroupRequest) => any;
+}
+
+export interface UpdateInputSecurityGroupResponse {
+    
+    SecurityGroup?: InputSecurityGroup;
+}
+export declare namespace UpdateInputSecurityGroupResponse {
+    
+    const filterSensitiveLog: (obj: UpdateInputSecurityGroupResponse) => any;
+}
+
+export interface UpdateMultiplexRequest {
+    
+    MultiplexId: string | undefined;
+    
+    MultiplexSettings?: MultiplexSettings;
+    
+    Name?: string;
+}
+export declare namespace UpdateMultiplexRequest {
+    
+    const filterSensitiveLog: (obj: UpdateMultiplexRequest) => any;
+}
+
+export interface UpdateMultiplexResponse {
+    
+    Multiplex?: Multiplex;
+}
+export declare namespace UpdateMultiplexResponse {
+    
+    const filterSensitiveLog: (obj: UpdateMultiplexResponse) => any;
+}
+
+export interface UpdateMultiplexProgramRequest {
+    
+    MultiplexId: string | undefined;
+    
+    MultiplexProgramSettings?: MultiplexProgramSettings;
+    
+    ProgramName: string | undefined;
+}
+export declare namespace UpdateMultiplexProgramRequest {
+    
+    const filterSensitiveLog: (obj: UpdateMultiplexProgramRequest) => any;
+}
+
+export interface UpdateMultiplexProgramResponse {
+    
+    MultiplexProgram?: MultiplexProgram;
+}
+export declare namespace UpdateMultiplexProgramResponse {
+    
+    const filterSensitiveLog: (obj: UpdateMultiplexProgramResponse) => any;
+}
+
+export interface UpdateReservationRequest {
+    
+    Name?: string;
+    
+    ReservationId: string | undefined;
+}
+export declare namespace UpdateReservationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateReservationRequest) => any;
+}
+
+export interface UpdateReservationResponse {
+    
+    Reservation?: Reservation;
+}
+export declare namespace UpdateReservationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateReservationResponse) => any;
+}