FieldToMatch.h

 
#pragma once
#include <aws/wafv2/WAFV2_EXPORTS.h>
#include <aws/wafv2/model/SingleHeader.h>
#include <aws/wafv2/model/SingleQueryArgument.h>
#include <aws/wafv2/model/AllQueryArguments.h>
#include <aws/wafv2/model/UriPath.h>
#include <aws/wafv2/model/QueryString.h>
#include <aws/wafv2/model/Body.h>
#include <aws/wafv2/model/Method.h>
#include <aws/wafv2/model/JsonBody.h>
#include <aws/wafv2/model/Headers.h>
#include <aws/wafv2/model/Cookies.h>
#include <aws/wafv2/model/HeaderOrder.h>
#include <aws/wafv2/model/JA3Fingerprint.h>
#include <aws/wafv2/model/JA4Fingerprint.h>
#include <aws/wafv2/model/UriFragment.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace WAFV2
{
namespace Model
{
 
  class FieldToMatch
  {
  public:
    AWS_WAFV2_API FieldToMatch() = default;
    AWS_WAFV2_API FieldToMatch(Aws::Utils::Json::JsonView jsonValue);
    AWS_WAFV2_API FieldToMatch& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_WAFV2_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const SingleHeader& GetSingleHeader() const { return m_singleHeader; }
    inline bool SingleHeaderHasBeenSet() const { return m_singleHeaderHasBeenSet; }
    template<typename SingleHeaderT = SingleHeader>
    void SetSingleHeader(SingleHeaderT&& value) { m_singleHeaderHasBeenSet = true; m_singleHeader = std::forward<SingleHeaderT>(value); }
    template<typename SingleHeaderT = SingleHeader>
    FieldToMatch& WithSingleHeader(SingleHeaderT&& value) { SetSingleHeader(std::forward<SingleHeaderT>(value)); return *this;}
 
 
    inline const SingleQueryArgument& GetSingleQueryArgument() const { return m_singleQueryArgument; }
    inline bool SingleQueryArgumentHasBeenSet() const { return m_singleQueryArgumentHasBeenSet; }
    template<typename SingleQueryArgumentT = SingleQueryArgument>
    void SetSingleQueryArgument(SingleQueryArgumentT&& value) { m_singleQueryArgumentHasBeenSet = true; m_singleQueryArgument = std::forward<SingleQueryArgumentT>(value); }
    template<typename SingleQueryArgumentT = SingleQueryArgument>
    FieldToMatch& WithSingleQueryArgument(SingleQueryArgumentT&& value) { SetSingleQueryArgument(std::forward<SingleQueryArgumentT>(value)); return *this;}
 
 
    inline const AllQueryArguments& GetAllQueryArguments() const { return m_allQueryArguments; }
    inline bool AllQueryArgumentsHasBeenSet() const { return m_allQueryArgumentsHasBeenSet; }
    template<typename AllQueryArgumentsT = AllQueryArguments>
    void SetAllQueryArguments(AllQueryArgumentsT&& value) { m_allQueryArgumentsHasBeenSet = true; m_allQueryArguments = std::forward<AllQueryArgumentsT>(value); }
    template<typename AllQueryArgumentsT = AllQueryArguments>
    FieldToMatch& WithAllQueryArguments(AllQueryArgumentsT&& value) { SetAllQueryArguments(std::forward<AllQueryArgumentsT>(value)); return *this;}
 
 
    inline const UriPath& GetUriPath() const { return m_uriPath; }
    inline bool UriPathHasBeenSet() const { return m_uriPathHasBeenSet; }
    template<typename UriPathT = UriPath>
    void SetUriPath(UriPathT&& value) { m_uriPathHasBeenSet = true; m_uriPath = std::forward<UriPathT>(value); }
    template<typename UriPathT = UriPath>
    FieldToMatch& WithUriPath(UriPathT&& value) { SetUriPath(std::forward<UriPathT>(value)); return *this;}
 
 
    inline const QueryString& GetQueryString() const { return m_queryString; }
    inline bool QueryStringHasBeenSet() const { return m_queryStringHasBeenSet; }
    template<typename QueryStringT = QueryString>
    void SetQueryString(QueryStringT&& value) { m_queryStringHasBeenSet = true; m_queryString = std::forward<QueryStringT>(value); }
    template<typename QueryStringT = QueryString>
    FieldToMatch& WithQueryString(QueryStringT&& value) { SetQueryString(std::forward<QueryStringT>(value)); return *this;}
 
 
    inline const Body& GetBody() const { return m_body; }
    inline bool BodyHasBeenSet() const { return m_bodyHasBeenSet; }
    template<typename BodyT = Body>
    void SetBody(BodyT&& value) { m_bodyHasBeenSet = true; m_body = std::forward<BodyT>(value); }
    template<typename BodyT = Body>
    FieldToMatch& WithBody(BodyT&& value) { SetBody(std::forward<BodyT>(value)); return *this;}
 
 
    inline const Method& GetMethod() const { return m_method; }
    inline bool MethodHasBeenSet() const { return m_methodHasBeenSet; }
    template<typename MethodT = Method>
    void SetMethod(MethodT&& value) { m_methodHasBeenSet = true; m_method = std::forward<MethodT>(value); }
    template<typename MethodT = Method>
    FieldToMatch& WithMethod(MethodT&& value) { SetMethod(std::forward<MethodT>(value)); return *this;}
 
 
    inline const JsonBody& GetJsonBody() const { return m_jsonBody; }
    inline bool JsonBodyHasBeenSet() const { return m_jsonBodyHasBeenSet; }
    template<typename JsonBodyT = JsonBody>
    void SetJsonBody(JsonBodyT&& value) { m_jsonBodyHasBeenSet = true; m_jsonBody = std::forward<JsonBodyT>(value); }
    template<typename JsonBodyT = JsonBody>
    FieldToMatch& WithJsonBody(JsonBodyT&& value) { SetJsonBody(std::forward<JsonBodyT>(value)); return *this;}
 
 
    inline const Headers& GetHeaders() const { return m_headers; }
    inline bool HeadersHasBeenSet() const { return m_headersHasBeenSet; }
    template<typename HeadersT = Headers>
    void SetHeaders(HeadersT&& value) { m_headersHasBeenSet = true; m_headers = std::forward<HeadersT>(value); }
    template<typename HeadersT = Headers>
    FieldToMatch& WithHeaders(HeadersT&& value) { SetHeaders(std::forward<HeadersT>(value)); return *this;}
 
 
    inline const Cookies& GetCookies() const { return m_cookies; }
    inline bool CookiesHasBeenSet() const { return m_cookiesHasBeenSet; }
    template<typename CookiesT = Cookies>
    void SetCookies(CookiesT&& value) { m_cookiesHasBeenSet = true; m_cookies = std::forward<CookiesT>(value); }
    template<typename CookiesT = Cookies>
    FieldToMatch& WithCookies(CookiesT&& value) { SetCookies(std::forward<CookiesT>(value)); return *this;}
 
 
    inline const HeaderOrder& GetHeaderOrder() const { return m_headerOrder; }
    inline bool HeaderOrderHasBeenSet() const { return m_headerOrderHasBeenSet; }
    template<typename HeaderOrderT = HeaderOrder>
    void SetHeaderOrder(HeaderOrderT&& value) { m_headerOrderHasBeenSet = true; m_headerOrder = std::forward<HeaderOrderT>(value); }
    template<typename HeaderOrderT = HeaderOrder>
    FieldToMatch& WithHeaderOrder(HeaderOrderT&& value) { SetHeaderOrder(std::forward<HeaderOrderT>(value)); return *this;}
 
 
    inline const JA3Fingerprint& GetJA3Fingerprint() const { return m_jA3Fingerprint; }
    inline bool JA3FingerprintHasBeenSet() const { return m_jA3FingerprintHasBeenSet; }
    template<typename JA3FingerprintT = JA3Fingerprint>
    void SetJA3Fingerprint(JA3FingerprintT&& value) { m_jA3FingerprintHasBeenSet = true; m_jA3Fingerprint = std::forward<JA3FingerprintT>(value); }
    template<typename JA3FingerprintT = JA3Fingerprint>
    FieldToMatch& WithJA3Fingerprint(JA3FingerprintT&& value) { SetJA3Fingerprint(std::forward<JA3FingerprintT>(value)); return *this;}
 
 
    inline const JA4Fingerprint& GetJA4Fingerprint() const { return m_jA4Fingerprint; }
    inline bool JA4FingerprintHasBeenSet() const { return m_jA4FingerprintHasBeenSet; }
    template<typename JA4FingerprintT = JA4Fingerprint>
    void SetJA4Fingerprint(JA4FingerprintT&& value) { m_jA4FingerprintHasBeenSet = true; m_jA4Fingerprint = std::forward<JA4FingerprintT>(value); }
    template<typename JA4FingerprintT = JA4Fingerprint>
    FieldToMatch& WithJA4Fingerprint(JA4FingerprintT&& value) { SetJA4Fingerprint(std::forward<JA4FingerprintT>(value)); return *this;}
 
 
    inline const UriFragment& GetUriFragment() const { return m_uriFragment; }
    inline bool UriFragmentHasBeenSet() const { return m_uriFragmentHasBeenSet; }
    template<typename UriFragmentT = UriFragment>
    void SetUriFragment(UriFragmentT&& value) { m_uriFragmentHasBeenSet = true; m_uriFragment = std::forward<UriFragmentT>(value); }
    template<typename UriFragmentT = UriFragment>
    FieldToMatch& WithUriFragment(UriFragmentT&& value) { SetUriFragment(std::forward<UriFragmentT>(value)); return *this;}
  private:
 
    SingleHeader m_singleHeader;
    bool m_singleHeaderHasBeenSet = false;
 
    SingleQueryArgument m_singleQueryArgument;
    bool m_singleQueryArgumentHasBeenSet = false;
 
    AllQueryArguments m_allQueryArguments;
    bool m_allQueryArgumentsHasBeenSet = false;
 
    UriPath m_uriPath;
    bool m_uriPathHasBeenSet = false;
 
    QueryString m_queryString;
    bool m_queryStringHasBeenSet = false;
 
    Body m_body;
    bool m_bodyHasBeenSet = false;
 
    Method m_method;
    bool m_methodHasBeenSet = false;
 
    JsonBody m_jsonBody;
    bool m_jsonBodyHasBeenSet = false;
 
    Headers m_headers;
    bool m_headersHasBeenSet = false;
 
    Cookies m_cookies;
    bool m_cookiesHasBeenSet = false;
 
    HeaderOrder m_headerOrder;
    bool m_headerOrderHasBeenSet = false;
 
    JA3Fingerprint m_jA3Fingerprint;
    bool m_jA3FingerprintHasBeenSet = false;
 
    JA4Fingerprint m_jA4Fingerprint;
    bool m_jA4FingerprintHasBeenSet = false;
 
    UriFragment m_uriFragment;
    bool m_uriFragmentHasBeenSet = false;
  };
 
} // namespace Model
} // namespace WAFV2
} // namespace Aws