Integration.h

 
#pragma once
#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/TlsConfig.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ApiGatewayV2 {
namespace Model {
 
class Integration {
 public:
  AWS_APIGATEWAYV2_API Integration() = default;
  AWS_APIGATEWAYV2_API Integration(Aws::Utils::Json::JsonView jsonValue);
  AWS_APIGATEWAYV2_API Integration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_APIGATEWAYV2_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline bool GetApiGatewayManaged() const { return m_apiGatewayManaged; }
  inline bool ApiGatewayManagedHasBeenSet() const { return m_apiGatewayManagedHasBeenSet; }
  inline void SetApiGatewayManaged(bool value) {
    m_apiGatewayManagedHasBeenSet = true;
    m_apiGatewayManaged = value;
  }
  inline Integration& WithApiGatewayManaged(bool value) {
    SetApiGatewayManaged(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 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 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 Integration& 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>
  Integration& 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>
  Integration& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIntegrationId() const { return m_integrationId; }
  inline bool IntegrationIdHasBeenSet() const { return m_integrationIdHasBeenSet; }
  template <typename IntegrationIdT = Aws::String>
  void SetIntegrationId(IntegrationIdT&& value) {
    m_integrationIdHasBeenSet = true;
    m_integrationId = std::forward<IntegrationIdT>(value);
  }
  template <typename IntegrationIdT = Aws::String>
  Integration& WithIntegrationId(IntegrationIdT&& value) {
    SetIntegrationId(std::forward<IntegrationIdT>(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>
  Integration& WithIntegrationMethod(IntegrationMethodT&& value) {
    SetIntegrationMethod(std::forward<IntegrationMethodT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIntegrationResponseSelectionExpression() const { return m_integrationResponseSelectionExpression; }
  inline bool IntegrationResponseSelectionExpressionHasBeenSet() const { return m_integrationResponseSelectionExpressionHasBeenSet; }
  template <typename IntegrationResponseSelectionExpressionT = Aws::String>
  void SetIntegrationResponseSelectionExpression(IntegrationResponseSelectionExpressionT&& value) {
    m_integrationResponseSelectionExpressionHasBeenSet = true;
    m_integrationResponseSelectionExpression = std::forward<IntegrationResponseSelectionExpressionT>(value);
  }
  template <typename IntegrationResponseSelectionExpressionT = Aws::String>
  Integration& WithIntegrationResponseSelectionExpression(IntegrationResponseSelectionExpressionT&& value) {
    SetIntegrationResponseSelectionExpression(std::forward<IntegrationResponseSelectionExpressionT>(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>
  Integration& 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 Integration& 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>
  Integration& 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 Integration& 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>
  Integration& 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>>
  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::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>>>
  Integration& WithResponseParameters(ResponseParametersT&& value) {
    SetResponseParameters(std::forward<ResponseParametersT>(value));
    return *this;
  }
  template <typename ResponseParametersKeyT = Aws::String, typename ResponseParametersValueT = Aws::Map<Aws::String, Aws::String>>
  Integration& 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>
  Integration& 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 Integration& 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>
  Integration& WithTlsConfig(TlsConfigT&& value) {
    SetTlsConfig(std::forward<TlsConfigT>(value));
    return *this;
  }
 private:
  bool m_apiGatewayManaged{false};
 
  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_integrationId;
 
  Aws::String m_integrationMethod;
 
  Aws::String m_integrationResponseSelectionExpression;
 
  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};
 
  TlsConfig m_tlsConfig;
  bool m_apiGatewayManagedHasBeenSet = false;
  bool m_connectionIdHasBeenSet = false;
  bool m_connectionTypeHasBeenSet = false;
  bool m_contentHandlingStrategyHasBeenSet = false;
  bool m_credentialsArnHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_integrationIdHasBeenSet = false;
  bool m_integrationMethodHasBeenSet = false;
  bool m_integrationResponseSelectionExpressionHasBeenSet = 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