GetCommandInvocationResult.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/ssm/SSM_EXPORTS.h>
#include <aws/ssm/model/CloudWatchOutputConfig.h>
#include <aws/ssm/model/CommandInvocationStatus.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace SSM {
namespace Model {
class GetCommandInvocationResult {
 public:
  AWS_SSM_API GetCommandInvocationResult() = default;
  AWS_SSM_API GetCommandInvocationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_SSM_API GetCommandInvocationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetCommandId() const { return m_commandId; }
  template <typename CommandIdT = Aws::String>
  void SetCommandId(CommandIdT&& value) {
    m_commandIdHasBeenSet = true;
    m_commandId = std::forward<CommandIdT>(value);
  }
  template <typename CommandIdT = Aws::String>
  GetCommandInvocationResult& WithCommandId(CommandIdT&& value) {
    SetCommandId(std::forward<CommandIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceId() const { return m_instanceId; }
  template <typename InstanceIdT = Aws::String>
  void SetInstanceId(InstanceIdT&& value) {
    m_instanceIdHasBeenSet = true;
    m_instanceId = std::forward<InstanceIdT>(value);
  }
  template <typename InstanceIdT = Aws::String>
  GetCommandInvocationResult& WithInstanceId(InstanceIdT&& value) {
    SetInstanceId(std::forward<InstanceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetComment() const { return m_comment; }
  template <typename CommentT = Aws::String>
  void SetComment(CommentT&& value) {
    m_commentHasBeenSet = true;
    m_comment = std::forward<CommentT>(value);
  }
  template <typename CommentT = Aws::String>
  GetCommandInvocationResult& WithComment(CommentT&& value) {
    SetComment(std::forward<CommentT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDocumentName() const { return m_documentName; }
  template <typename DocumentNameT = Aws::String>
  void SetDocumentName(DocumentNameT&& value) {
    m_documentNameHasBeenSet = true;
    m_documentName = std::forward<DocumentNameT>(value);
  }
  template <typename DocumentNameT = Aws::String>
  GetCommandInvocationResult& WithDocumentName(DocumentNameT&& value) {
    SetDocumentName(std::forward<DocumentNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDocumentVersion() const { return m_documentVersion; }
  template <typename DocumentVersionT = Aws::String>
  void SetDocumentVersion(DocumentVersionT&& value) {
    m_documentVersionHasBeenSet = true;
    m_documentVersion = std::forward<DocumentVersionT>(value);
  }
  template <typename DocumentVersionT = Aws::String>
  GetCommandInvocationResult& WithDocumentVersion(DocumentVersionT&& value) {
    SetDocumentVersion(std::forward<DocumentVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPluginName() const { return m_pluginName; }
  template <typename PluginNameT = Aws::String>
  void SetPluginName(PluginNameT&& value) {
    m_pluginNameHasBeenSet = true;
    m_pluginName = std::forward<PluginNameT>(value);
  }
  template <typename PluginNameT = Aws::String>
  GetCommandInvocationResult& WithPluginName(PluginNameT&& value) {
    SetPluginName(std::forward<PluginNameT>(value));
    return *this;
  }
 
 
  inline int GetResponseCode() const { return m_responseCode; }
  inline void SetResponseCode(int value) {
    m_responseCodeHasBeenSet = true;
    m_responseCode = value;
  }
  inline GetCommandInvocationResult& WithResponseCode(int value) {
    SetResponseCode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetExecutionStartDateTime() const { return m_executionStartDateTime; }
  template <typename ExecutionStartDateTimeT = Aws::String>
  void SetExecutionStartDateTime(ExecutionStartDateTimeT&& value) {
    m_executionStartDateTimeHasBeenSet = true;
    m_executionStartDateTime = std::forward<ExecutionStartDateTimeT>(value);
  }
  template <typename ExecutionStartDateTimeT = Aws::String>
  GetCommandInvocationResult& WithExecutionStartDateTime(ExecutionStartDateTimeT&& value) {
    SetExecutionStartDateTime(std::forward<ExecutionStartDateTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutionElapsedTime() const { return m_executionElapsedTime; }
  template <typename ExecutionElapsedTimeT = Aws::String>
  void SetExecutionElapsedTime(ExecutionElapsedTimeT&& value) {
    m_executionElapsedTimeHasBeenSet = true;
    m_executionElapsedTime = std::forward<ExecutionElapsedTimeT>(value);
  }
  template <typename ExecutionElapsedTimeT = Aws::String>
  GetCommandInvocationResult& WithExecutionElapsedTime(ExecutionElapsedTimeT&& value) {
    SetExecutionElapsedTime(std::forward<ExecutionElapsedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutionEndDateTime() const { return m_executionEndDateTime; }
  template <typename ExecutionEndDateTimeT = Aws::String>
  void SetExecutionEndDateTime(ExecutionEndDateTimeT&& value) {
    m_executionEndDateTimeHasBeenSet = true;
    m_executionEndDateTime = std::forward<ExecutionEndDateTimeT>(value);
  }
  template <typename ExecutionEndDateTimeT = Aws::String>
  GetCommandInvocationResult& WithExecutionEndDateTime(ExecutionEndDateTimeT&& value) {
    SetExecutionEndDateTime(std::forward<ExecutionEndDateTimeT>(value));
    return *this;
  }
 
 
  inline CommandInvocationStatus GetStatus() const { return m_status; }
  inline void SetStatus(CommandInvocationStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline GetCommandInvocationResult& WithStatus(CommandInvocationStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStatusDetails() const { return m_statusDetails; }
  template <typename StatusDetailsT = Aws::String>
  void SetStatusDetails(StatusDetailsT&& value) {
    m_statusDetailsHasBeenSet = true;
    m_statusDetails = std::forward<StatusDetailsT>(value);
  }
  template <typename StatusDetailsT = Aws::String>
  GetCommandInvocationResult& WithStatusDetails(StatusDetailsT&& value) {
    SetStatusDetails(std::forward<StatusDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStandardOutputContent() const { return m_standardOutputContent; }
  template <typename StandardOutputContentT = Aws::String>
  void SetStandardOutputContent(StandardOutputContentT&& value) {
    m_standardOutputContentHasBeenSet = true;
    m_standardOutputContent = std::forward<StandardOutputContentT>(value);
  }
  template <typename StandardOutputContentT = Aws::String>
  GetCommandInvocationResult& WithStandardOutputContent(StandardOutputContentT&& value) {
    SetStandardOutputContent(std::forward<StandardOutputContentT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStandardOutputUrl() const { return m_standardOutputUrl; }
  template <typename StandardOutputUrlT = Aws::String>
  void SetStandardOutputUrl(StandardOutputUrlT&& value) {
    m_standardOutputUrlHasBeenSet = true;
    m_standardOutputUrl = std::forward<StandardOutputUrlT>(value);
  }
  template <typename StandardOutputUrlT = Aws::String>
  GetCommandInvocationResult& WithStandardOutputUrl(StandardOutputUrlT&& value) {
    SetStandardOutputUrl(std::forward<StandardOutputUrlT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStandardErrorContent() const { return m_standardErrorContent; }
  template <typename StandardErrorContentT = Aws::String>
  void SetStandardErrorContent(StandardErrorContentT&& value) {
    m_standardErrorContentHasBeenSet = true;
    m_standardErrorContent = std::forward<StandardErrorContentT>(value);
  }
  template <typename StandardErrorContentT = Aws::String>
  GetCommandInvocationResult& WithStandardErrorContent(StandardErrorContentT&& value) {
    SetStandardErrorContent(std::forward<StandardErrorContentT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStandardErrorUrl() const { return m_standardErrorUrl; }
  template <typename StandardErrorUrlT = Aws::String>
  void SetStandardErrorUrl(StandardErrorUrlT&& value) {
    m_standardErrorUrlHasBeenSet = true;
    m_standardErrorUrl = std::forward<StandardErrorUrlT>(value);
  }
  template <typename StandardErrorUrlT = Aws::String>
  GetCommandInvocationResult& WithStandardErrorUrl(StandardErrorUrlT&& value) {
    SetStandardErrorUrl(std::forward<StandardErrorUrlT>(value));
    return *this;
  }
 
 
  inline const CloudWatchOutputConfig& GetCloudWatchOutputConfig() const { return m_cloudWatchOutputConfig; }
  template <typename CloudWatchOutputConfigT = CloudWatchOutputConfig>
  void SetCloudWatchOutputConfig(CloudWatchOutputConfigT&& value) {
    m_cloudWatchOutputConfigHasBeenSet = true;
    m_cloudWatchOutputConfig = std::forward<CloudWatchOutputConfigT>(value);
  }
  template <typename CloudWatchOutputConfigT = CloudWatchOutputConfig>
  GetCommandInvocationResult& WithCloudWatchOutputConfig(CloudWatchOutputConfigT&& value) {
    SetCloudWatchOutputConfig(std::forward<CloudWatchOutputConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  GetCommandInvocationResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
 private:
  Aws::String m_commandId;
 
  Aws::String m_instanceId;
 
  Aws::String m_comment;
 
  Aws::String m_documentName;
 
  Aws::String m_documentVersion;
 
  Aws::String m_pluginName;
 
  int m_responseCode{0};
 
  Aws::String m_executionStartDateTime;
 
  Aws::String m_executionElapsedTime;
 
  Aws::String m_executionEndDateTime;
 
  CommandInvocationStatus m_status{CommandInvocationStatus::NOT_SET};
 
  Aws::String m_statusDetails;
 
  Aws::String m_standardOutputContent;
 
  Aws::String m_standardOutputUrl;
 
  Aws::String m_standardErrorContent;
 
  Aws::String m_standardErrorUrl;
 
  CloudWatchOutputConfig m_cloudWatchOutputConfig;
 
  Aws::String m_requestId;
  bool m_commandIdHasBeenSet = false;
  bool m_instanceIdHasBeenSet = false;
  bool m_commentHasBeenSet = false;
  bool m_documentNameHasBeenSet = false;
  bool m_documentVersionHasBeenSet = false;
  bool m_pluginNameHasBeenSet = false;
  bool m_responseCodeHasBeenSet = false;
  bool m_executionStartDateTimeHasBeenSet = false;
  bool m_executionElapsedTimeHasBeenSet = false;
  bool m_executionEndDateTimeHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statusDetailsHasBeenSet = false;
  bool m_standardOutputContentHasBeenSet = false;
  bool m_standardOutputUrlHasBeenSet = false;
  bool m_standardErrorContentHasBeenSet = false;
  bool m_standardErrorUrlHasBeenSet = false;
  bool m_cloudWatchOutputConfigHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SSM
}  // namespace Aws