CreateIntegrationRequest.h

 
#pragma once
#include <aws/apigatewayv2/ApiGatewayV2_EXPORTS.h>
#include <aws/apigatewayv2/ApiGatewayV2Request.h>
#include <aws/core/utils/memory/stl/AWSString.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/core/utils/memory/stl/AWSMap.h>
#include <aws/apigatewayv2/model/TlsConfigInput.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;
    bool m_apiIdHasBeenSet = false;
 
    Aws::String m_connectionId;
    bool m_connectionIdHasBeenSet = false;
 
    ConnectionType m_connectionType{ConnectionType::NOT_SET};
    bool m_connectionTypeHasBeenSet = false;
 
    ContentHandlingStrategy m_contentHandlingStrategy{ContentHandlingStrategy::NOT_SET};
    bool m_contentHandlingStrategyHasBeenSet = false;
 
    Aws::String m_credentialsArn;
    bool m_credentialsArnHasBeenSet = false;
 
    Aws::String m_description;
    bool m_descriptionHasBeenSet = false;
 
    Aws::String m_integrationMethod;
    bool m_integrationMethodHasBeenSet = false;
 
    Aws::String m_integrationSubtype;
    bool m_integrationSubtypeHasBeenSet = false;
 
    IntegrationType m_integrationType{IntegrationType::NOT_SET};
    bool m_integrationTypeHasBeenSet = false;
 
    Aws::String m_integrationUri;
    bool m_integrationUriHasBeenSet = false;
 
    PassthroughBehavior m_passthroughBehavior{PassthroughBehavior::NOT_SET};
    bool m_passthroughBehaviorHasBeenSet = false;
 
    Aws::String m_payloadFormatVersion;
    bool m_payloadFormatVersionHasBeenSet = false;
 
    Aws::Map<Aws::String, Aws::String> m_requestParameters;
    bool m_requestParametersHasBeenSet = false;
 
    Aws::Map<Aws::String, Aws::String> m_requestTemplates;
    bool m_requestTemplatesHasBeenSet = false;
 
    Aws::Map<Aws::String, Aws::Map<Aws::String, Aws::String>> m_responseParameters;
    bool m_responseParametersHasBeenSet = false;
 
    Aws::String m_templateSelectionExpression;
    bool m_templateSelectionExpressionHasBeenSet = false;
 
    int m_timeoutInMillis{0};
    bool m_timeoutInMillisHasBeenSet = false;
 
    TlsConfigInput m_tlsConfig;
    bool m_tlsConfigHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ApiGatewayV2
} // namespace Aws