ProgressEvent.h

 
#pragma once
#include <aws/cloudcontrol/CloudControlApi_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/cloudcontrol/model/Operation.h>
#include <aws/cloudcontrol/model/OperationStatus.h>
#include <aws/core/utils/DateTime.h>
#include <aws/cloudcontrol/model/HandlerErrorCode.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace CloudControlApi
{
namespace Model
{
 
  class ProgressEvent
  {
  public:
    AWS_CLOUDCONTROLAPI_API ProgressEvent() = default;
    AWS_CLOUDCONTROLAPI_API ProgressEvent(Aws::Utils::Json::JsonView jsonValue);
    AWS_CLOUDCONTROLAPI_API ProgressEvent& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_CLOUDCONTROLAPI_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetTypeName() const { return m_typeName; }
    inline bool TypeNameHasBeenSet() const { return m_typeNameHasBeenSet; }
    template<typename TypeNameT = Aws::String>
    void SetTypeName(TypeNameT&& value) { m_typeNameHasBeenSet = true; m_typeName = std::forward<TypeNameT>(value); }
    template<typename TypeNameT = Aws::String>
    ProgressEvent& WithTypeName(TypeNameT&& value) { SetTypeName(std::forward<TypeNameT>(value)); return *this;}
 
 
    inline const Aws::String& GetIdentifier() const { return m_identifier; }
    inline bool IdentifierHasBeenSet() const { return m_identifierHasBeenSet; }
    template<typename IdentifierT = Aws::String>
    void SetIdentifier(IdentifierT&& value) { m_identifierHasBeenSet = true; m_identifier = std::forward<IdentifierT>(value); }
    template<typename IdentifierT = Aws::String>
    ProgressEvent& WithIdentifier(IdentifierT&& value) { SetIdentifier(std::forward<IdentifierT>(value)); return *this;}
 
 
    inline const Aws::String& GetRequestToken() const { return m_requestToken; }
    inline bool RequestTokenHasBeenSet() const { return m_requestTokenHasBeenSet; }
    template<typename RequestTokenT = Aws::String>
    void SetRequestToken(RequestTokenT&& value) { m_requestTokenHasBeenSet = true; m_requestToken = std::forward<RequestTokenT>(value); }
    template<typename RequestTokenT = Aws::String>
    ProgressEvent& WithRequestToken(RequestTokenT&& value) { SetRequestToken(std::forward<RequestTokenT>(value)); return *this;}
 
 
    inline const Aws::String& GetHooksRequestToken() const { return m_hooksRequestToken; }
    inline bool HooksRequestTokenHasBeenSet() const { return m_hooksRequestTokenHasBeenSet; }
    template<typename HooksRequestTokenT = Aws::String>
    void SetHooksRequestToken(HooksRequestTokenT&& value) { m_hooksRequestTokenHasBeenSet = true; m_hooksRequestToken = std::forward<HooksRequestTokenT>(value); }
    template<typename HooksRequestTokenT = Aws::String>
    ProgressEvent& WithHooksRequestToken(HooksRequestTokenT&& value) { SetHooksRequestToken(std::forward<HooksRequestTokenT>(value)); return *this;}
 
 
    inline Operation GetOperation() const { return m_operation; }
    inline bool OperationHasBeenSet() const { return m_operationHasBeenSet; }
    inline void SetOperation(Operation value) { m_operationHasBeenSet = true; m_operation = value; }
    inline ProgressEvent& WithOperation(Operation value) { SetOperation(value); return *this;}
 
 
    inline OperationStatus GetOperationStatus() const { return m_operationStatus; }
    inline bool OperationStatusHasBeenSet() const { return m_operationStatusHasBeenSet; }
    inline void SetOperationStatus(OperationStatus value) { m_operationStatusHasBeenSet = true; m_operationStatus = value; }
    inline ProgressEvent& WithOperationStatus(OperationStatus value) { SetOperationStatus(value); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetEventTime() const { return m_eventTime; }
    inline bool EventTimeHasBeenSet() const { return m_eventTimeHasBeenSet; }
    template<typename EventTimeT = Aws::Utils::DateTime>
    void SetEventTime(EventTimeT&& value) { m_eventTimeHasBeenSet = true; m_eventTime = std::forward<EventTimeT>(value); }
    template<typename EventTimeT = Aws::Utils::DateTime>
    ProgressEvent& WithEventTime(EventTimeT&& value) { SetEventTime(std::forward<EventTimeT>(value)); return *this;}
 
 
    inline const Aws::String& GetResourceModel() const { return m_resourceModel; }
    inline bool ResourceModelHasBeenSet() const { return m_resourceModelHasBeenSet; }
    template<typename ResourceModelT = Aws::String>
    void SetResourceModel(ResourceModelT&& value) { m_resourceModelHasBeenSet = true; m_resourceModel = std::forward<ResourceModelT>(value); }
    template<typename ResourceModelT = Aws::String>
    ProgressEvent& WithResourceModel(ResourceModelT&& value) { SetResourceModel(std::forward<ResourceModelT>(value)); return *this;}
 
 
    inline const Aws::String& GetStatusMessage() const { return m_statusMessage; }
    inline bool StatusMessageHasBeenSet() const { return m_statusMessageHasBeenSet; }
    template<typename StatusMessageT = Aws::String>
    void SetStatusMessage(StatusMessageT&& value) { m_statusMessageHasBeenSet = true; m_statusMessage = std::forward<StatusMessageT>(value); }
    template<typename StatusMessageT = Aws::String>
    ProgressEvent& WithStatusMessage(StatusMessageT&& value) { SetStatusMessage(std::forward<StatusMessageT>(value)); return *this;}
 
 
    inline HandlerErrorCode GetErrorCode() const { return m_errorCode; }
    inline bool ErrorCodeHasBeenSet() const { return m_errorCodeHasBeenSet; }
    inline void SetErrorCode(HandlerErrorCode value) { m_errorCodeHasBeenSet = true; m_errorCode = value; }
    inline ProgressEvent& WithErrorCode(HandlerErrorCode value) { SetErrorCode(value); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetRetryAfter() const { return m_retryAfter; }
    inline bool RetryAfterHasBeenSet() const { return m_retryAfterHasBeenSet; }
    template<typename RetryAfterT = Aws::Utils::DateTime>
    void SetRetryAfter(RetryAfterT&& value) { m_retryAfterHasBeenSet = true; m_retryAfter = std::forward<RetryAfterT>(value); }
    template<typename RetryAfterT = Aws::Utils::DateTime>
    ProgressEvent& WithRetryAfter(RetryAfterT&& value) { SetRetryAfter(std::forward<RetryAfterT>(value)); return *this;}
  private:
 
    Aws::String m_typeName;
    bool m_typeNameHasBeenSet = false;
 
    Aws::String m_identifier;
    bool m_identifierHasBeenSet = false;
 
    Aws::String m_requestToken;
    bool m_requestTokenHasBeenSet = false;
 
    Aws::String m_hooksRequestToken;
    bool m_hooksRequestTokenHasBeenSet = false;
 
    Operation m_operation{Operation::NOT_SET};
    bool m_operationHasBeenSet = false;
 
    OperationStatus m_operationStatus{OperationStatus::NOT_SET};
    bool m_operationStatusHasBeenSet = false;
 
    Aws::Utils::DateTime m_eventTime{};
    bool m_eventTimeHasBeenSet = false;
 
    Aws::String m_resourceModel;
    bool m_resourceModelHasBeenSet = false;
 
    Aws::String m_statusMessage;
    bool m_statusMessageHasBeenSet = false;
 
    HandlerErrorCode m_errorCode{HandlerErrorCode::NOT_SET};
    bool m_errorCodeHasBeenSet = false;
 
    Aws::Utils::DateTime m_retryAfter{};
    bool m_retryAfterHasBeenSet = false;
  };
 
} // namespace Model
} // namespace CloudControlApi
} // namespace Aws