PutIntegrationRequest.h

 
#pragma once
#include <aws/apigateway/APIGatewayRequest.h>
#include <aws/apigateway/APIGateway_EXPORTS.h>
#include <aws/apigateway/model/ConnectionType.h>
#include <aws/apigateway/model/ContentHandlingStrategy.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 APIGateway {
namespace Model {
 
class PutIntegrationRequest : public APIGatewayRequest {
 public:
  AWS_APIGATEWAY_API PutIntegrationRequest() = 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 "PutIntegration"; }
 
  AWS_APIGATEWAY_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetRestApiId() const { return m_restApiId; }
  inline bool RestApiIdHasBeenSet() const { return m_restApiIdHasBeenSet; }
  template <typename RestApiIdT = Aws::String>
  void SetRestApiId(RestApiIdT&& value) {
    m_restApiIdHasBeenSet = true;
    m_restApiId = std::forward<RestApiIdT>(value);
  }
  template <typename RestApiIdT = Aws::String>
  PutIntegrationRequest& WithRestApiId(RestApiIdT&& value) {
    SetRestApiId(std::forward<RestApiIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourceId() const { return m_resourceId; }
  inline bool ResourceIdHasBeenSet() const { return m_resourceIdHasBeenSet; }
  template <typename ResourceIdT = Aws::String>
  void SetResourceId(ResourceIdT&& value) {
    m_resourceIdHasBeenSet = true;
    m_resourceId = std::forward<ResourceIdT>(value);
  }
  template <typename ResourceIdT = Aws::String>
  PutIntegrationRequest& WithResourceId(ResourceIdT&& value) {
    SetResourceId(std::forward<ResourceIdT>(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>
  PutIntegrationRequest& WithHttpMethod(HttpMethodT&& value) {
    SetHttpMethod(std::forward<HttpMethodT>(value));
    return *this;
  }
 
 
  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 PutIntegrationRequest& WithType(IntegrationType value) {
    SetType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetIntegrationHttpMethod() const { return m_integrationHttpMethod; }
  inline bool IntegrationHttpMethodHasBeenSet() const { return m_integrationHttpMethodHasBeenSet; }
  template <typename IntegrationHttpMethodT = Aws::String>
  void SetIntegrationHttpMethod(IntegrationHttpMethodT&& value) {
    m_integrationHttpMethodHasBeenSet = true;
    m_integrationHttpMethod = std::forward<IntegrationHttpMethodT>(value);
  }
  template <typename IntegrationHttpMethodT = Aws::String>
  PutIntegrationRequest& WithIntegrationHttpMethod(IntegrationHttpMethodT&& value) {
    SetIntegrationHttpMethod(std::forward<IntegrationHttpMethodT>(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>
  PutIntegrationRequest& 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 PutIntegrationRequest& 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>
  PutIntegrationRequest& 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>
  PutIntegrationRequest& 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>>
  PutIntegrationRequest& WithRequestParameters(RequestParametersT&& value) {
    SetRequestParameters(std::forward<RequestParametersT>(value));
    return *this;
  }
  template <typename RequestParametersKeyT = Aws::String, typename RequestParametersValueT = Aws::String>
  PutIntegrationRequest& 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>>
  PutIntegrationRequest& WithRequestTemplates(RequestTemplatesT&& value) {
    SetRequestTemplates(std::forward<RequestTemplatesT>(value));
    return *this;
  }
  template <typename RequestTemplatesKeyT = Aws::String, typename RequestTemplatesValueT = Aws::String>
  PutIntegrationRequest& 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>
  PutIntegrationRequest& WithPassthroughBehavior(PassthroughBehaviorT&& value) {
    SetPassthroughBehavior(std::forward<PassthroughBehaviorT>(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>
  PutIntegrationRequest& 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>>
  PutIntegrationRequest& WithCacheKeyParameters(CacheKeyParametersT&& value) {
    SetCacheKeyParameters(std::forward<CacheKeyParametersT>(value));
    return *this;
  }
  template <typename CacheKeyParametersT = Aws::String>
  PutIntegrationRequest& AddCacheKeyParameters(CacheKeyParametersT&& value) {
    m_cacheKeyParametersHasBeenSet = true;
    m_cacheKeyParameters.emplace_back(std::forward<CacheKeyParametersT>(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 PutIntegrationRequest& 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 PutIntegrationRequest& WithTimeoutInMillis(int value) {
    SetTimeoutInMillis(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>
  PutIntegrationRequest& 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 PutIntegrationRequest& 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>
  PutIntegrationRequest& WithIntegrationTarget(IntegrationTargetT&& value) {
    SetIntegrationTarget(std::forward<IntegrationTargetT>(value));
    return *this;
  }
 private:
  Aws::String m_restApiId;
 
  Aws::String m_resourceId;
 
  Aws::String m_httpMethod;
 
  IntegrationType m_type{IntegrationType::NOT_SET};
 
  Aws::String m_integrationHttpMethod;
 
  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;
 
  Aws::String m_cacheNamespace;
 
  Aws::Vector<Aws::String> m_cacheKeyParameters;
 
  ContentHandlingStrategy m_contentHandling{ContentHandlingStrategy::NOT_SET};
 
  int m_timeoutInMillis{0};
 
  TlsConfig m_tlsConfig;
 
  ResponseTransferMode m_responseTransferMode{ResponseTransferMode::NOT_SET};
 
  Aws::String m_integrationTarget;
  bool m_restApiIdHasBeenSet = false;
  bool m_resourceIdHasBeenSet = false;
  bool m_httpMethodHasBeenSet = false;
  bool m_typeHasBeenSet = false;
  bool m_integrationHttpMethodHasBeenSet = 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_cacheNamespaceHasBeenSet = false;
  bool m_cacheKeyParametersHasBeenSet = false;
  bool m_contentHandlingHasBeenSet = false;
  bool m_timeoutInMillisHasBeenSet = false;
  bool m_tlsConfigHasBeenSet = false;
  bool m_responseTransferModeHasBeenSet = false;
  bool m_integrationTargetHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace APIGateway
}  // namespace Aws