ConnectCasesClient.h

 
#pragma once
#include <aws/connectcases/ConnectCases_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/connectcases/ConnectCasesServiceClientModel.h>
 
namespace Aws
{
namespace ConnectCases
{
  class AWS_CONNECTCASES_API ConnectCasesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ConnectCasesEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectCasesClient>;
      void init(const ConnectCasesClientConfiguration& clientConfiguration);
 
      ConnectCasesClientConfiguration m_clientConfiguration;
      std::shared_ptr<ConnectCasesEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ConnectCases
} // namespace Aws