@aws-sdk/client-mediaconnect 3.50.0 → 3.53.0

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

@@ -0,0 +1,1600 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { MediaConnectServiceException as __BaseException } from "./MediaConnectServiceException";
+export declare enum Colorimetry {
+    BT2020 = "BT2020",
+    BT2100 = "BT2100",
+    BT601 = "BT601",
+    BT709 = "BT709",
+    ST2065_1 = "ST2065-1",
+    ST2065_3 = "ST2065-3",
+    XYZ = "XYZ"
+}
+export declare enum Range {
+    FULL = "FULL",
+    FULLPROTECT = "FULLPROTECT",
+    NARROW = "NARROW"
+}
+export declare enum ScanMode {
+    interlace = "interlace",
+    progressive = "progressive",
+    progressive_segmented_frame = "progressive-segmented-frame"
+}
+export declare enum Tcs {
+    BT2100LINHLG = "BT2100LINHLG",
+    BT2100LINPQ = "BT2100LINPQ",
+    DENSITY = "DENSITY",
+    HLG = "HLG",
+    LINEAR = "LINEAR",
+    PQ = "PQ",
+    SDR = "SDR",
+    ST2065_1 = "ST2065-1",
+    ST428_1 = "ST428-1"
+}
+
+export interface FmtpRequest {
+    
+    ChannelOrder?: string;
+    
+    Colorimetry?: Colorimetry | string;
+    
+    ExactFramerate?: string;
+    
+    Par?: string;
+    
+    Range?: Range | string;
+    
+    ScanMode?: ScanMode | string;
+    
+    Tcs?: Tcs | string;
+}
+export declare namespace FmtpRequest {
+    
+    const filterSensitiveLog: (obj: FmtpRequest) => any;
+}
+
+export interface MediaStreamAttributesRequest {
+    
+    Fmtp?: FmtpRequest;
+    
+    Lang?: string;
+}
+export declare namespace MediaStreamAttributesRequest {
+    
+    const filterSensitiveLog: (obj: MediaStreamAttributesRequest) => any;
+}
+export declare enum MediaStreamType {
+    ancillary_data = "ancillary-data",
+    audio = "audio",
+    video = "video"
+}
+
+export interface AddMediaStreamRequest {
+    
+    Attributes?: MediaStreamAttributesRequest;
+    
+    ClockRate?: number;
+    
+    Description?: string;
+    
+    MediaStreamId: number | undefined;
+    
+    MediaStreamName: string | undefined;
+    
+    MediaStreamType: MediaStreamType | string | undefined;
+    
+    VideoFormat?: string;
+}
+export declare namespace AddMediaStreamRequest {
+    
+    const filterSensitiveLog: (obj: AddMediaStreamRequest) => any;
+}
+export declare enum Algorithm {
+    aes128 = "aes128",
+    aes192 = "aes192",
+    aes256 = "aes256"
+}
+export declare enum KeyType {
+    speke = "speke",
+    srt_password = "srt-password",
+    static_key = "static-key"
+}
+
+export interface Encryption {
+    
+    Algorithm?: Algorithm | string;
+    
+    ConstantInitializationVector?: string;
+    
+    DeviceId?: string;
+    
+    KeyType?: KeyType | string;
+    
+    Region?: string;
+    
+    ResourceId?: string;
+    
+    RoleArn: string | undefined;
+    
+    SecretArn?: string;
+    
+    Url?: string;
+}
+export declare namespace Encryption {
+    
+    const filterSensitiveLog: (obj: Encryption) => any;
+}
+
+export interface InterfaceRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace InterfaceRequest {
+    
+    const filterSensitiveLog: (obj: InterfaceRequest) => any;
+}
+
+export interface DestinationConfigurationRequest {
+    
+    DestinationIp: string | undefined;
+    
+    DestinationPort: number | undefined;
+    
+    Interface: InterfaceRequest | undefined;
+}
+export declare namespace DestinationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DestinationConfigurationRequest) => any;
+}
+export declare enum EncodingName {
+    jxsv = "jxsv",
+    pcm = "pcm",
+    raw = "raw",
+    smpte291 = "smpte291"
+}
+export declare enum EncoderProfile {
+    high = "high",
+    main = "main"
+}
+
+export interface EncodingParametersRequest {
+    
+    CompressionFactor: number | undefined;
+    
+    EncoderProfile: EncoderProfile | string | undefined;
+}
+export declare namespace EncodingParametersRequest {
+    
+    const filterSensitiveLog: (obj: EncodingParametersRequest) => any;
+}
+
+export interface MediaStreamOutputConfigurationRequest {
+    
+    DestinationConfigurations?: DestinationConfigurationRequest[];
+    
+    EncodingName: EncodingName | string | undefined;
+    
+    EncodingParameters?: EncodingParametersRequest;
+    
+    MediaStreamName: string | undefined;
+}
+export declare namespace MediaStreamOutputConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: MediaStreamOutputConfigurationRequest) => any;
+}
+export declare enum Protocol {
+    cdi = "cdi",
+    fujitsu_qos = "fujitsu-qos",
+    rist = "rist",
+    rtp = "rtp",
+    rtp_fec = "rtp-fec",
+    srt_listener = "srt-listener",
+    st2110_jpegxs = "st2110-jpegxs",
+    zixi_pull = "zixi-pull",
+    zixi_push = "zixi-push"
+}
+
+export interface VpcInterfaceAttachment {
+    
+    VpcInterfaceName?: string;
+}
+export declare namespace VpcInterfaceAttachment {
+    
+    const filterSensitiveLog: (obj: VpcInterfaceAttachment) => any;
+}
+
+export interface AddOutputRequest {
+    
+    CidrAllowList?: string[];
+    
+    Description?: string;
+    
+    Destination?: string;
+    
+    Encryption?: Encryption;
+    
+    MaxLatency?: number;
+    
+    MediaStreamOutputConfigurations?: MediaStreamOutputConfigurationRequest[];
+    
+    MinLatency?: number;
+    
+    Name?: string;
+    
+    Port?: number;
+    
+    Protocol: Protocol | string | undefined;
+    
+    RemoteId?: string;
+    
+    SenderControlPort?: number;
+    
+    SmoothingLatency?: number;
+    
+    StreamId?: string;
+    
+    VpcInterfaceAttachment?: VpcInterfaceAttachment;
+}
+export declare namespace AddOutputRequest {
+    
+    const filterSensitiveLog: (obj: AddOutputRequest) => any;
+}
+
+export interface Interface {
+    
+    Name: string | undefined;
+}
+export declare namespace Interface {
+    
+    const filterSensitiveLog: (obj: Interface) => any;
+}
+
+export interface DestinationConfiguration {
+    
+    DestinationIp: string | undefined;
+    
+    DestinationPort: number | undefined;
+    
+    Interface: Interface | undefined;
+    
+    OutboundIp: string | undefined;
+}
+export declare namespace DestinationConfiguration {
+    
+    const filterSensitiveLog: (obj: DestinationConfiguration) => any;
+}
+export declare enum EntitlementStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface Entitlement {
+    
+    DataTransferSubscriberFeePercent?: number;
+    
+    Description?: string;
+    
+    Encryption?: Encryption;
+    
+    EntitlementArn: string | undefined;
+    
+    EntitlementStatus?: EntitlementStatus | string;
+    
+    Name: string | undefined;
+    
+    Subscribers: string[] | undefined;
+}
+export declare namespace Entitlement {
+    
+    const filterSensitiveLog: (obj: Entitlement) => any;
+}
+
+export interface GrantEntitlementRequest {
+    
+    DataTransferSubscriberFeePercent?: number;
+    
+    Description?: string;
+    
+    Encryption?: Encryption;
+    
+    EntitlementStatus?: EntitlementStatus | string;
+    
+    Name?: string;
+    
+    Subscribers: string[] | undefined;
+}
+export declare namespace GrantEntitlementRequest {
+    
+    const filterSensitiveLog: (obj: GrantEntitlementRequest) => any;
+}
+
+export interface InputConfiguration {
+    
+    InputIp: string | undefined;
+    
+    InputPort: number | undefined;
+    
+    Interface: Interface | undefined;
+}
+export declare namespace InputConfiguration {
+    
+    const filterSensitiveLog: (obj: InputConfiguration) => any;
+}
+
+export interface InputConfigurationRequest {
+    
+    InputPort: number | undefined;
+    
+    Interface: InterfaceRequest | undefined;
+}
+export declare namespace InputConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: InputConfigurationRequest) => any;
+}
+
+export interface ListedEntitlement {
+    
+    DataTransferSubscriberFeePercent?: number;
+    
+    EntitlementArn: string | undefined;
+    
+    EntitlementName: string | undefined;
+}
+export declare namespace ListedEntitlement {
+    
+    const filterSensitiveLog: (obj: ListedEntitlement) => any;
+}
+export declare enum SourceType {
+    ENTITLED = "ENTITLED",
+    OWNED = "OWNED"
+}
+export declare enum Status {
+    ACTIVE = "ACTIVE",
+    DELETING = "DELETING",
+    ERROR = "ERROR",
+    STANDBY = "STANDBY",
+    STARTING = "STARTING",
+    STOPPING = "STOPPING",
+    UPDATING = "UPDATING"
+}
+
+export interface ListedFlow {
+    
+    AvailabilityZone: string | undefined;
+    
+    Description: string | undefined;
+    
+    FlowArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    SourceType: SourceType | string | undefined;
+    
+    Status: Status | string | undefined;
+}
+export declare namespace ListedFlow {
+    
+    const filterSensitiveLog: (obj: ListedFlow) => any;
+}
+
+export interface Fmtp {
+    
+    ChannelOrder?: string;
+    
+    Colorimetry?: Colorimetry | string;
+    
+    ExactFramerate?: string;
+    
+    Par?: string;
+    
+    Range?: Range | string;
+    
+    ScanMode?: ScanMode | string;
+    
+    Tcs?: Tcs | string;
+}
+export declare namespace Fmtp {
+    
+    const filterSensitiveLog: (obj: Fmtp) => any;
+}
+
+export interface MediaStreamAttributes {
+    
+    Fmtp: Fmtp | undefined;
+    
+    Lang?: string;
+}
+export declare namespace MediaStreamAttributes {
+    
+    const filterSensitiveLog: (obj: MediaStreamAttributes) => any;
+}
+
+export interface MediaStream {
+    
+    Attributes?: MediaStreamAttributes;
+    
+    ClockRate?: number;
+    
+    Description?: string;
+    
+    Fmt: number | undefined;
+    
+    MediaStreamId: number | undefined;
+    
+    MediaStreamName: string | undefined;
+    
+    MediaStreamType: MediaStreamType | string | undefined;
+    
+    VideoFormat?: string;
+}
+export declare namespace MediaStream {
+    
+    const filterSensitiveLog: (obj: MediaStream) => any;
+}
+
+export interface EncodingParameters {
+    
+    CompressionFactor: number | undefined;
+    
+    EncoderProfile: EncoderProfile | string | undefined;
+}
+export declare namespace EncodingParameters {
+    
+    const filterSensitiveLog: (obj: EncodingParameters) => any;
+}
+
+export interface MediaStreamOutputConfiguration {
+    
+    DestinationConfigurations?: DestinationConfiguration[];
+    
+    EncodingName: EncodingName | string | undefined;
+    
+    EncodingParameters?: EncodingParameters;
+    
+    MediaStreamName: string | undefined;
+}
+export declare namespace MediaStreamOutputConfiguration {
+    
+    const filterSensitiveLog: (obj: MediaStreamOutputConfiguration) => any;
+}
+
+export interface MediaStreamSourceConfiguration {
+    
+    EncodingName: EncodingName | string | undefined;
+    
+    InputConfigurations?: InputConfiguration[];
+    
+    MediaStreamName: string | undefined;
+}
+export declare namespace MediaStreamSourceConfiguration {
+    
+    const filterSensitiveLog: (obj: MediaStreamSourceConfiguration) => any;
+}
+
+export interface MediaStreamSourceConfigurationRequest {
+    
+    EncodingName: EncodingName | string | undefined;
+    
+    InputConfigurations?: InputConfigurationRequest[];
+    
+    MediaStreamName: string | undefined;
+}
+export declare namespace MediaStreamSourceConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: MediaStreamSourceConfigurationRequest) => any;
+}
+export declare enum DurationUnits {
+    MONTHS = "MONTHS"
+}
+export declare enum PriceUnits {
+    HOURLY = "HOURLY"
+}
+export declare enum ResourceType {
+    Mbps_Outbound_Bandwidth = "Mbps_Outbound_Bandwidth"
+}
+
+export interface ResourceSpecification {
+    
+    ReservedBitrate?: number;
+    
+    ResourceType: ResourceType | string | undefined;
+}
+export declare namespace ResourceSpecification {
+    
+    const filterSensitiveLog: (obj: ResourceSpecification) => any;
+}
+
+export interface Offering {
+    
+    CurrencyCode: string | undefined;
+    
+    Duration: number | undefined;
+    
+    DurationUnits: DurationUnits | string | undefined;
+    
+    OfferingArn: string | undefined;
+    
+    OfferingDescription: string | undefined;
+    
+    PricePerUnit: string | undefined;
+    
+    PriceUnits: PriceUnits | string | undefined;
+    
+    ResourceSpecification: ResourceSpecification | undefined;
+}
+export declare namespace Offering {
+    
+    const filterSensitiveLog: (obj: Offering) => any;
+}
+
+export interface Transport {
+    
+    CidrAllowList?: string[];
+    
+    MaxBitrate?: number;
+    
+    MaxLatency?: number;
+    
+    MaxSyncBuffer?: number;
+    
+    MinLatency?: number;
+    
+    Protocol: Protocol | string | undefined;
+    
+    RemoteId?: string;
+    
+    SenderControlPort?: number;
+    
+    SenderIpAddress?: string;
+    
+    SmoothingLatency?: number;
+    
+    StreamId?: string;
+}
+export declare namespace Transport {
+    
+    const filterSensitiveLog: (obj: Transport) => any;
+}
+
+export interface Output {
+    
+    DataTransferSubscriberFeePercent?: number;
+    
+    Description?: string;
+    
+    Destination?: string;
+    
+    Encryption?: Encryption;
+    
+    EntitlementArn?: string;
+    
+    ListenerAddress?: string;
+    
+    MediaLiveInputArn?: string;
+    
+    MediaStreamOutputConfigurations?: MediaStreamOutputConfiguration[];
+    
+    Name: string | undefined;
+    
+    OutputArn: string | undefined;
+    
+    Port?: number;
+    
+    Transport?: Transport;
+    
+    VpcInterfaceAttachment?: VpcInterfaceAttachment;
+}
+export declare namespace Output {
+    
+    const filterSensitiveLog: (obj: Output) => any;
+}
+export declare enum ReservationState {
+    ACTIVE = "ACTIVE",
+    CANCELED = "CANCELED",
+    EXPIRED = "EXPIRED",
+    PROCESSING = "PROCESSING"
+}
+
+export interface Reservation {
+    
+    CurrencyCode: string | undefined;
+    
+    Duration: number | undefined;
+    
+    DurationUnits: DurationUnits | string | undefined;
+    
+    End: string | undefined;
+    
+    OfferingArn: string | undefined;
+    
+    OfferingDescription: string | undefined;
+    
+    PricePerUnit: string | undefined;
+    
+    PriceUnits: PriceUnits | string | undefined;
+    
+    ReservationArn: string | undefined;
+    
+    ReservationName: string | undefined;
+    
+    ReservationState: ReservationState | string | undefined;
+    
+    ResourceSpecification: ResourceSpecification | undefined;
+    
+    Start: string | undefined;
+}
+export declare namespace Reservation {
+    
+    const filterSensitiveLog: (obj: Reservation) => any;
+}
+
+export interface SetSourceRequest {
+    
+    Decryption?: Encryption;
+    
+    Description?: string;
+    
+    EntitlementArn?: string;
+    
+    IngestPort?: number;
+    
+    MaxBitrate?: number;
+    
+    MaxLatency?: number;
+    
+    MaxSyncBuffer?: number;
+    
+    MediaStreamSourceConfigurations?: MediaStreamSourceConfigurationRequest[];
+    
+    MinLatency?: number;
+    
+    Name?: string;
+    
+    Protocol?: Protocol | string;
+    
+    SenderControlPort?: number;
+    
+    SenderIpAddress?: string;
+    
+    StreamId?: string;
+    
+    VpcInterfaceName?: string;
+    
+    WhitelistCidr?: string;
+}
+export declare namespace SetSourceRequest {
+    
+    const filterSensitiveLog: (obj: SetSourceRequest) => any;
+}
+
+export interface Source {
+    
+    DataTransferSubscriberFeePercent?: number;
+    
+    Decryption?: Encryption;
+    
+    Description?: string;
+    
+    EntitlementArn?: string;
+    
+    IngestIp?: string;
+    
+    IngestPort?: number;
+    
+    MediaStreamSourceConfigurations?: MediaStreamSourceConfiguration[];
+    
+    Name: string | undefined;
+    
+    SenderControlPort?: number;
+    
+    SenderIpAddress?: string;
+    
+    SourceArn: string | undefined;
+    
+    Transport?: Transport;
+    
+    VpcInterfaceName?: string;
+    
+    WhitelistCidr?: string;
+}
+export declare namespace Source {
+    
+    const filterSensitiveLog: (obj: Source) => any;
+}
+export declare enum NetworkInterfaceType {
+    efa = "efa",
+    ena = "ena"
+}
+
+export interface VpcInterface {
+    
+    Name: string | undefined;
+    
+    NetworkInterfaceIds: string[] | undefined;
+    
+    NetworkInterfaceType: NetworkInterfaceType | string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    SecurityGroupIds: string[] | undefined;
+    
+    SubnetId: string | undefined;
+}
+export declare namespace VpcInterface {
+    
+    const filterSensitiveLog: (obj: VpcInterface) => any;
+}
+
+export interface VpcInterfaceRequest {
+    
+    Name: string | undefined;
+    
+    NetworkInterfaceType?: NetworkInterfaceType | string;
+    
+    RoleArn: string | undefined;
+    
+    SecurityGroupIds: string[] | undefined;
+    
+    SubnetId: string | undefined;
+}
+export declare namespace VpcInterfaceRequest {
+    
+    const filterSensitiveLog: (obj: VpcInterfaceRequest) => any;
+}
+
+export interface AddFlowMediaStreamsRequest {
+    
+    FlowArn: string | undefined;
+    
+    MediaStreams: AddMediaStreamRequest[] | undefined;
+}
+export declare namespace AddFlowMediaStreamsRequest {
+    
+    const filterSensitiveLog: (obj: AddFlowMediaStreamsRequest) => any;
+}
+export interface AddFlowMediaStreamsResponse {
+    
+    FlowArn?: string;
+    
+    MediaStreams?: MediaStream[];
+}
+export declare namespace AddFlowMediaStreamsResponse {
+    
+    const filterSensitiveLog: (obj: AddFlowMediaStreamsResponse) => any;
+}
+
+export declare class BadRequestException extends __BaseException {
+    readonly name: "BadRequestException";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
+}
+
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+
+export declare class InternalServerErrorException extends __BaseException {
+    readonly name: "InternalServerErrorException";
+    readonly $fault: "server";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerErrorException, __BaseException>);
+}
+
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
+
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}
+
+export declare class TooManyRequestsException extends __BaseException {
+    readonly name: "TooManyRequestsException";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>);
+}
+
+export declare class AddFlowOutputs420Exception extends __BaseException {
+    readonly name: "AddFlowOutputs420Exception";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<AddFlowOutputs420Exception, __BaseException>);
+}
+
+export interface AddFlowOutputsRequest {
+    
+    FlowArn: string | undefined;
+    
+    Outputs: AddOutputRequest[] | undefined;
+}
+export declare namespace AddFlowOutputsRequest {
+    
+    const filterSensitiveLog: (obj: AddFlowOutputsRequest) => any;
+}
+export interface AddFlowOutputsResponse {
+    
+    FlowArn?: string;
+    
+    Outputs?: Output[];
+}
+export declare namespace AddFlowOutputsResponse {
+    
+    const filterSensitiveLog: (obj: AddFlowOutputsResponse) => any;
+}
+
+export interface AddFlowSourcesRequest {
+    
+    FlowArn: string | undefined;
+    
+    Sources: SetSourceRequest[] | undefined;
+}
+export declare namespace AddFlowSourcesRequest {
+    
+    const filterSensitiveLog: (obj: AddFlowSourcesRequest) => any;
+}
+export interface AddFlowSourcesResponse {
+    
+    FlowArn?: string;
+    
+    Sources?: Source[];
+}
+export declare namespace AddFlowSourcesResponse {
+    
+    const filterSensitiveLog: (obj: AddFlowSourcesResponse) => any;
+}
+
+export interface AddFlowVpcInterfacesRequest {
+    
+    FlowArn: string | undefined;
+    
+    VpcInterfaces: VpcInterfaceRequest[] | undefined;
+}
+export declare namespace AddFlowVpcInterfacesRequest {
+    
+    const filterSensitiveLog: (obj: AddFlowVpcInterfacesRequest) => any;
+}
+export interface AddFlowVpcInterfacesResponse {
+    
+    FlowArn?: string;
+    
+    VpcInterfaces?: VpcInterface[];
+}
+export declare namespace AddFlowVpcInterfacesResponse {
+    
+    const filterSensitiveLog: (obj: AddFlowVpcInterfacesResponse) => any;
+}
+
+export declare class CreateFlow420Exception extends __BaseException {
+    readonly name: "CreateFlow420Exception";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<CreateFlow420Exception, __BaseException>);
+}
+export declare enum FailoverMode {
+    FAILOVER = "FAILOVER",
+    MERGE = "MERGE"
+}
+
+export interface SourcePriority {
+    
+    PrimarySource?: string;
+}
+export declare namespace SourcePriority {
+    
+    const filterSensitiveLog: (obj: SourcePriority) => any;
+}
+export declare enum State {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface FailoverConfig {
+    
+    FailoverMode?: FailoverMode | string;
+    
+    RecoveryWindow?: number;
+    
+    SourcePriority?: SourcePriority;
+    State?: State | string;
+}
+export declare namespace FailoverConfig {
+    
+    const filterSensitiveLog: (obj: FailoverConfig) => any;
+}
+
+export interface CreateFlowRequest {
+    
+    AvailabilityZone?: string;
+    
+    Entitlements?: GrantEntitlementRequest[];
+    
+    MediaStreams?: AddMediaStreamRequest[];
+    
+    Name: string | undefined;
+    
+    Outputs?: AddOutputRequest[];
+    
+    Source?: SetSourceRequest;
+    
+    SourceFailoverConfig?: FailoverConfig;
+    Sources?: SetSourceRequest[];
+    
+    VpcInterfaces?: VpcInterfaceRequest[];
+}
+export declare namespace CreateFlowRequest {
+    
+    const filterSensitiveLog: (obj: CreateFlowRequest) => any;
+}
+
+export interface Flow {
+    
+    AvailabilityZone: string | undefined;
+    
+    Description?: string;
+    
+    EgressIp?: string;
+    
+    Entitlements: Entitlement[] | undefined;
+    
+    FlowArn: string | undefined;
+    
+    MediaStreams?: MediaStream[];
+    
+    Name: string | undefined;
+    
+    Outputs: Output[] | undefined;
+    
+    Source: Source | undefined;
+    
+    SourceFailoverConfig?: FailoverConfig;
+    Sources?: Source[];
+    
+    Status: Status | string | undefined;
+    
+    VpcInterfaces?: VpcInterface[];
+}
+export declare namespace Flow {
+    
+    const filterSensitiveLog: (obj: Flow) => any;
+}
+export interface CreateFlowResponse {
+    
+    Flow?: Flow;
+}
+export declare namespace CreateFlowResponse {
+    
+    const filterSensitiveLog: (obj: CreateFlowResponse) => any;
+}
+export interface DeleteFlowRequest {
+    
+    FlowArn: string | undefined;
+}
+export declare namespace DeleteFlowRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFlowRequest) => any;
+}
+export interface DeleteFlowResponse {
+    
+    FlowArn?: string;
+    
+    Status?: Status | string;
+}
+export declare namespace DeleteFlowResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFlowResponse) => any;
+}
+export interface DescribeFlowRequest {
+    
+    FlowArn: string | undefined;
+}
+export declare namespace DescribeFlowRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFlowRequest) => any;
+}
+
+export interface Messages {
+    
+    Errors: string[] | undefined;
+}
+export declare namespace Messages {
+    
+    const filterSensitiveLog: (obj: Messages) => any;
+}
+export interface DescribeFlowResponse {
+    
+    Flow?: Flow;
+    
+    Messages?: Messages;
+}
+export declare namespace DescribeFlowResponse {
+    
+    const filterSensitiveLog: (obj: DescribeFlowResponse) => any;
+}
+export interface DescribeOfferingRequest {
+    
+    OfferingArn: string | undefined;
+}
+export declare namespace DescribeOfferingRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOfferingRequest) => any;
+}
+export interface DescribeOfferingResponse {
+    
+    Offering?: Offering;
+}
+export declare namespace DescribeOfferingResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOfferingResponse) => any;
+}
+export interface DescribeReservationRequest {
+    
+    ReservationArn: string | undefined;
+}
+export declare namespace DescribeReservationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeReservationRequest) => any;
+}
+export interface DescribeReservationResponse {
+    
+    Reservation?: Reservation;
+}
+export declare namespace DescribeReservationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeReservationResponse) => any;
+}
+
+export declare class GrantFlowEntitlements420Exception extends __BaseException {
+    readonly name: "GrantFlowEntitlements420Exception";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<GrantFlowEntitlements420Exception, __BaseException>);
+}
+
+export interface GrantFlowEntitlementsRequest {
+    
+    Entitlements: GrantEntitlementRequest[] | undefined;
+    
+    FlowArn: string | undefined;
+}
+export declare namespace GrantFlowEntitlementsRequest {
+    
+    const filterSensitiveLog: (obj: GrantFlowEntitlementsRequest) => any;
+}
+export interface GrantFlowEntitlementsResponse {
+    
+    Entitlements?: Entitlement[];
+    
+    FlowArn?: string;
+}
+export declare namespace GrantFlowEntitlementsResponse {
+    
+    const filterSensitiveLog: (obj: GrantFlowEntitlementsResponse) => any;
+}
+export interface ListEntitlementsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListEntitlementsRequest {
+    
+    const filterSensitiveLog: (obj: ListEntitlementsRequest) => any;
+}
+export interface ListEntitlementsResponse {
+    
+    Entitlements?: ListedEntitlement[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEntitlementsResponse {
+    
+    const filterSensitiveLog: (obj: ListEntitlementsResponse) => any;
+}
+export interface ListFlowsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFlowsRequest {
+    
+    const filterSensitiveLog: (obj: ListFlowsRequest) => any;
+}
+export interface ListFlowsResponse {
+    
+    Flows?: ListedFlow[];
+    
+    NextToken?: string;
+}
+export declare namespace ListFlowsResponse {
+    
+    const filterSensitiveLog: (obj: ListFlowsResponse) => any;
+}
+export interface ListOfferingsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: 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 {
+    
+    MaxResults?: number;
+    
+    NextToken?: 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 {
+    
+    OfferingArn: string | undefined;
+    
+    ReservationName: string | undefined;
+    
+    Start: string | undefined;
+}
+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 RemoveFlowMediaStreamRequest {
+    
+    FlowArn: string | undefined;
+    
+    MediaStreamName: string | undefined;
+}
+export declare namespace RemoveFlowMediaStreamRequest {
+    
+    const filterSensitiveLog: (obj: RemoveFlowMediaStreamRequest) => any;
+}
+export interface RemoveFlowMediaStreamResponse {
+    
+    FlowArn?: string;
+    
+    MediaStreamName?: string;
+}
+export declare namespace RemoveFlowMediaStreamResponse {
+    
+    const filterSensitiveLog: (obj: RemoveFlowMediaStreamResponse) => any;
+}
+export interface RemoveFlowOutputRequest {
+    
+    FlowArn: string | undefined;
+    
+    OutputArn: string | undefined;
+}
+export declare namespace RemoveFlowOutputRequest {
+    
+    const filterSensitiveLog: (obj: RemoveFlowOutputRequest) => any;
+}
+export interface RemoveFlowOutputResponse {
+    
+    FlowArn?: string;
+    
+    OutputArn?: string;
+}
+export declare namespace RemoveFlowOutputResponse {
+    
+    const filterSensitiveLog: (obj: RemoveFlowOutputResponse) => any;
+}
+export interface RemoveFlowSourceRequest {
+    
+    FlowArn: string | undefined;
+    
+    SourceArn: string | undefined;
+}
+export declare namespace RemoveFlowSourceRequest {
+    
+    const filterSensitiveLog: (obj: RemoveFlowSourceRequest) => any;
+}
+export interface RemoveFlowSourceResponse {
+    
+    FlowArn?: string;
+    
+    SourceArn?: string;
+}
+export declare namespace RemoveFlowSourceResponse {
+    
+    const filterSensitiveLog: (obj: RemoveFlowSourceResponse) => any;
+}
+export interface RemoveFlowVpcInterfaceRequest {
+    
+    FlowArn: string | undefined;
+    
+    VpcInterfaceName: string | undefined;
+}
+export declare namespace RemoveFlowVpcInterfaceRequest {
+    
+    const filterSensitiveLog: (obj: RemoveFlowVpcInterfaceRequest) => any;
+}
+export interface RemoveFlowVpcInterfaceResponse {
+    
+    FlowArn?: string;
+    
+    NonDeletedNetworkInterfaceIds?: string[];
+    
+    VpcInterfaceName?: string;
+}
+export declare namespace RemoveFlowVpcInterfaceResponse {
+    
+    const filterSensitiveLog: (obj: RemoveFlowVpcInterfaceResponse) => any;
+}
+export interface RevokeFlowEntitlementRequest {
+    
+    EntitlementArn: string | undefined;
+    
+    FlowArn: string | undefined;
+}
+export declare namespace RevokeFlowEntitlementRequest {
+    
+    const filterSensitiveLog: (obj: RevokeFlowEntitlementRequest) => any;
+}
+export interface RevokeFlowEntitlementResponse {
+    
+    EntitlementArn?: string;
+    
+    FlowArn?: string;
+}
+export declare namespace RevokeFlowEntitlementResponse {
+    
+    const filterSensitiveLog: (obj: RevokeFlowEntitlementResponse) => any;
+}
+export interface StartFlowRequest {
+    
+    FlowArn: string | undefined;
+}
+export declare namespace StartFlowRequest {
+    
+    const filterSensitiveLog: (obj: StartFlowRequest) => any;
+}
+export interface StartFlowResponse {
+    
+    FlowArn?: string;
+    
+    Status?: Status | string;
+}
+export declare namespace StartFlowResponse {
+    
+    const filterSensitiveLog: (obj: StartFlowResponse) => any;
+}
+export interface StopFlowRequest {
+    
+    FlowArn: string | undefined;
+}
+export declare namespace StopFlowRequest {
+    
+    const filterSensitiveLog: (obj: StopFlowRequest) => any;
+}
+export interface StopFlowResponse {
+    
+    FlowArn?: string;
+    
+    Status?: Status | string;
+}
+export declare namespace StopFlowResponse {
+    
+    const filterSensitiveLog: (obj: StopFlowResponse) => any;
+}
+
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+
+export interface UpdateFailoverConfig {
+    
+    FailoverMode?: FailoverMode | string;
+    
+    RecoveryWindow?: number;
+    
+    SourcePriority?: SourcePriority;
+    State?: State | string;
+}
+export declare namespace UpdateFailoverConfig {
+    
+    const filterSensitiveLog: (obj: UpdateFailoverConfig) => any;
+}
+
+export interface UpdateFlowRequest {
+    
+    FlowArn: string | undefined;
+    
+    SourceFailoverConfig?: UpdateFailoverConfig;
+}
+export declare namespace UpdateFlowRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFlowRequest) => any;
+}
+export interface UpdateFlowResponse {
+    
+    Flow?: Flow;
+}
+export declare namespace UpdateFlowResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFlowResponse) => any;
+}
+
+export interface UpdateEncryption {
+    
+    Algorithm?: Algorithm | string;
+    
+    ConstantInitializationVector?: string;
+    
+    DeviceId?: string;
+    
+    KeyType?: KeyType | string;
+    
+    Region?: string;
+    
+    ResourceId?: string;
+    
+    RoleArn?: string;
+    
+    SecretArn?: string;
+    
+    Url?: string;
+}
+export declare namespace UpdateEncryption {
+    
+    const filterSensitiveLog: (obj: UpdateEncryption) => any;
+}
+
+export interface UpdateFlowEntitlementRequest {
+    
+    Description?: string;
+    
+    Encryption?: UpdateEncryption;
+    
+    EntitlementArn: string | undefined;
+    
+    EntitlementStatus?: EntitlementStatus | string;
+    
+    FlowArn: string | undefined;
+    
+    Subscribers?: string[];
+}
+export declare namespace UpdateFlowEntitlementRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFlowEntitlementRequest) => any;
+}
+export interface UpdateFlowEntitlementResponse {
+    
+    Entitlement?: Entitlement;
+    
+    FlowArn?: string;
+}
+export declare namespace UpdateFlowEntitlementResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFlowEntitlementResponse) => any;
+}
+
+export interface UpdateFlowMediaStreamRequest {
+    
+    Attributes?: MediaStreamAttributesRequest;
+    
+    ClockRate?: number;
+    
+    Description?: string;
+    
+    FlowArn: string | undefined;
+    
+    MediaStreamName: string | undefined;
+    
+    MediaStreamType?: MediaStreamType | string;
+    
+    VideoFormat?: string;
+}
+export declare namespace UpdateFlowMediaStreamRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFlowMediaStreamRequest) => any;
+}
+export interface UpdateFlowMediaStreamResponse {
+    
+    FlowArn?: string;
+    
+    MediaStream?: MediaStream;
+}
+export declare namespace UpdateFlowMediaStreamResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFlowMediaStreamResponse) => any;
+}
+
+export interface UpdateFlowOutputRequest {
+    
+    CidrAllowList?: string[];
+    
+    Description?: string;
+    
+    Destination?: string;
+    
+    Encryption?: UpdateEncryption;
+    
+    FlowArn: string | undefined;
+    
+    MaxLatency?: number;
+    
+    MediaStreamOutputConfigurations?: MediaStreamOutputConfigurationRequest[];
+    
+    MinLatency?: number;
+    
+    OutputArn: string | undefined;
+    
+    Port?: number;
+    
+    Protocol?: Protocol | string;
+    
+    RemoteId?: string;
+    
+    SenderControlPort?: number;
+    
+    SenderIpAddress?: string;
+    
+    SmoothingLatency?: number;
+    
+    StreamId?: string;
+    
+    VpcInterfaceAttachment?: VpcInterfaceAttachment;
+}
+export declare namespace UpdateFlowOutputRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFlowOutputRequest) => any;
+}
+export interface UpdateFlowOutputResponse {
+    
+    FlowArn?: string;
+    
+    Output?: Output;
+}
+export declare namespace UpdateFlowOutputResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFlowOutputResponse) => any;
+}
+
+export interface UpdateFlowSourceRequest {
+    
+    Decryption?: UpdateEncryption;
+    
+    Description?: string;
+    
+    EntitlementArn?: string;
+    
+    FlowArn: string | undefined;
+    
+    IngestPort?: number;
+    
+    MaxBitrate?: number;
+    
+    MaxLatency?: number;
+    
+    MaxSyncBuffer?: number;
+    
+    MediaStreamSourceConfigurations?: MediaStreamSourceConfigurationRequest[];
+    
+    MinLatency?: number;
+    
+    Protocol?: Protocol | string;
+    
+    SenderControlPort?: number;
+    
+    SenderIpAddress?: string;
+    
+    SourceArn: string | undefined;
+    
+    StreamId?: string;
+    
+    VpcInterfaceName?: string;
+    
+    WhitelistCidr?: string;
+}
+export declare namespace UpdateFlowSourceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFlowSourceRequest) => any;
+}
+export interface UpdateFlowSourceResponse {
+    
+    FlowArn?: string;
+    
+    Source?: Source;
+}
+export declare namespace UpdateFlowSourceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFlowSourceResponse) => any;
+}