SendOutboundWebNotificationRequest.h

 
#pragma once
#include <aws/connect/ConnectRequest.h>
#include <aws/connect/Connect_EXPORTS.h>
#include <aws/connect/model/WebNotificationContent.h>
#include <aws/connect/model/WebNotificationSource.h>
#include <aws/connect/model/WidgetDestination.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/UUID.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Connect {
namespace Model {
 
class SendOutboundWebNotificationRequest : public ConnectRequest {
 public:
  AWS_CONNECT_API SendOutboundWebNotificationRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "SendOutboundWebNotification"; }
 
  AWS_CONNECT_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetInstanceId() const { return m_instanceId; }
  inline bool InstanceIdHasBeenSet() const { return m_instanceIdHasBeenSet; }
  template <typename InstanceIdT = Aws::String>
  void SetInstanceId(InstanceIdT&& value) {
    m_instanceIdHasBeenSet = true;
    m_instanceId = std::forward<InstanceIdT>(value);
  }
  template <typename InstanceIdT = Aws::String>
  SendOutboundWebNotificationRequest& WithInstanceId(InstanceIdT&& value) {
    SetInstanceId(std::forward<InstanceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClientToken() const { return m_clientToken; }
  inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
  template <typename ClientTokenT = Aws::String>
  void SetClientToken(ClientTokenT&& value) {
    m_clientTokenHasBeenSet = true;
    m_clientToken = std::forward<ClientTokenT>(value);
  }
  template <typename ClientTokenT = Aws::String>
  SendOutboundWebNotificationRequest& WithClientToken(ClientTokenT&& value) {
    SetClientToken(std::forward<ClientTokenT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBrowserId() const { return m_browserId; }
  inline bool BrowserIdHasBeenSet() const { return m_browserIdHasBeenSet; }
  template <typename BrowserIdT = Aws::String>
  void SetBrowserId(BrowserIdT&& value) {
    m_browserIdHasBeenSet = true;
    m_browserId = std::forward<BrowserIdT>(value);
  }
  template <typename BrowserIdT = Aws::String>
  SendOutboundWebNotificationRequest& WithBrowserId(BrowserIdT&& value) {
    SetBrowserId(std::forward<BrowserIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSessionId() const { return m_sessionId; }
  inline bool SessionIdHasBeenSet() const { return m_sessionIdHasBeenSet; }
  template <typename SessionIdT = Aws::String>
  void SetSessionId(SessionIdT&& value) {
    m_sessionIdHasBeenSet = true;
    m_sessionId = std::forward<SessionIdT>(value);
  }
  template <typename SessionIdT = Aws::String>
  SendOutboundWebNotificationRequest& WithSessionId(SessionIdT&& value) {
    SetSessionId(std::forward<SessionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetExpiresAt() const { return m_expiresAt; }
  inline bool ExpiresAtHasBeenSet() const { return m_expiresAtHasBeenSet; }
  template <typename ExpiresAtT = Aws::Utils::DateTime>
  void SetExpiresAt(ExpiresAtT&& value) {
    m_expiresAtHasBeenSet = true;
    m_expiresAt = std::forward<ExpiresAtT>(value);
  }
  template <typename ExpiresAtT = Aws::Utils::DateTime>
  SendOutboundWebNotificationRequest& WithExpiresAt(ExpiresAtT&& value) {
    SetExpiresAt(std::forward<ExpiresAtT>(value));
    return *this;
  }
 
 
  inline const WebNotificationSource& GetSource() const { return m_source; }
  inline bool SourceHasBeenSet() const { return m_sourceHasBeenSet; }
  template <typename SourceT = WebNotificationSource>
  void SetSource(SourceT&& value) {
    m_sourceHasBeenSet = true;
    m_source = std::forward<SourceT>(value);
  }
  template <typename SourceT = WebNotificationSource>
  SendOutboundWebNotificationRequest& WithSource(SourceT&& value) {
    SetSource(std::forward<SourceT>(value));
    return *this;
  }
 
 
  inline const WidgetDestination& GetDestination() const { return m_destination; }
  inline bool DestinationHasBeenSet() const { return m_destinationHasBeenSet; }
  template <typename DestinationT = WidgetDestination>
  void SetDestination(DestinationT&& value) {
    m_destinationHasBeenSet = true;
    m_destination = std::forward<DestinationT>(value);
  }
  template <typename DestinationT = WidgetDestination>
  SendOutboundWebNotificationRequest& WithDestination(DestinationT&& value) {
    SetDestination(std::forward<DestinationT>(value));
    return *this;
  }
 
 
  inline const WebNotificationContent& GetContent() const { return m_content; }
  inline bool ContentHasBeenSet() const { return m_contentHasBeenSet; }
  template <typename ContentT = WebNotificationContent>
  void SetContent(ContentT&& value) {
    m_contentHasBeenSet = true;
    m_content = std::forward<ContentT>(value);
  }
  template <typename ContentT = WebNotificationContent>
  SendOutboundWebNotificationRequest& WithContent(ContentT&& value) {
    SetContent(std::forward<ContentT>(value));
    return *this;
  }
 private:
  Aws::String m_instanceId;
 
  Aws::String m_clientToken{Aws::Utils::UUID::PseudoRandomUUID()};
 
  Aws::String m_browserId;
 
  Aws::String m_sessionId;
 
  Aws::Utils::DateTime m_expiresAt{};
 
  WebNotificationSource m_source;
 
  WidgetDestination m_destination;
 
  WebNotificationContent m_content;
  bool m_instanceIdHasBeenSet = false;
  bool m_clientTokenHasBeenSet = true;
  bool m_browserIdHasBeenSet = false;
  bool m_sessionIdHasBeenSet = false;
  bool m_expiresAtHasBeenSet = false;
  bool m_sourceHasBeenSet = false;
  bool m_destinationHasBeenSet = false;
  bool m_contentHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Connect
}  // namespace Aws