CreateIntegrationRequest.h

 
#pragma once
#include <aws/apigatewayv2/ApiGatewayV2Request.h>
#include <aws/apigatewayv2/ApiGatewayV2_EXPORTS.h>
#include <aws/apigatewayv2/model/ConnectionType.h>
#include <aws/apigatewayv2/model/ContentHandlingStrategy.h>
#include <aws/apigatewayv2/model/IntegrationType.h>
#include <aws/apigatewayv2/model/PassthroughBehavior.h>
#include <aws/apigatewayv2/model/TlsConfigInput.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace ApiGatewayV2 {
namespace Model {
 
class CreateIntegrationRequest : public ApiGatewayV2Request {
 public:
  AWS_APIGATEWAYV2_API CreateIntegrationRequest() = 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 "CreateIntegration"; }
 
  AWS_APIGATEWAYV2_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetApiId() const { return m_apiId; }
  inline bool ApiIdHasBeenSet() const { return m_apiIdHasBeenSet; }
  template <typename ApiIdT = Aws::String>
  void SetApiId(ApiIdT&& value) {
    m_apiIdHasBeenSet = true;
    m_apiId = std::forward<ApiIdT>(value);
  }
  template <typename ApiIdT = Aws::String>
  CreateIntegrationRequest& WithApiId(ApiIdT&& value) {
    SetApiId(std::forward<ApiIdT>(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>
  CreateIntegrationRequest& WithConnectionId(ConnectionIdT&& value) {
    SetConnectionId(std::forward<ConnectionIdT>(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 CreateIntegrationRequest& WithConnectionType(ConnectionType value) {
    SetConnectionType(value);
    return *this;
  }
 
 
  inline ContentHandlingStrategy GetContentHandlingStrategy() const { return m_contentHandlingStrategy; }
  inline bool ContentHandlingStrategyHasBeenSet() const { return m_contentHandlingStrategyHasBeenSet; }
  inline void SetContentHandlingStrategy(ContentHandlingStrategy value) {
    m_contentHandlingStrategyHasBeenSet = true;
    m_contentHandlingStrategy = value;
  }
  inline CreateIntegrationRequest& WithContentHandlingStrategy(ContentHandlingStrategy value) {
    SetContentHandlingStrategy(value);
    return *this;
  }
 
 
  inline const Aws::String& GetCredentialsArn() const { return m_credentialsArn; }
  inline bool CredentialsArnHasBeenSet() const { return m_credentialsArnHasBeenSet; }
  template <typename CredentialsArnT = Aws::String>
  void SetCredentialsArn(CredentialsArnT&& value) {
    m_credentialsArnHasBeenSet = true;
    m_credentialsArn = std::forward<CredentialsArnT>(value);
  }
  template <typename CredentialsArnT = Aws::String>
  CreateIntegrationRequest& WithCredentialsArn(CredentialsArnT&& value) {
    SetCredentialsArn(std::forward<CredentialsArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  CreateIntegrationRequest& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIntegrationMethod() const { return m_integrationMethod; }
  inline bool IntegrationMethodHasBeenSet() const { return m_integrationMethodHasBeenSet; }
  template <typename IntegrationMethodT = Aws::String>
  void SetIntegrationMethod(IntegrationMethodT&& value) {
    m_integrationMethodHasBeenSet = true;
    m_integrationMethod = std::forward<IntegrationMethodT>(value);
  }
  template <typename IntegrationMethodT = Aws::String>
  CreateIntegrationRequest& WithIntegrationMethod(IntegrationMethodT&& value) {
    SetIntegrationMethod(std::forward<IntegrationMethodT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIntegrationSubtype() const { return m_integrationSubtype; }
  inline bool IntegrationSubtypeHasBeenSet() const { return m_integrationSubtypeHasBeenSet; }
  template <typename IntegrationSubtypeT = Aws::String>
  void SetIntegrationSubtype(IntegrationSubtypeT&& value) {
    m_integrationSubtypeHasBeenSet = true;
    m_integrationSubtype = std::forward<IntegrationSubtypeT>(value);
  }
  template <typename IntegrationSubtypeT = Aws::String>
  CreateIntegrationRequest& WithIntegrationSubtype(IntegrationSubtypeT&& value) {
    SetIntegrationSubtype(std::forward<IntegrationSubtypeT>(value));
    return *this;
  }
 
 
  inline IntegrationType GetIntegrationType() const { return m_integrationType; }
  inline bool IntegrationTypeHasBeenSet() const { return m_integrationTypeHasBeenSet; }
  inline void SetIntegrationType(IntegrationType value) {
    m_integrationTypeHasBeenSet = true;
    m_integrationType = value;
  }
  inline CreateIntegrationRequest& WithIntegrationType(IntegrationType value) {
    SetIntegrationType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetIntegrationUri() const { return m_integrationUri; }
  inline bool IntegrationUriHasBeenSet() const { return m_integrationUriHasBeenSet; }
  template <typename IntegrationUriT = Aws::String>
  void SetIntegrationUri(IntegrationUriT&& value) {
    m_integrationUriHasBeenSet = true;
    m_integrationUri = std::forward<IntegrationUriT>(value);
  }
  template <typename IntegrationUriT = Aws::String>
  CreateIntegrationRequest& WithIntegrationUri(IntegrationUriT&& value) {
    SetIntegrationUri(std::forward<IntegrationUriT>(value));
    return *this;
  }
 
 
  inline PassthroughBehavior GetPassthroughBehavior() const { return m_passthroughBehavior; }
  inline bool PassthroughBehaviorHasBeenSet() const { return m_passthroughBehaviorHasBeenSet; }
  inline void SetPassthroughBehavior(PassthroughBehavior value) {
    m_passthroughBehaviorHasBeenSet = true;
    m_passthroughBehavior = value;
  }
  inline CreateIntegrationRequest& WithPassthroughBehavior(PassthroughBehavior value) {
    SetPassthroughBehavior(value);
    return *this;
  }
 
 
  inline const Aws::String& GetPayloadFormatVersion() const { return m_payloadFormatVersion; }
  inline bool PayloadFormatVersionHasBeenSet() const { return m_payloadFormatVersionHasBeenSet; }
  template <typename PayloadFormatVersionT = Aws::String>
  void SetPayloadFormatVersion(PayloadFormatVersionT&& value) {
    m_payloadFormatVersionHasBeenSet = true;
    m_payloadFormatVersion = std::forward<PayloadFormatVersionT>(value);
  }
  template <typename PayloadFormatVersionT = Aws::String>
  CreateIntegrationRequest& WithPayloadFormatVersion(PayloadFormatVersionT&& value) {
    SetPayloadFormatVersion(std::forward<PayloadFormatVersionT>(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>>
  CreateIntegrationRequest& WithRequestParameters(RequestParametersT&& value) {
    SetRequestParameters(std::forward<RequestParametersT>(value));
    return *this;
  }
  template <typename RequestParametersKeyT = Aws::String, typename RequestParametersValueT = Aws::String>
  CreateIntegrationRequest& 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>>
  CreateIntegrationRequest& WithRequestTemplates(RequestTemplatesT&& value) {
    SetRequestTemplates(std::forward<RequestTemplatesT>(value));
    return *this;
  }
  template <typename RequestTemplatesKeyT = Aws::String, typename RequestTemplatesValueT = Aws::String>
  CreateIntegrationRequest& AddRequestTemplates(RequestTemplatesKeyT&& key, RequestTemplatesValueT&& value) {
    m_requestTemplatesHasBeenSet = true;
    m_requestTemplates.emplace(std::forward<RequestTemplatesKeyT>(key), std::forward<RequestTemplatesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::Map<Aws::String, Aws::String>>& GetResponseParameters() const { return m_responseParameters; }
  inline bool ResponseParametersHasBeenSet() const { return m_responseParametersHasBeenSet; }
  template <typename ResponseParametersT = Aws::Map<Aws::String, Aws::Map<Aws::String, Aws::String>>>
  void SetResponseParameters(ResponseParametersT&& value) {
    m_responseParametersHasBeenSet = true;
    m_responseParameters = std::forward<ResponseParametersT>(value);
  }
  template <typename ResponseParametersT = Aws::Map<Aws::String, Aws::Map<Aws::String, Aws::String>>>
  CreateIntegrationRequest& WithResponseParameters(ResponseParametersT&& value) {
    SetResponseParameters(std::forward<ResponseParametersT>(value));
    return *this;
  }
  template <typename ResponseParametersKeyT = Aws::String, typename ResponseParametersValueT = Aws::Map<Aws::String, Aws::String>>
  CreateIntegrationRequest& AddResponseParameters(ResponseParametersKeyT&& key, ResponseParametersValueT&& value) {
    m_responseParametersHasBeenSet = true;
    m_responseParameters.emplace(std::forward<ResponseParametersKeyT>(key), std::forward<ResponseParametersValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTemplateSelectionExpression() const { return m_templateSelectionExpression; }
  inline bool TemplateSelectionExpressionHasBeenSet() const { return m_templateSelectionExpressionHasBeenSet; }
  template <typename TemplateSelectionExpressionT = Aws::String>
  void SetTemplateSelectionExpression(TemplateSelectionExpressionT&& value) {
    m_templateSelectionExpressionHasBeenSet = true;
    m_templateSelectionExpression = std::forward<TemplateSelectionExpressionT>(value);
  }
  template <typename TemplateSelectionExpressionT = Aws::String>
  CreateIntegrationRequest& WithTemplateSelectionExpression(TemplateSelectionExpressionT&& value) {
    SetTemplateSelectionExpression(std::forward<TemplateSelectionExpressionT>(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 CreateIntegrationRequest& WithTimeoutInMillis(int value) {
    SetTimeoutInMillis(value);
    return *this;
  }
 
 
  inline const TlsConfigInput& GetTlsConfig() const { return m_tlsConfig; }
  inline bool TlsConfigHasBeenSet() const { return m_tlsConfigHasBeenSet; }
  template <typename TlsConfigT = TlsConfigInput>
  void SetTlsConfig(TlsConfigT&& value) {
    m_tlsConfigHasBeenSet = true;
    m_tlsConfig = std::forward<TlsConfigT>(value);
  }
  template <typename TlsConfigT = TlsConfigInput>
  CreateIntegrationRequest& WithTlsConfig(TlsConfigT&& value) {
    SetTlsConfig(std::forward<TlsConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_apiId;
 
  Aws::String m_connectionId;
 
  ConnectionType m_connectionType{ConnectionType::NOT_SET};
 
  ContentHandlingStrategy m_contentHandlingStrategy{ContentHandlingStrategy::NOT_SET};
 
  Aws::String m_credentialsArn;
 
  Aws::String m_description;
 
  Aws::String m_integrationMethod;
 
  Aws::String m_integrationSubtype;
 
  IntegrationType m_integrationType{IntegrationType::NOT_SET};
 
  Aws::String m_integrationUri;
 
  PassthroughBehavior m_passthroughBehavior{PassthroughBehavior::NOT_SET};
 
  Aws::String m_payloadFormatVersion;
 
  Aws::Map<Aws::String, Aws::String> m_requestParameters;
 
  Aws::Map<Aws::String, Aws::String> m_requestTemplates;
 
  Aws::Map<Aws::String, Aws::Map<Aws::String, Aws::String>> m_responseParameters;
 
  Aws::String m_templateSelectionExpression;
 
  int m_timeoutInMillis{0};
 
  TlsConfigInput m_tlsConfig;
  bool m_apiIdHasBeenSet = false;
  bool m_connectionIdHasBeenSet = false;
  bool m_connectionTypeHasBeenSet = false;
  bool m_contentHandlingStrategyHasBeenSet = false;
  bool m_credentialsArnHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_integrationMethodHasBeenSet = false;
  bool m_integrationSubtypeHasBeenSet = false;
  bool m_integrationTypeHasBeenSet = false;
  bool m_integrationUriHasBeenSet = false;
  bool m_passthroughBehaviorHasBeenSet = false;
  bool m_payloadFormatVersionHasBeenSet = false;
  bool m_requestParametersHasBeenSet = false;
  bool m_requestTemplatesHasBeenSet = false;
  bool m_responseParametersHasBeenSet = false;
  bool m_templateSelectionExpressionHasBeenSet = false;
  bool m_timeoutInMillisHasBeenSet = false;
  bool m_tlsConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ApiGatewayV2
}  // namespace Aws