ConnectCasesClient.h

 
#pragma once
#include <aws/connectcases/ConnectCasesPaginationBase.h>
#include <aws/connectcases/ConnectCasesServiceClientModel.h>
#include <aws/connectcases/ConnectCasesWaiter.h>
#include <aws/connectcases/ConnectCases_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace ConnectCases {
class AWS_CONNECTCASES_API ConnectCasesClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<ConnectCasesClient>,
                                                public ConnectCasesPaginationBase<ConnectCasesClient>,
                                                public ConnectCasesWaiter<ConnectCasesClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ConnectCasesClientConfiguration ClientConfigurationType;
  typedef ConnectCasesEndpointProvider EndpointProviderType;
 
  ConnectCasesClient(
      const Aws::ConnectCases::ConnectCasesClientConfiguration& clientConfiguration = Aws::ConnectCases::ConnectCasesClientConfiguration(),
      std::shared_ptr<ConnectCasesEndpointProviderBase> endpointProvider = nullptr);
 
  ConnectCasesClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<ConnectCasesEndpointProviderBase> endpointProvider = nullptr,
      const Aws::ConnectCases::ConnectCasesClientConfiguration& clientConfiguration = Aws::ConnectCases::ConnectCasesClientConfiguration());
 
  ConnectCasesClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<ConnectCasesEndpointProviderBase> endpointProvider = nullptr,
      const Aws::ConnectCases::ConnectCasesClientConfiguration& clientConfiguration = Aws::ConnectCases::ConnectCasesClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ConnectCasesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConnectCasesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConnectCasesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ConnectCasesClient();
 
  virtual Model::BatchGetCaseRuleOutcome BatchGetCaseRule(const Model::BatchGetCaseRuleRequest& request) const;
 
  template <typename BatchGetCaseRuleRequestT = Model::BatchGetCaseRuleRequest>
  Model::BatchGetCaseRuleOutcomeCallable BatchGetCaseRuleCallable(const BatchGetCaseRuleRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::BatchGetCaseRule, request);
  }
 
  template <typename BatchGetCaseRuleRequestT = Model::BatchGetCaseRuleRequest>
  void BatchGetCaseRuleAsync(const BatchGetCaseRuleRequestT& request, const BatchGetCaseRuleResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::BatchGetCaseRule, request, handler, context);
  }
 
  virtual Model::BatchGetFieldOutcome BatchGetField(const Model::BatchGetFieldRequest& request) const;
 
  template <typename BatchGetFieldRequestT = Model::BatchGetFieldRequest>
  Model::BatchGetFieldOutcomeCallable BatchGetFieldCallable(const BatchGetFieldRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::BatchGetField, request);
  }
 
  template <typename BatchGetFieldRequestT = Model::BatchGetFieldRequest>
  void BatchGetFieldAsync(const BatchGetFieldRequestT& request, const BatchGetFieldResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::BatchGetField, request, handler, context);
  }
 
  virtual Model::BatchPutFieldOptionsOutcome BatchPutFieldOptions(const Model::BatchPutFieldOptionsRequest& request) const;
 
  template <typename BatchPutFieldOptionsRequestT = Model::BatchPutFieldOptionsRequest>
  Model::BatchPutFieldOptionsOutcomeCallable BatchPutFieldOptionsCallable(const BatchPutFieldOptionsRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::BatchPutFieldOptions, request);
  }
 
  template <typename BatchPutFieldOptionsRequestT = Model::BatchPutFieldOptionsRequest>
  void BatchPutFieldOptionsAsync(const BatchPutFieldOptionsRequestT& request, const BatchPutFieldOptionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::BatchPutFieldOptions, request, handler, context);
  }
 
  virtual Model::CreateCaseOutcome CreateCase(const Model::CreateCaseRequest& request) const;
 
  template <typename CreateCaseRequestT = Model::CreateCaseRequest>
  Model::CreateCaseOutcomeCallable CreateCaseCallable(const CreateCaseRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::CreateCase, request);
  }
 
  template <typename CreateCaseRequestT = Model::CreateCaseRequest>
  void CreateCaseAsync(const CreateCaseRequestT& request, const CreateCaseResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::CreateCase, request, handler, context);
  }
 
  virtual Model::CreateCaseRuleOutcome CreateCaseRule(const Model::CreateCaseRuleRequest& request) const;
 
  template <typename CreateCaseRuleRequestT = Model::CreateCaseRuleRequest>
  Model::CreateCaseRuleOutcomeCallable CreateCaseRuleCallable(const CreateCaseRuleRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::CreateCaseRule, request);
  }
 
  template <typename CreateCaseRuleRequestT = Model::CreateCaseRuleRequest>
  void CreateCaseRuleAsync(const CreateCaseRuleRequestT& request, const CreateCaseRuleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::CreateCaseRule, request, handler, context);
  }
 
  virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::CreateDomain, request);
  }
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::CreateDomain, request, handler, context);
  }
 
  virtual Model::CreateFieldOutcome CreateField(const Model::CreateFieldRequest& request) const;
 
  template <typename CreateFieldRequestT = Model::CreateFieldRequest>
  Model::CreateFieldOutcomeCallable CreateFieldCallable(const CreateFieldRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::CreateField, request);
  }
 
  template <typename CreateFieldRequestT = Model::CreateFieldRequest>
  void CreateFieldAsync(const CreateFieldRequestT& request, const CreateFieldResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::CreateField, request, handler, context);
  }
 
  virtual Model::CreateLayoutOutcome CreateLayout(const Model::CreateLayoutRequest& request) const;
 
  template <typename CreateLayoutRequestT = Model::CreateLayoutRequest>
  Model::CreateLayoutOutcomeCallable CreateLayoutCallable(const CreateLayoutRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::CreateLayout, request);
  }
 
  template <typename CreateLayoutRequestT = Model::CreateLayoutRequest>
  void CreateLayoutAsync(const CreateLayoutRequestT& request, const CreateLayoutResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::CreateLayout, request, handler, context);
  }
 
  virtual Model::CreateRelatedItemOutcome CreateRelatedItem(const Model::CreateRelatedItemRequest& request) const;
 
  template <typename CreateRelatedItemRequestT = Model::CreateRelatedItemRequest>
  Model::CreateRelatedItemOutcomeCallable CreateRelatedItemCallable(const CreateRelatedItemRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::CreateRelatedItem, request);
  }
 
  template <typename CreateRelatedItemRequestT = Model::CreateRelatedItemRequest>
  void CreateRelatedItemAsync(const CreateRelatedItemRequestT& request, const CreateRelatedItemResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::CreateRelatedItem, request, handler, context);
  }
 
  virtual Model::CreateTemplateOutcome CreateTemplate(const Model::CreateTemplateRequest& request) const;
 
  template <typename CreateTemplateRequestT = Model::CreateTemplateRequest>
  Model::CreateTemplateOutcomeCallable CreateTemplateCallable(const CreateTemplateRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::CreateTemplate, request);
  }
 
  template <typename CreateTemplateRequestT = Model::CreateTemplateRequest>
  void CreateTemplateAsync(const CreateTemplateRequestT& request, const CreateTemplateResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::CreateTemplate, request, handler, context);
  }
 
  virtual Model::DeleteCaseOutcome DeleteCase(const Model::DeleteCaseRequest& request) const;
 
  template <typename DeleteCaseRequestT = Model::DeleteCaseRequest>
  Model::DeleteCaseOutcomeCallable DeleteCaseCallable(const DeleteCaseRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::DeleteCase, request);
  }
 
  template <typename DeleteCaseRequestT = Model::DeleteCaseRequest>
  void DeleteCaseAsync(const DeleteCaseRequestT& request, const DeleteCaseResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::DeleteCase, request, handler, context);
  }
 
  virtual Model::DeleteCaseRuleOutcome DeleteCaseRule(const Model::DeleteCaseRuleRequest& request) const;
 
  template <typename DeleteCaseRuleRequestT = Model::DeleteCaseRuleRequest>
  Model::DeleteCaseRuleOutcomeCallable DeleteCaseRuleCallable(const DeleteCaseRuleRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::DeleteCaseRule, request);
  }
 
  template <typename DeleteCaseRuleRequestT = Model::DeleteCaseRuleRequest>
  void DeleteCaseRuleAsync(const DeleteCaseRuleRequestT& request, const DeleteCaseRuleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::DeleteCaseRule, request, handler, context);
  }
 
  virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::DeleteDomain, request);
  }
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::DeleteDomain, request, handler, context);
  }
 
  virtual Model::DeleteFieldOutcome DeleteField(const Model::DeleteFieldRequest& request) const;
 
  template <typename DeleteFieldRequestT = Model::DeleteFieldRequest>
  Model::DeleteFieldOutcomeCallable DeleteFieldCallable(const DeleteFieldRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::DeleteField, request);
  }
 
  template <typename DeleteFieldRequestT = Model::DeleteFieldRequest>
  void DeleteFieldAsync(const DeleteFieldRequestT& request, const DeleteFieldResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::DeleteField, request, handler, context);
  }
 
  virtual Model::DeleteLayoutOutcome DeleteLayout(const Model::DeleteLayoutRequest& request) const;
 
  template <typename DeleteLayoutRequestT = Model::DeleteLayoutRequest>
  Model::DeleteLayoutOutcomeCallable DeleteLayoutCallable(const DeleteLayoutRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::DeleteLayout, request);
  }
 
  template <typename DeleteLayoutRequestT = Model::DeleteLayoutRequest>
  void DeleteLayoutAsync(const DeleteLayoutRequestT& request, const DeleteLayoutResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::DeleteLayout, request, handler, context);
  }
 
  virtual Model::DeleteRelatedItemOutcome DeleteRelatedItem(const Model::DeleteRelatedItemRequest& request) const;
 
  template <typename DeleteRelatedItemRequestT = Model::DeleteRelatedItemRequest>
  Model::DeleteRelatedItemOutcomeCallable DeleteRelatedItemCallable(const DeleteRelatedItemRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::DeleteRelatedItem, request);
  }
 
  template <typename DeleteRelatedItemRequestT = Model::DeleteRelatedItemRequest>
  void DeleteRelatedItemAsync(const DeleteRelatedItemRequestT& request, const DeleteRelatedItemResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::DeleteRelatedItem, request, handler, context);
  }
 
  virtual Model::DeleteTemplateOutcome DeleteTemplate(const Model::DeleteTemplateRequest& request) const;
 
  template <typename DeleteTemplateRequestT = Model::DeleteTemplateRequest>
  Model::DeleteTemplateOutcomeCallable DeleteTemplateCallable(const DeleteTemplateRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::DeleteTemplate, request);
  }
 
  template <typename DeleteTemplateRequestT = Model::DeleteTemplateRequest>
  void DeleteTemplateAsync(const DeleteTemplateRequestT& request, const DeleteTemplateResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::DeleteTemplate, request, handler, context);
  }
 
  virtual Model::GetCaseOutcome GetCase(const Model::GetCaseRequest& request) const;
 
  template <typename GetCaseRequestT = Model::GetCaseRequest>
  Model::GetCaseOutcomeCallable GetCaseCallable(const GetCaseRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::GetCase, request);
  }
 
  template <typename GetCaseRequestT = Model::GetCaseRequest>
  void GetCaseAsync(const GetCaseRequestT& request, const GetCaseResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::GetCase, request, handler, context);
  }
 
  virtual Model::GetCaseAuditEventsOutcome GetCaseAuditEvents(const Model::GetCaseAuditEventsRequest& request) const;
 
  template <typename GetCaseAuditEventsRequestT = Model::GetCaseAuditEventsRequest>
  Model::GetCaseAuditEventsOutcomeCallable GetCaseAuditEventsCallable(const GetCaseAuditEventsRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::GetCaseAuditEvents, request);
  }
 
  template <typename GetCaseAuditEventsRequestT = Model::GetCaseAuditEventsRequest>
  void GetCaseAuditEventsAsync(const GetCaseAuditEventsRequestT& request, const GetCaseAuditEventsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::GetCaseAuditEvents, request, handler, context);
  }
 
  virtual Model::GetCaseEventConfigurationOutcome GetCaseEventConfiguration(const Model::GetCaseEventConfigurationRequest& request) const;
 
  template <typename GetCaseEventConfigurationRequestT = Model::GetCaseEventConfigurationRequest>
  Model::GetCaseEventConfigurationOutcomeCallable GetCaseEventConfigurationCallable(
      const GetCaseEventConfigurationRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::GetCaseEventConfiguration, request);
  }
 
  template <typename GetCaseEventConfigurationRequestT = Model::GetCaseEventConfigurationRequest>
  void GetCaseEventConfigurationAsync(const GetCaseEventConfigurationRequestT& request,
                                      const GetCaseEventConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::GetCaseEventConfiguration, request, handler, context);
  }
 
  virtual Model::GetDomainOutcome GetDomain(const Model::GetDomainRequest& request) const;
 
  template <typename GetDomainRequestT = Model::GetDomainRequest>
  Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::GetDomain, request);
  }
 
  template <typename GetDomainRequestT = Model::GetDomainRequest>
  void GetDomainAsync(const GetDomainRequestT& request, const GetDomainResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::GetDomain, request, handler, context);
  }
 
  virtual Model::GetLayoutOutcome GetLayout(const Model::GetLayoutRequest& request) const;
 
  template <typename GetLayoutRequestT = Model::GetLayoutRequest>
  Model::GetLayoutOutcomeCallable GetLayoutCallable(const GetLayoutRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::GetLayout, request);
  }
 
  template <typename GetLayoutRequestT = Model::GetLayoutRequest>
  void GetLayoutAsync(const GetLayoutRequestT& request, const GetLayoutResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::GetLayout, request, handler, context);
  }
 
  virtual Model::GetTemplateOutcome GetTemplate(const Model::GetTemplateRequest& request) const;
 
  template <typename GetTemplateRequestT = Model::GetTemplateRequest>
  Model::GetTemplateOutcomeCallable GetTemplateCallable(const GetTemplateRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::GetTemplate, request);
  }
 
  template <typename GetTemplateRequestT = Model::GetTemplateRequest>
  void GetTemplateAsync(const GetTemplateRequestT& request, const GetTemplateResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::GetTemplate, request, handler, context);
  }
 
  virtual Model::ListCaseRulesOutcome ListCaseRules(const Model::ListCaseRulesRequest& request) const;
 
  template <typename ListCaseRulesRequestT = Model::ListCaseRulesRequest>
  Model::ListCaseRulesOutcomeCallable ListCaseRulesCallable(const ListCaseRulesRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::ListCaseRules, request);
  }
 
  template <typename ListCaseRulesRequestT = Model::ListCaseRulesRequest>
  void ListCaseRulesAsync(const ListCaseRulesRequestT& request, const ListCaseRulesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::ListCaseRules, request, handler, context);
  }
 
  virtual Model::ListCasesForContactOutcome ListCasesForContact(const Model::ListCasesForContactRequest& request) const;
 
  template <typename ListCasesForContactRequestT = Model::ListCasesForContactRequest>
  Model::ListCasesForContactOutcomeCallable ListCasesForContactCallable(const ListCasesForContactRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::ListCasesForContact, request);
  }
 
  template <typename ListCasesForContactRequestT = Model::ListCasesForContactRequest>
  void ListCasesForContactAsync(const ListCasesForContactRequestT& request, const ListCasesForContactResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::ListCasesForContact, request, handler, context);
  }
 
  virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request = {}) const;
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request = {}) const {
    return SubmitCallable(&ConnectCasesClient::ListDomains, request);
  }
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  void ListDomainsAsync(const ListDomainsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListDomainsRequestT& request = {}) const {
    return SubmitAsync(&ConnectCasesClient::ListDomains, request, handler, context);
  }
 
  virtual Model::ListFieldOptionsOutcome ListFieldOptions(const Model::ListFieldOptionsRequest& request) const;
 
  template <typename ListFieldOptionsRequestT = Model::ListFieldOptionsRequest>
  Model::ListFieldOptionsOutcomeCallable ListFieldOptionsCallable(const ListFieldOptionsRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::ListFieldOptions, request);
  }
 
  template <typename ListFieldOptionsRequestT = Model::ListFieldOptionsRequest>
  void ListFieldOptionsAsync(const ListFieldOptionsRequestT& request, const ListFieldOptionsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::ListFieldOptions, request, handler, context);
  }
 
  virtual Model::ListFieldsOutcome ListFields(const Model::ListFieldsRequest& request) const;
 
  template <typename ListFieldsRequestT = Model::ListFieldsRequest>
  Model::ListFieldsOutcomeCallable ListFieldsCallable(const ListFieldsRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::ListFields, request);
  }
 
  template <typename ListFieldsRequestT = Model::ListFieldsRequest>
  void ListFieldsAsync(const ListFieldsRequestT& request, const ListFieldsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::ListFields, request, handler, context);
  }
 
  virtual Model::ListLayoutsOutcome ListLayouts(const Model::ListLayoutsRequest& request) const;
 
  template <typename ListLayoutsRequestT = Model::ListLayoutsRequest>
  Model::ListLayoutsOutcomeCallable ListLayoutsCallable(const ListLayoutsRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::ListLayouts, request);
  }
 
  template <typename ListLayoutsRequestT = Model::ListLayoutsRequest>
  void ListLayoutsAsync(const ListLayoutsRequestT& request, const ListLayoutsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::ListLayouts, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTemplatesOutcome ListTemplates(const Model::ListTemplatesRequest& request) const;
 
  template <typename ListTemplatesRequestT = Model::ListTemplatesRequest>
  Model::ListTemplatesOutcomeCallable ListTemplatesCallable(const ListTemplatesRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::ListTemplates, request);
  }
 
  template <typename ListTemplatesRequestT = Model::ListTemplatesRequest>
  void ListTemplatesAsync(const ListTemplatesRequestT& request, const ListTemplatesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::ListTemplates, request, handler, context);
  }
 
  virtual Model::PutCaseEventConfigurationOutcome PutCaseEventConfiguration(const Model::PutCaseEventConfigurationRequest& request) const;
 
  template <typename PutCaseEventConfigurationRequestT = Model::PutCaseEventConfigurationRequest>
  Model::PutCaseEventConfigurationOutcomeCallable PutCaseEventConfigurationCallable(
      const PutCaseEventConfigurationRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::PutCaseEventConfiguration, request);
  }
 
  template <typename PutCaseEventConfigurationRequestT = Model::PutCaseEventConfigurationRequest>
  void PutCaseEventConfigurationAsync(const PutCaseEventConfigurationRequestT& request,
                                      const PutCaseEventConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::PutCaseEventConfiguration, request, handler, context);
  }
 
  virtual Model::SearchAllRelatedItemsOutcome SearchAllRelatedItems(const Model::SearchAllRelatedItemsRequest& request) const;
 
  template <typename SearchAllRelatedItemsRequestT = Model::SearchAllRelatedItemsRequest>
  Model::SearchAllRelatedItemsOutcomeCallable SearchAllRelatedItemsCallable(const SearchAllRelatedItemsRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::SearchAllRelatedItems, request);
  }
 
  template <typename SearchAllRelatedItemsRequestT = Model::SearchAllRelatedItemsRequest>
  void SearchAllRelatedItemsAsync(const SearchAllRelatedItemsRequestT& request, const SearchAllRelatedItemsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::SearchAllRelatedItems, request, handler, context);
  }
 
  virtual Model::SearchCasesOutcome SearchCases(const Model::SearchCasesRequest& request) const;
 
  template <typename SearchCasesRequestT = Model::SearchCasesRequest>
  Model::SearchCasesOutcomeCallable SearchCasesCallable(const SearchCasesRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::SearchCases, request);
  }
 
  template <typename SearchCasesRequestT = Model::SearchCasesRequest>
  void SearchCasesAsync(const SearchCasesRequestT& request, const SearchCasesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::SearchCases, request, handler, context);
  }
 
  virtual Model::SearchRelatedItemsOutcome SearchRelatedItems(const Model::SearchRelatedItemsRequest& request) const;
 
  template <typename SearchRelatedItemsRequestT = Model::SearchRelatedItemsRequest>
  Model::SearchRelatedItemsOutcomeCallable SearchRelatedItemsCallable(const SearchRelatedItemsRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::SearchRelatedItems, request);
  }
 
  template <typename SearchRelatedItemsRequestT = Model::SearchRelatedItemsRequest>
  void SearchRelatedItemsAsync(const SearchRelatedItemsRequestT& request, const SearchRelatedItemsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::SearchRelatedItems, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCaseOutcome UpdateCase(const Model::UpdateCaseRequest& request) const;
 
  template <typename UpdateCaseRequestT = Model::UpdateCaseRequest>
  Model::UpdateCaseOutcomeCallable UpdateCaseCallable(const UpdateCaseRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::UpdateCase, request);
  }
 
  template <typename UpdateCaseRequestT = Model::UpdateCaseRequest>
  void UpdateCaseAsync(const UpdateCaseRequestT& request, const UpdateCaseResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::UpdateCase, request, handler, context);
  }
 
  virtual Model::UpdateCaseRuleOutcome UpdateCaseRule(const Model::UpdateCaseRuleRequest& request) const;
 
  template <typename UpdateCaseRuleRequestT = Model::UpdateCaseRuleRequest>
  Model::UpdateCaseRuleOutcomeCallable UpdateCaseRuleCallable(const UpdateCaseRuleRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::UpdateCaseRule, request);
  }
 
  template <typename UpdateCaseRuleRequestT = Model::UpdateCaseRuleRequest>
  void UpdateCaseRuleAsync(const UpdateCaseRuleRequestT& request, const UpdateCaseRuleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::UpdateCaseRule, request, handler, context);
  }
 
  virtual Model::UpdateFieldOutcome UpdateField(const Model::UpdateFieldRequest& request) const;
 
  template <typename UpdateFieldRequestT = Model::UpdateFieldRequest>
  Model::UpdateFieldOutcomeCallable UpdateFieldCallable(const UpdateFieldRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::UpdateField, request);
  }
 
  template <typename UpdateFieldRequestT = Model::UpdateFieldRequest>
  void UpdateFieldAsync(const UpdateFieldRequestT& request, const UpdateFieldResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::UpdateField, request, handler, context);
  }
 
  virtual Model::UpdateLayoutOutcome UpdateLayout(const Model::UpdateLayoutRequest& request) const;
 
  template <typename UpdateLayoutRequestT = Model::UpdateLayoutRequest>
  Model::UpdateLayoutOutcomeCallable UpdateLayoutCallable(const UpdateLayoutRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::UpdateLayout, request);
  }
 
  template <typename UpdateLayoutRequestT = Model::UpdateLayoutRequest>
  void UpdateLayoutAsync(const UpdateLayoutRequestT& request, const UpdateLayoutResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::UpdateLayout, request, handler, context);
  }
 
  virtual Model::UpdateRelatedItemOutcome UpdateRelatedItem(const Model::UpdateRelatedItemRequest& request) const;
 
  template <typename UpdateRelatedItemRequestT = Model::UpdateRelatedItemRequest>
  Model::UpdateRelatedItemOutcomeCallable UpdateRelatedItemCallable(const UpdateRelatedItemRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::UpdateRelatedItem, request);
  }
 
  template <typename UpdateRelatedItemRequestT = Model::UpdateRelatedItemRequest>
  void UpdateRelatedItemAsync(const UpdateRelatedItemRequestT& request, const UpdateRelatedItemResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::UpdateRelatedItem, request, handler, context);
  }
 
  virtual Model::UpdateTemplateOutcome UpdateTemplate(const Model::UpdateTemplateRequest& request) const;
 
  template <typename UpdateTemplateRequestT = Model::UpdateTemplateRequest>
  Model::UpdateTemplateOutcomeCallable UpdateTemplateCallable(const UpdateTemplateRequestT& request) const {
    return SubmitCallable(&ConnectCasesClient::UpdateTemplate, request);
  }
 
  template <typename UpdateTemplateRequestT = Model::UpdateTemplateRequest>
  void UpdateTemplateAsync(const UpdateTemplateRequestT& request, const UpdateTemplateResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCasesClient::UpdateTemplate, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ConnectCasesEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectCasesClient>;
  void init(const ConnectCasesClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ConnectCasesError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ConnectCasesClientConfiguration m_clientConfiguration;
  std::shared_ptr<ConnectCasesEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ConnectCases
}  // namespace Aws