Output.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/mediaconnect/MediaConnect_EXPORTS.h>
#include <aws/mediaconnect/model/Encryption.h>
#include <aws/mediaconnect/model/FlowTransitEncryption.h>
#include <aws/mediaconnect/model/MediaStreamOutputConfiguration.h>
#include <aws/mediaconnect/model/OutputStatus.h>
#include <aws/mediaconnect/model/State.h>
#include <aws/mediaconnect/model/Transport.h>
#include <aws/mediaconnect/model/VpcInterfaceAttachment.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConnect {
namespace Model {
 
class Output {
 public:
  AWS_MEDIACONNECT_API Output() = default;
  AWS_MEDIACONNECT_API Output(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONNECT_API Output& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONNECT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline int GetDataTransferSubscriberFeePercent() const { return m_dataTransferSubscriberFeePercent; }
  inline bool DataTransferSubscriberFeePercentHasBeenSet() const { return m_dataTransferSubscriberFeePercentHasBeenSet; }
  inline void SetDataTransferSubscriberFeePercent(int value) {
    m_dataTransferSubscriberFeePercentHasBeenSet = true;
    m_dataTransferSubscriberFeePercent = value;
  }
  inline Output& WithDataTransferSubscriberFeePercent(int value) {
    SetDataTransferSubscriberFeePercent(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  Output& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDestination() const { return m_destination; }
  inline bool DestinationHasBeenSet() const { return m_destinationHasBeenSet; }
  template <typename DestinationT = Aws::String>
  void SetDestination(DestinationT&& value) {
    m_destinationHasBeenSet = true;
    m_destination = std::forward<DestinationT>(value);
  }
  template <typename DestinationT = Aws::String>
  Output& WithDestination(DestinationT&& value) {
    SetDestination(std::forward<DestinationT>(value));
    return *this;
  }
 
 
  inline const Encryption& GetEncryption() const { return m_encryption; }
  inline bool EncryptionHasBeenSet() const { return m_encryptionHasBeenSet; }
  template <typename EncryptionT = Encryption>
  void SetEncryption(EncryptionT&& value) {
    m_encryptionHasBeenSet = true;
    m_encryption = std::forward<EncryptionT>(value);
  }
  template <typename EncryptionT = Encryption>
  Output& WithEncryption(EncryptionT&& value) {
    SetEncryption(std::forward<EncryptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEntitlementArn() const { return m_entitlementArn; }
  inline bool EntitlementArnHasBeenSet() const { return m_entitlementArnHasBeenSet; }
  template <typename EntitlementArnT = Aws::String>
  void SetEntitlementArn(EntitlementArnT&& value) {
    m_entitlementArnHasBeenSet = true;
    m_entitlementArn = std::forward<EntitlementArnT>(value);
  }
  template <typename EntitlementArnT = Aws::String>
  Output& WithEntitlementArn(EntitlementArnT&& value) {
    SetEntitlementArn(std::forward<EntitlementArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetListenerAddress() const { return m_listenerAddress; }
  inline bool ListenerAddressHasBeenSet() const { return m_listenerAddressHasBeenSet; }
  template <typename ListenerAddressT = Aws::String>
  void SetListenerAddress(ListenerAddressT&& value) {
    m_listenerAddressHasBeenSet = true;
    m_listenerAddress = std::forward<ListenerAddressT>(value);
  }
  template <typename ListenerAddressT = Aws::String>
  Output& WithListenerAddress(ListenerAddressT&& value) {
    SetListenerAddress(std::forward<ListenerAddressT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMediaLiveInputArn() const { return m_mediaLiveInputArn; }
  inline bool MediaLiveInputArnHasBeenSet() const { return m_mediaLiveInputArnHasBeenSet; }
  template <typename MediaLiveInputArnT = Aws::String>
  void SetMediaLiveInputArn(MediaLiveInputArnT&& value) {
    m_mediaLiveInputArnHasBeenSet = true;
    m_mediaLiveInputArn = std::forward<MediaLiveInputArnT>(value);
  }
  template <typename MediaLiveInputArnT = Aws::String>
  Output& WithMediaLiveInputArn(MediaLiveInputArnT&& value) {
    SetMediaLiveInputArn(std::forward<MediaLiveInputArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<MediaStreamOutputConfiguration>& GetMediaStreamOutputConfigurations() const {
    return m_mediaStreamOutputConfigurations;
  }
  inline bool MediaStreamOutputConfigurationsHasBeenSet() const { return m_mediaStreamOutputConfigurationsHasBeenSet; }
  template <typename MediaStreamOutputConfigurationsT = Aws::Vector<MediaStreamOutputConfiguration>>
  void SetMediaStreamOutputConfigurations(MediaStreamOutputConfigurationsT&& value) {
    m_mediaStreamOutputConfigurationsHasBeenSet = true;
    m_mediaStreamOutputConfigurations = std::forward<MediaStreamOutputConfigurationsT>(value);
  }
  template <typename MediaStreamOutputConfigurationsT = Aws::Vector<MediaStreamOutputConfiguration>>
  Output& WithMediaStreamOutputConfigurations(MediaStreamOutputConfigurationsT&& value) {
    SetMediaStreamOutputConfigurations(std::forward<MediaStreamOutputConfigurationsT>(value));
    return *this;
  }
  template <typename MediaStreamOutputConfigurationsT = MediaStreamOutputConfiguration>
  Output& AddMediaStreamOutputConfigurations(MediaStreamOutputConfigurationsT&& value) {
    m_mediaStreamOutputConfigurationsHasBeenSet = true;
    m_mediaStreamOutputConfigurations.emplace_back(std::forward<MediaStreamOutputConfigurationsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  Output& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOutputArn() const { return m_outputArn; }
  inline bool OutputArnHasBeenSet() const { return m_outputArnHasBeenSet; }
  template <typename OutputArnT = Aws::String>
  void SetOutputArn(OutputArnT&& value) {
    m_outputArnHasBeenSet = true;
    m_outputArn = std::forward<OutputArnT>(value);
  }
  template <typename OutputArnT = Aws::String>
  Output& WithOutputArn(OutputArnT&& value) {
    SetOutputArn(std::forward<OutputArnT>(value));
    return *this;
  }
 
 
  inline int GetPort() const { return m_port; }
  inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
  inline void SetPort(int value) {
    m_portHasBeenSet = true;
    m_port = value;
  }
  inline Output& WithPort(int value) {
    SetPort(value);
    return *this;
  }
 
 
  inline const Transport& GetTransport() const { return m_transport; }
  inline bool TransportHasBeenSet() const { return m_transportHasBeenSet; }
  template <typename TransportT = Transport>
  void SetTransport(TransportT&& value) {
    m_transportHasBeenSet = true;
    m_transport = std::forward<TransportT>(value);
  }
  template <typename TransportT = Transport>
  Output& WithTransport(TransportT&& value) {
    SetTransport(std::forward<TransportT>(value));
    return *this;
  }
 
 
  inline const VpcInterfaceAttachment& GetVpcInterfaceAttachment() const { return m_vpcInterfaceAttachment; }
  inline bool VpcInterfaceAttachmentHasBeenSet() const { return m_vpcInterfaceAttachmentHasBeenSet; }
  template <typename VpcInterfaceAttachmentT = VpcInterfaceAttachment>
  void SetVpcInterfaceAttachment(VpcInterfaceAttachmentT&& value) {
    m_vpcInterfaceAttachmentHasBeenSet = true;
    m_vpcInterfaceAttachment = std::forward<VpcInterfaceAttachmentT>(value);
  }
  template <typename VpcInterfaceAttachmentT = VpcInterfaceAttachment>
  Output& WithVpcInterfaceAttachment(VpcInterfaceAttachmentT&& value) {
    SetVpcInterfaceAttachment(std::forward<VpcInterfaceAttachmentT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBridgeArn() const { return m_bridgeArn; }
  inline bool BridgeArnHasBeenSet() const { return m_bridgeArnHasBeenSet; }
  template <typename BridgeArnT = Aws::String>
  void SetBridgeArn(BridgeArnT&& value) {
    m_bridgeArnHasBeenSet = true;
    m_bridgeArn = std::forward<BridgeArnT>(value);
  }
  template <typename BridgeArnT = Aws::String>
  Output& WithBridgeArn(BridgeArnT&& value) {
    SetBridgeArn(std::forward<BridgeArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<int>& GetBridgePorts() const { return m_bridgePorts; }
  inline bool BridgePortsHasBeenSet() const { return m_bridgePortsHasBeenSet; }
  template <typename BridgePortsT = Aws::Vector<int>>
  void SetBridgePorts(BridgePortsT&& value) {
    m_bridgePortsHasBeenSet = true;
    m_bridgePorts = std::forward<BridgePortsT>(value);
  }
  template <typename BridgePortsT = Aws::Vector<int>>
  Output& WithBridgePorts(BridgePortsT&& value) {
    SetBridgePorts(std::forward<BridgePortsT>(value));
    return *this;
  }
  inline Output& AddBridgePorts(int value) {
    m_bridgePortsHasBeenSet = true;
    m_bridgePorts.push_back(value);
    return *this;
  }
 
 
  inline OutputStatus GetOutputStatus() const { return m_outputStatus; }
  inline bool OutputStatusHasBeenSet() const { return m_outputStatusHasBeenSet; }
  inline void SetOutputStatus(OutputStatus value) {
    m_outputStatusHasBeenSet = true;
    m_outputStatus = value;
  }
  inline Output& WithOutputStatus(OutputStatus value) {
    SetOutputStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetPeerIpAddress() const { return m_peerIpAddress; }
  inline bool PeerIpAddressHasBeenSet() const { return m_peerIpAddressHasBeenSet; }
  template <typename PeerIpAddressT = Aws::String>
  void SetPeerIpAddress(PeerIpAddressT&& value) {
    m_peerIpAddressHasBeenSet = true;
    m_peerIpAddress = std::forward<PeerIpAddressT>(value);
  }
  template <typename PeerIpAddressT = Aws::String>
  Output& WithPeerIpAddress(PeerIpAddressT&& value) {
    SetPeerIpAddress(std::forward<PeerIpAddressT>(value));
    return *this;
  }
 
 
  inline State GetRouterIntegrationState() const { return m_routerIntegrationState; }
  inline bool RouterIntegrationStateHasBeenSet() const { return m_routerIntegrationStateHasBeenSet; }
  inline void SetRouterIntegrationState(State value) {
    m_routerIntegrationStateHasBeenSet = true;
    m_routerIntegrationState = value;
  }
  inline Output& WithRouterIntegrationState(State value) {
    SetRouterIntegrationState(value);
    return *this;
  }
 
 
  inline const FlowTransitEncryption& GetRouterIntegrationTransitEncryption() const { return m_routerIntegrationTransitEncryption; }
  inline bool RouterIntegrationTransitEncryptionHasBeenSet() const { return m_routerIntegrationTransitEncryptionHasBeenSet; }
  template <typename RouterIntegrationTransitEncryptionT = FlowTransitEncryption>
  void SetRouterIntegrationTransitEncryption(RouterIntegrationTransitEncryptionT&& value) {
    m_routerIntegrationTransitEncryptionHasBeenSet = true;
    m_routerIntegrationTransitEncryption = std::forward<RouterIntegrationTransitEncryptionT>(value);
  }
  template <typename RouterIntegrationTransitEncryptionT = FlowTransitEncryption>
  Output& WithRouterIntegrationTransitEncryption(RouterIntegrationTransitEncryptionT&& value) {
    SetRouterIntegrationTransitEncryption(std::forward<RouterIntegrationTransitEncryptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConnectedRouterInputArn() const { return m_connectedRouterInputArn; }
  inline bool ConnectedRouterInputArnHasBeenSet() const { return m_connectedRouterInputArnHasBeenSet; }
  template <typename ConnectedRouterInputArnT = Aws::String>
  void SetConnectedRouterInputArn(ConnectedRouterInputArnT&& value) {
    m_connectedRouterInputArnHasBeenSet = true;
    m_connectedRouterInputArn = std::forward<ConnectedRouterInputArnT>(value);
  }
  template <typename ConnectedRouterInputArnT = Aws::String>
  Output& WithConnectedRouterInputArn(ConnectedRouterInputArnT&& value) {
    SetConnectedRouterInputArn(std::forward<ConnectedRouterInputArnT>(value));
    return *this;
  }
 private:
  int m_dataTransferSubscriberFeePercent{0};
 
  Aws::String m_description;
 
  Aws::String m_destination;
 
  Encryption m_encryption;
 
  Aws::String m_entitlementArn;
 
  Aws::String m_listenerAddress;
 
  Aws::String m_mediaLiveInputArn;
 
  Aws::Vector<MediaStreamOutputConfiguration> m_mediaStreamOutputConfigurations;
 
  Aws::String m_name;
 
  Aws::String m_outputArn;
 
  int m_port{0};
 
  Transport m_transport;
 
  VpcInterfaceAttachment m_vpcInterfaceAttachment;
 
  Aws::String m_bridgeArn;
 
  Aws::Vector<int> m_bridgePorts;
 
  OutputStatus m_outputStatus{OutputStatus::NOT_SET};
 
  Aws::String m_peerIpAddress;
 
  State m_routerIntegrationState{State::NOT_SET};
 
  FlowTransitEncryption m_routerIntegrationTransitEncryption;
 
  Aws::String m_connectedRouterInputArn;
  bool m_dataTransferSubscriberFeePercentHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_destinationHasBeenSet = false;
  bool m_encryptionHasBeenSet = false;
  bool m_entitlementArnHasBeenSet = false;
  bool m_listenerAddressHasBeenSet = false;
  bool m_mediaLiveInputArnHasBeenSet = false;
  bool m_mediaStreamOutputConfigurationsHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_outputArnHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_transportHasBeenSet = false;
  bool m_vpcInterfaceAttachmentHasBeenSet = false;
  bool m_bridgeArnHasBeenSet = false;
  bool m_bridgePortsHasBeenSet = false;
  bool m_outputStatusHasBeenSet = false;
  bool m_peerIpAddressHasBeenSet = false;
  bool m_routerIntegrationStateHasBeenSet = false;
  bool m_routerIntegrationTransitEncryptionHasBeenSet = false;
  bool m_connectedRouterInputArnHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConnect
}  // namespace Aws