Integration.h

 
#pragma once
#include <aws/apigateway/APIGateway_EXPORTS.h>
#include <aws/apigateway/model/ConnectionType.h>
#include <aws/apigateway/model/ContentHandlingStrategy.h>
#include <aws/apigateway/model/IntegrationResponse.h>
#include <aws/apigateway/model/IntegrationType.h>
#include <aws/apigateway/model/ResponseTransferMode.h>
#include <aws/apigateway/model/TlsConfig.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace APIGateway {
namespace Model {
 
class Integration {
 public:
  AWS_APIGATEWAY_API Integration() = default;
  AWS_APIGATEWAY_API Integration(Aws::Utils::Json::JsonView jsonValue);
  AWS_APIGATEWAY_API Integration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_APIGATEWAY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline IntegrationType GetType() const { return m_type; }
  inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
  inline void SetType(IntegrationType value) {
    m_typeHasBeenSet = true;
    m_type = value;
  }
  inline Integration& WithType(IntegrationType value) {
    SetType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetHttpMethod() const { return m_httpMethod; }
  inline bool HttpMethodHasBeenSet() const { return m_httpMethodHasBeenSet; }
  template <typename HttpMethodT = Aws::String>
  void SetHttpMethod(HttpMethodT&& value) {
    m_httpMethodHasBeenSet = true;
    m_httpMethod = std::forward<HttpMethodT>(value);
  }
  template <typename HttpMethodT = Aws::String>
  Integration& WithHttpMethod(HttpMethodT&& value) {
    SetHttpMethod(std::forward<HttpMethodT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUri() const { return m_uri; }
  inline bool UriHasBeenSet() const { return m_uriHasBeenSet; }
  template <typename UriT = Aws::String>
  void SetUri(UriT&& value) {
    m_uriHasBeenSet = true;
    m_uri = std::forward<UriT>(value);
  }
  template <typename UriT = Aws::String>
  Integration& WithUri(UriT&& value) {
    SetUri(std::forward<UriT>(value));
    return *this;
  }
 
 
  inline ConnectionType GetConnectionType() const { return m_connectionType; }
  inline bool ConnectionTypeHasBeenSet() const { return m_connectionTypeHasBeenSet; }
  inline void SetConnectionType(ConnectionType value) {
    m_connectionTypeHasBeenSet = true;
    m_connectionType = value;
  }
  inline Integration& WithConnectionType(ConnectionType value) {
    SetConnectionType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetConnectionId() const { return m_connectionId; }
  inline bool ConnectionIdHasBeenSet() const { return m_connectionIdHasBeenSet; }
  template <typename ConnectionIdT = Aws::String>
  void SetConnectionId(ConnectionIdT&& value) {
    m_connectionIdHasBeenSet = true;
    m_connectionId = std::forward<ConnectionIdT>(value);
  }
  template <typename ConnectionIdT = Aws::String>
  Integration& WithConnectionId(ConnectionIdT&& value) {
    SetConnectionId(std::forward<ConnectionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCredentials() const { return m_credentials; }
  inline bool CredentialsHasBeenSet() const { return m_credentialsHasBeenSet; }
  template <typename CredentialsT = Aws::String>
  void SetCredentials(CredentialsT&& value) {
    m_credentialsHasBeenSet = true;
    m_credentials = std::forward<CredentialsT>(value);
  }
  template <typename CredentialsT = Aws::String>
  Integration& WithCredentials(CredentialsT&& value) {
    SetCredentials(std::forward<CredentialsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetRequestParameters() const { return m_requestParameters; }
  inline bool RequestParametersHasBeenSet() const { return m_requestParametersHasBeenSet; }
  template <typename RequestParametersT = Aws::Map<Aws::String, Aws::String>>
  void SetRequestParameters(RequestParametersT&& value) {
    m_requestParametersHasBeenSet = true;
    m_requestParameters = std::forward<RequestParametersT>(value);
  }
  template <typename RequestParametersT = Aws::Map<Aws::String, Aws::String>>
  Integration& WithRequestParameters(RequestParametersT&& value) {
    SetRequestParameters(std::forward<RequestParametersT>(value));
    return *this;
  }
  template <typename RequestParametersKeyT = Aws::String, typename RequestParametersValueT = Aws::String>
  Integration& AddRequestParameters(RequestParametersKeyT&& key, RequestParametersValueT&& value) {
    m_requestParametersHasBeenSet = true;
    m_requestParameters.emplace(std::forward<RequestParametersKeyT>(key), std::forward<RequestParametersValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetRequestTemplates() const { return m_requestTemplates; }
  inline bool RequestTemplatesHasBeenSet() const { return m_requestTemplatesHasBeenSet; }
  template <typename RequestTemplatesT = Aws::Map<Aws::String, Aws::String>>
  void SetRequestTemplates(RequestTemplatesT&& value) {
    m_requestTemplatesHasBeenSet = true;
    m_requestTemplates = std::forward<RequestTemplatesT>(value);
  }
  template <typename RequestTemplatesT = Aws::Map<Aws::String, Aws::String>>
  Integration& WithRequestTemplates(RequestTemplatesT&& value) {
    SetRequestTemplates(std::forward<RequestTemplatesT>(value));
    return *this;
  }
  template <typename RequestTemplatesKeyT = Aws::String, typename RequestTemplatesValueT = Aws::String>
  Integration& AddRequestTemplates(RequestTemplatesKeyT&& key, RequestTemplatesValueT&& value) {
    m_requestTemplatesHasBeenSet = true;
    m_requestTemplates.emplace(std::forward<RequestTemplatesKeyT>(key), std::forward<RequestTemplatesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPassthroughBehavior() const { return m_passthroughBehavior; }
  inline bool PassthroughBehaviorHasBeenSet() const { return m_passthroughBehaviorHasBeenSet; }
  template <typename PassthroughBehaviorT = Aws::String>
  void SetPassthroughBehavior(PassthroughBehaviorT&& value) {
    m_passthroughBehaviorHasBeenSet = true;
    m_passthroughBehavior = std::forward<PassthroughBehaviorT>(value);
  }
  template <typename PassthroughBehaviorT = Aws::String>
  Integration& WithPassthroughBehavior(PassthroughBehaviorT&& value) {
    SetPassthroughBehavior(std::forward<PassthroughBehaviorT>(value));
    return *this;
  }
 
 
  inline ContentHandlingStrategy GetContentHandling() const { return m_contentHandling; }
  inline bool ContentHandlingHasBeenSet() const { return m_contentHandlingHasBeenSet; }
  inline void SetContentHandling(ContentHandlingStrategy value) {
    m_contentHandlingHasBeenSet = true;
    m_contentHandling = value;
  }
  inline Integration& WithContentHandling(ContentHandlingStrategy value) {
    SetContentHandling(value);
    return *this;
  }
 
 
  inline int GetTimeoutInMillis() const { return m_timeoutInMillis; }
  inline bool TimeoutInMillisHasBeenSet() const { return m_timeoutInMillisHasBeenSet; }
  inline void SetTimeoutInMillis(int value) {
    m_timeoutInMillisHasBeenSet = true;
    m_timeoutInMillis = value;
  }
  inline Integration& WithTimeoutInMillis(int value) {
    SetTimeoutInMillis(value);
    return *this;
  }
 
 
  inline const Aws::String& GetCacheNamespace() const { return m_cacheNamespace; }
  inline bool CacheNamespaceHasBeenSet() const { return m_cacheNamespaceHasBeenSet; }
  template <typename CacheNamespaceT = Aws::String>
  void SetCacheNamespace(CacheNamespaceT&& value) {
    m_cacheNamespaceHasBeenSet = true;
    m_cacheNamespace = std::forward<CacheNamespaceT>(value);
  }
  template <typename CacheNamespaceT = Aws::String>
  Integration& WithCacheNamespace(CacheNamespaceT&& value) {
    SetCacheNamespace(std::forward<CacheNamespaceT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetCacheKeyParameters() const { return m_cacheKeyParameters; }
  inline bool CacheKeyParametersHasBeenSet() const { return m_cacheKeyParametersHasBeenSet; }
  template <typename CacheKeyParametersT = Aws::Vector<Aws::String>>
  void SetCacheKeyParameters(CacheKeyParametersT&& value) {
    m_cacheKeyParametersHasBeenSet = true;
    m_cacheKeyParameters = std::forward<CacheKeyParametersT>(value);
  }
  template <typename CacheKeyParametersT = Aws::Vector<Aws::String>>
  Integration& WithCacheKeyParameters(CacheKeyParametersT&& value) {
    SetCacheKeyParameters(std::forward<CacheKeyParametersT>(value));
    return *this;
  }
  template <typename CacheKeyParametersT = Aws::String>
  Integration& AddCacheKeyParameters(CacheKeyParametersT&& value) {
    m_cacheKeyParametersHasBeenSet = true;
    m_cacheKeyParameters.emplace_back(std::forward<CacheKeyParametersT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, IntegrationResponse>& GetIntegrationResponses() const { return m_integrationResponses; }
  inline bool IntegrationResponsesHasBeenSet() const { return m_integrationResponsesHasBeenSet; }
  template <typename IntegrationResponsesT = Aws::Map<Aws::String, IntegrationResponse>>
  void SetIntegrationResponses(IntegrationResponsesT&& value) {
    m_integrationResponsesHasBeenSet = true;
    m_integrationResponses = std::forward<IntegrationResponsesT>(value);
  }
  template <typename IntegrationResponsesT = Aws::Map<Aws::String, IntegrationResponse>>
  Integration& WithIntegrationResponses(IntegrationResponsesT&& value) {
    SetIntegrationResponses(std::forward<IntegrationResponsesT>(value));
    return *this;
  }
  template <typename IntegrationResponsesKeyT = Aws::String, typename IntegrationResponsesValueT = IntegrationResponse>
  Integration& AddIntegrationResponses(IntegrationResponsesKeyT&& key, IntegrationResponsesValueT&& value) {
    m_integrationResponsesHasBeenSet = true;
    m_integrationResponses.emplace(std::forward<IntegrationResponsesKeyT>(key), std::forward<IntegrationResponsesValueT>(value));
    return *this;
  }
 
 
  inline const TlsConfig& GetTlsConfig() const { return m_tlsConfig; }
  inline bool TlsConfigHasBeenSet() const { return m_tlsConfigHasBeenSet; }
  template <typename TlsConfigT = TlsConfig>
  void SetTlsConfig(TlsConfigT&& value) {
    m_tlsConfigHasBeenSet = true;
    m_tlsConfig = std::forward<TlsConfigT>(value);
  }
  template <typename TlsConfigT = TlsConfig>
  Integration& WithTlsConfig(TlsConfigT&& value) {
    SetTlsConfig(std::forward<TlsConfigT>(value));
    return *this;
  }
 
 
  inline ResponseTransferMode GetResponseTransferMode() const { return m_responseTransferMode; }
  inline bool ResponseTransferModeHasBeenSet() const { return m_responseTransferModeHasBeenSet; }
  inline void SetResponseTransferMode(ResponseTransferMode value) {
    m_responseTransferModeHasBeenSet = true;
    m_responseTransferMode = value;
  }
  inline Integration& WithResponseTransferMode(ResponseTransferMode value) {
    SetResponseTransferMode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetIntegrationTarget() const { return m_integrationTarget; }
  inline bool IntegrationTargetHasBeenSet() const { return m_integrationTargetHasBeenSet; }
  template <typename IntegrationTargetT = Aws::String>
  void SetIntegrationTarget(IntegrationTargetT&& value) {
    m_integrationTargetHasBeenSet = true;
    m_integrationTarget = std::forward<IntegrationTargetT>(value);
  }
  template <typename IntegrationTargetT = Aws::String>
  Integration& WithIntegrationTarget(IntegrationTargetT&& value) {
    SetIntegrationTarget(std::forward<IntegrationTargetT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  inline bool RequestIdHasBeenSet() const { return m_requestIdHasBeenSet; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  Integration& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
 private:
  IntegrationType m_type{IntegrationType::NOT_SET};
 
  Aws::String m_httpMethod;
 
  Aws::String m_uri;
 
  ConnectionType m_connectionType{ConnectionType::NOT_SET};
 
  Aws::String m_connectionId;
 
  Aws::String m_credentials;
 
  Aws::Map<Aws::String, Aws::String> m_requestParameters;
 
  Aws::Map<Aws::String, Aws::String> m_requestTemplates;
 
  Aws::String m_passthroughBehavior;
 
  ContentHandlingStrategy m_contentHandling{ContentHandlingStrategy::NOT_SET};
 
  int m_timeoutInMillis{0};
 
  Aws::String m_cacheNamespace;
 
  Aws::Vector<Aws::String> m_cacheKeyParameters;
 
  Aws::Map<Aws::String, IntegrationResponse> m_integrationResponses;
 
  TlsConfig m_tlsConfig;
 
  ResponseTransferMode m_responseTransferMode{ResponseTransferMode::NOT_SET};
 
  Aws::String m_integrationTarget;
 
  Aws::String m_requestId;
  bool m_typeHasBeenSet = false;
  bool m_httpMethodHasBeenSet = false;
  bool m_uriHasBeenSet = false;
  bool m_connectionTypeHasBeenSet = false;
  bool m_connectionIdHasBeenSet = false;
  bool m_credentialsHasBeenSet = false;
  bool m_requestParametersHasBeenSet = false;
  bool m_requestTemplatesHasBeenSet = false;
  bool m_passthroughBehaviorHasBeenSet = false;
  bool m_contentHandlingHasBeenSet = false;
  bool m_timeoutInMillisHasBeenSet = false;
  bool m_cacheNamespaceHasBeenSet = false;
  bool m_cacheKeyParametersHasBeenSet = false;
  bool m_integrationResponsesHasBeenSet = false;
  bool m_tlsConfigHasBeenSet = false;
  bool m_responseTransferModeHasBeenSet = false;
  bool m_integrationTargetHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace APIGateway
}  // namespace Aws