DeviceFarmClient.h

 
#pragma once
#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>
#include <aws/devicefarm/DeviceFarmPaginationBase.h>
#include <aws/devicefarm/DeviceFarmServiceClientModel.h>
#include <aws/devicefarm/DeviceFarmWaiter.h>
#include <aws/devicefarm/DeviceFarm_EXPORTS.h>
 
namespace Aws {
namespace DeviceFarm {
class AWS_DEVICEFARM_API DeviceFarmClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<DeviceFarmClient>,
                                            public DeviceFarmPaginationBase<DeviceFarmClient>,
                                            public DeviceFarmWaiter<DeviceFarmClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DeviceFarmClientConfiguration ClientConfigurationType;
  typedef DeviceFarmEndpointProvider EndpointProviderType;
 
  DeviceFarmClient(
      const Aws::DeviceFarm::DeviceFarmClientConfiguration& clientConfiguration = Aws::DeviceFarm::DeviceFarmClientConfiguration(),
      std::shared_ptr<DeviceFarmEndpointProviderBase> endpointProvider = nullptr);
 
  DeviceFarmClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DeviceFarmEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DeviceFarm::DeviceFarmClientConfiguration& clientConfiguration = Aws::DeviceFarm::DeviceFarmClientConfiguration());
 
  DeviceFarmClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<DeviceFarmEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DeviceFarm::DeviceFarmClientConfiguration& clientConfiguration = Aws::DeviceFarm::DeviceFarmClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DeviceFarmClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DeviceFarmClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DeviceFarmClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DeviceFarmClient();
 
  virtual Model::CreateDevicePoolOutcome CreateDevicePool(const Model::CreateDevicePoolRequest& request) const;
 
  template <typename CreateDevicePoolRequestT = Model::CreateDevicePoolRequest>
  Model::CreateDevicePoolOutcomeCallable CreateDevicePoolCallable(const CreateDevicePoolRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateDevicePool, request);
  }
 
  template <typename CreateDevicePoolRequestT = Model::CreateDevicePoolRequest>
  void CreateDevicePoolAsync(const CreateDevicePoolRequestT& request, const CreateDevicePoolResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateDevicePool, request, handler, context);
  }
 
  virtual Model::CreateInstanceProfileOutcome CreateInstanceProfile(const Model::CreateInstanceProfileRequest& request) const;
 
  template <typename CreateInstanceProfileRequestT = Model::CreateInstanceProfileRequest>
  Model::CreateInstanceProfileOutcomeCallable CreateInstanceProfileCallable(const CreateInstanceProfileRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateInstanceProfile, request);
  }
 
  template <typename CreateInstanceProfileRequestT = Model::CreateInstanceProfileRequest>
  void CreateInstanceProfileAsync(const CreateInstanceProfileRequestT& request, const CreateInstanceProfileResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateInstanceProfile, request, handler, context);
  }
 
  virtual Model::CreateNetworkProfileOutcome CreateNetworkProfile(const Model::CreateNetworkProfileRequest& request) const;
 
  template <typename CreateNetworkProfileRequestT = Model::CreateNetworkProfileRequest>
  Model::CreateNetworkProfileOutcomeCallable CreateNetworkProfileCallable(const CreateNetworkProfileRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateNetworkProfile, request);
  }
 
  template <typename CreateNetworkProfileRequestT = Model::CreateNetworkProfileRequest>
  void CreateNetworkProfileAsync(const CreateNetworkProfileRequestT& request, const CreateNetworkProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateNetworkProfile, request, handler, context);
  }
 
  virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateProject, request);
  }
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateProject, request, handler, context);
  }
 
  virtual Model::CreateRemoteAccessSessionOutcome CreateRemoteAccessSession(const Model::CreateRemoteAccessSessionRequest& request) const;
 
  template <typename CreateRemoteAccessSessionRequestT = Model::CreateRemoteAccessSessionRequest>
  Model::CreateRemoteAccessSessionOutcomeCallable CreateRemoteAccessSessionCallable(
      const CreateRemoteAccessSessionRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateRemoteAccessSession, request);
  }
 
  template <typename CreateRemoteAccessSessionRequestT = Model::CreateRemoteAccessSessionRequest>
  void CreateRemoteAccessSessionAsync(const CreateRemoteAccessSessionRequestT& request,
                                      const CreateRemoteAccessSessionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateRemoteAccessSession, request, handler, context);
  }
 
  virtual Model::CreateTestGridProjectOutcome CreateTestGridProject(const Model::CreateTestGridProjectRequest& request) const;
 
  template <typename CreateTestGridProjectRequestT = Model::CreateTestGridProjectRequest>
  Model::CreateTestGridProjectOutcomeCallable CreateTestGridProjectCallable(const CreateTestGridProjectRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateTestGridProject, request);
  }
 
  template <typename CreateTestGridProjectRequestT = Model::CreateTestGridProjectRequest>
  void CreateTestGridProjectAsync(const CreateTestGridProjectRequestT& request, const CreateTestGridProjectResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateTestGridProject, request, handler, context);
  }
 
  virtual Model::CreateTestGridUrlOutcome CreateTestGridUrl(const Model::CreateTestGridUrlRequest& request) const;
 
  template <typename CreateTestGridUrlRequestT = Model::CreateTestGridUrlRequest>
  Model::CreateTestGridUrlOutcomeCallable CreateTestGridUrlCallable(const CreateTestGridUrlRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateTestGridUrl, request);
  }
 
  template <typename CreateTestGridUrlRequestT = Model::CreateTestGridUrlRequest>
  void CreateTestGridUrlAsync(const CreateTestGridUrlRequestT& request, const CreateTestGridUrlResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateTestGridUrl, request, handler, context);
  }
 
  virtual Model::CreateUploadOutcome CreateUpload(const Model::CreateUploadRequest& request) const;
 
  template <typename CreateUploadRequestT = Model::CreateUploadRequest>
  Model::CreateUploadOutcomeCallable CreateUploadCallable(const CreateUploadRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateUpload, request);
  }
 
  template <typename CreateUploadRequestT = Model::CreateUploadRequest>
  void CreateUploadAsync(const CreateUploadRequestT& request, const CreateUploadResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateUpload, request, handler, context);
  }
 
  virtual Model::CreateVPCEConfigurationOutcome CreateVPCEConfiguration(const Model::CreateVPCEConfigurationRequest& request) const;
 
  template <typename CreateVPCEConfigurationRequestT = Model::CreateVPCEConfigurationRequest>
  Model::CreateVPCEConfigurationOutcomeCallable CreateVPCEConfigurationCallable(const CreateVPCEConfigurationRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::CreateVPCEConfiguration, request);
  }
 
  template <typename CreateVPCEConfigurationRequestT = Model::CreateVPCEConfigurationRequest>
  void CreateVPCEConfigurationAsync(const CreateVPCEConfigurationRequestT& request,
                                    const CreateVPCEConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::CreateVPCEConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteDevicePoolOutcome DeleteDevicePool(const Model::DeleteDevicePoolRequest& request) const;
 
  template <typename DeleteDevicePoolRequestT = Model::DeleteDevicePoolRequest>
  Model::DeleteDevicePoolOutcomeCallable DeleteDevicePoolCallable(const DeleteDevicePoolRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteDevicePool, request);
  }
 
  template <typename DeleteDevicePoolRequestT = Model::DeleteDevicePoolRequest>
  void DeleteDevicePoolAsync(const DeleteDevicePoolRequestT& request, const DeleteDevicePoolResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteDevicePool, request, handler, context);
  }
 
  virtual Model::DeleteInstanceProfileOutcome DeleteInstanceProfile(const Model::DeleteInstanceProfileRequest& request) const;
 
  template <typename DeleteInstanceProfileRequestT = Model::DeleteInstanceProfileRequest>
  Model::DeleteInstanceProfileOutcomeCallable DeleteInstanceProfileCallable(const DeleteInstanceProfileRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteInstanceProfile, request);
  }
 
  template <typename DeleteInstanceProfileRequestT = Model::DeleteInstanceProfileRequest>
  void DeleteInstanceProfileAsync(const DeleteInstanceProfileRequestT& request, const DeleteInstanceProfileResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteInstanceProfile, request, handler, context);
  }
 
  virtual Model::DeleteNetworkProfileOutcome DeleteNetworkProfile(const Model::DeleteNetworkProfileRequest& request) const;
 
  template <typename DeleteNetworkProfileRequestT = Model::DeleteNetworkProfileRequest>
  Model::DeleteNetworkProfileOutcomeCallable DeleteNetworkProfileCallable(const DeleteNetworkProfileRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteNetworkProfile, request);
  }
 
  template <typename DeleteNetworkProfileRequestT = Model::DeleteNetworkProfileRequest>
  void DeleteNetworkProfileAsync(const DeleteNetworkProfileRequestT& request, const DeleteNetworkProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteNetworkProfile, request, handler, context);
  }
 
  virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteProject, request);
  }
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteProject, request, handler, context);
  }
 
  virtual Model::DeleteRemoteAccessSessionOutcome DeleteRemoteAccessSession(const Model::DeleteRemoteAccessSessionRequest& request) const;
 
  template <typename DeleteRemoteAccessSessionRequestT = Model::DeleteRemoteAccessSessionRequest>
  Model::DeleteRemoteAccessSessionOutcomeCallable DeleteRemoteAccessSessionCallable(
      const DeleteRemoteAccessSessionRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteRemoteAccessSession, request);
  }
 
  template <typename DeleteRemoteAccessSessionRequestT = Model::DeleteRemoteAccessSessionRequest>
  void DeleteRemoteAccessSessionAsync(const DeleteRemoteAccessSessionRequestT& request,
                                      const DeleteRemoteAccessSessionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteRemoteAccessSession, request, handler, context);
  }
 
  virtual Model::DeleteRunOutcome DeleteRun(const Model::DeleteRunRequest& request) const;
 
  template <typename DeleteRunRequestT = Model::DeleteRunRequest>
  Model::DeleteRunOutcomeCallable DeleteRunCallable(const DeleteRunRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteRun, request);
  }
 
  template <typename DeleteRunRequestT = Model::DeleteRunRequest>
  void DeleteRunAsync(const DeleteRunRequestT& request, const DeleteRunResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteRun, request, handler, context);
  }
 
  virtual Model::DeleteTestGridProjectOutcome DeleteTestGridProject(const Model::DeleteTestGridProjectRequest& request) const;
 
  template <typename DeleteTestGridProjectRequestT = Model::DeleteTestGridProjectRequest>
  Model::DeleteTestGridProjectOutcomeCallable DeleteTestGridProjectCallable(const DeleteTestGridProjectRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteTestGridProject, request);
  }
 
  template <typename DeleteTestGridProjectRequestT = Model::DeleteTestGridProjectRequest>
  void DeleteTestGridProjectAsync(const DeleteTestGridProjectRequestT& request, const DeleteTestGridProjectResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteTestGridProject, request, handler, context);
  }
 
  virtual Model::DeleteUploadOutcome DeleteUpload(const Model::DeleteUploadRequest& request) const;
 
  template <typename DeleteUploadRequestT = Model::DeleteUploadRequest>
  Model::DeleteUploadOutcomeCallable DeleteUploadCallable(const DeleteUploadRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteUpload, request);
  }
 
  template <typename DeleteUploadRequestT = Model::DeleteUploadRequest>
  void DeleteUploadAsync(const DeleteUploadRequestT& request, const DeleteUploadResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteUpload, request, handler, context);
  }
 
  virtual Model::DeleteVPCEConfigurationOutcome DeleteVPCEConfiguration(const Model::DeleteVPCEConfigurationRequest& request) const;
 
  template <typename DeleteVPCEConfigurationRequestT = Model::DeleteVPCEConfigurationRequest>
  Model::DeleteVPCEConfigurationOutcomeCallable DeleteVPCEConfigurationCallable(const DeleteVPCEConfigurationRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::DeleteVPCEConfiguration, request);
  }
 
  template <typename DeleteVPCEConfigurationRequestT = Model::DeleteVPCEConfigurationRequest>
  void DeleteVPCEConfigurationAsync(const DeleteVPCEConfigurationRequestT& request,
                                    const DeleteVPCEConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::DeleteVPCEConfiguration, request, handler, context);
  }
 
  virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request = {}) const;
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::GetAccountSettings, request);
  }
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  void GetAccountSettingsAsync(const GetAccountSettingsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::GetAccountSettings, request, handler, context);
  }
 
  virtual Model::GetDeviceOutcome GetDevice(const Model::GetDeviceRequest& request) const;
 
  template <typename GetDeviceRequestT = Model::GetDeviceRequest>
  Model::GetDeviceOutcomeCallable GetDeviceCallable(const GetDeviceRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetDevice, request);
  }
 
  template <typename GetDeviceRequestT = Model::GetDeviceRequest>
  void GetDeviceAsync(const GetDeviceRequestT& request, const GetDeviceResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetDevice, request, handler, context);
  }
 
  virtual Model::GetDeviceInstanceOutcome GetDeviceInstance(const Model::GetDeviceInstanceRequest& request) const;
 
  template <typename GetDeviceInstanceRequestT = Model::GetDeviceInstanceRequest>
  Model::GetDeviceInstanceOutcomeCallable GetDeviceInstanceCallable(const GetDeviceInstanceRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetDeviceInstance, request);
  }
 
  template <typename GetDeviceInstanceRequestT = Model::GetDeviceInstanceRequest>
  void GetDeviceInstanceAsync(const GetDeviceInstanceRequestT& request, const GetDeviceInstanceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetDeviceInstance, request, handler, context);
  }
 
  virtual Model::GetDevicePoolOutcome GetDevicePool(const Model::GetDevicePoolRequest& request) const;
 
  template <typename GetDevicePoolRequestT = Model::GetDevicePoolRequest>
  Model::GetDevicePoolOutcomeCallable GetDevicePoolCallable(const GetDevicePoolRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetDevicePool, request);
  }
 
  template <typename GetDevicePoolRequestT = Model::GetDevicePoolRequest>
  void GetDevicePoolAsync(const GetDevicePoolRequestT& request, const GetDevicePoolResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetDevicePool, request, handler, context);
  }
 
  virtual Model::GetDevicePoolCompatibilityOutcome GetDevicePoolCompatibility(
      const Model::GetDevicePoolCompatibilityRequest& request) const;
 
  template <typename GetDevicePoolCompatibilityRequestT = Model::GetDevicePoolCompatibilityRequest>
  Model::GetDevicePoolCompatibilityOutcomeCallable GetDevicePoolCompatibilityCallable(
      const GetDevicePoolCompatibilityRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetDevicePoolCompatibility, request);
  }
 
  template <typename GetDevicePoolCompatibilityRequestT = Model::GetDevicePoolCompatibilityRequest>
  void GetDevicePoolCompatibilityAsync(const GetDevicePoolCompatibilityRequestT& request,
                                       const GetDevicePoolCompatibilityResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetDevicePoolCompatibility, request, handler, context);
  }
 
  virtual Model::GetInstanceProfileOutcome GetInstanceProfile(const Model::GetInstanceProfileRequest& request) const;
 
  template <typename GetInstanceProfileRequestT = Model::GetInstanceProfileRequest>
  Model::GetInstanceProfileOutcomeCallable GetInstanceProfileCallable(const GetInstanceProfileRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetInstanceProfile, request);
  }
 
  template <typename GetInstanceProfileRequestT = Model::GetInstanceProfileRequest>
  void GetInstanceProfileAsync(const GetInstanceProfileRequestT& request, const GetInstanceProfileResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetInstanceProfile, request, handler, context);
  }
 
  virtual Model::GetJobOutcome GetJob(const Model::GetJobRequest& request) const;
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  Model::GetJobOutcomeCallable GetJobCallable(const GetJobRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetJob, request);
  }
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  void GetJobAsync(const GetJobRequestT& request, const GetJobResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetJob, request, handler, context);
  }
 
  virtual Model::GetNetworkProfileOutcome GetNetworkProfile(const Model::GetNetworkProfileRequest& request) const;
 
  template <typename GetNetworkProfileRequestT = Model::GetNetworkProfileRequest>
  Model::GetNetworkProfileOutcomeCallable GetNetworkProfileCallable(const GetNetworkProfileRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetNetworkProfile, request);
  }
 
  template <typename GetNetworkProfileRequestT = Model::GetNetworkProfileRequest>
  void GetNetworkProfileAsync(const GetNetworkProfileRequestT& request, const GetNetworkProfileResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetNetworkProfile, request, handler, context);
  }
 
  virtual Model::GetOfferingStatusOutcome GetOfferingStatus(const Model::GetOfferingStatusRequest& request = {}) const;
 
  template <typename GetOfferingStatusRequestT = Model::GetOfferingStatusRequest>
  Model::GetOfferingStatusOutcomeCallable GetOfferingStatusCallable(const GetOfferingStatusRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::GetOfferingStatus, request);
  }
 
  template <typename GetOfferingStatusRequestT = Model::GetOfferingStatusRequest>
  void GetOfferingStatusAsync(const GetOfferingStatusResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetOfferingStatusRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::GetOfferingStatus, request, handler, context);
  }
 
  virtual Model::GetProjectOutcome GetProject(const Model::GetProjectRequest& request) const;
 
  template <typename GetProjectRequestT = Model::GetProjectRequest>
  Model::GetProjectOutcomeCallable GetProjectCallable(const GetProjectRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetProject, request);
  }
 
  template <typename GetProjectRequestT = Model::GetProjectRequest>
  void GetProjectAsync(const GetProjectRequestT& request, const GetProjectResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetProject, request, handler, context);
  }
 
  virtual Model::GetRemoteAccessSessionOutcome GetRemoteAccessSession(const Model::GetRemoteAccessSessionRequest& request) const;
 
  template <typename GetRemoteAccessSessionRequestT = Model::GetRemoteAccessSessionRequest>
  Model::GetRemoteAccessSessionOutcomeCallable GetRemoteAccessSessionCallable(const GetRemoteAccessSessionRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetRemoteAccessSession, request);
  }
 
  template <typename GetRemoteAccessSessionRequestT = Model::GetRemoteAccessSessionRequest>
  void GetRemoteAccessSessionAsync(const GetRemoteAccessSessionRequestT& request,
                                   const GetRemoteAccessSessionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetRemoteAccessSession, request, handler, context);
  }
 
  virtual Model::GetRunOutcome GetRun(const Model::GetRunRequest& request) const;
 
  template <typename GetRunRequestT = Model::GetRunRequest>
  Model::GetRunOutcomeCallable GetRunCallable(const GetRunRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetRun, request);
  }
 
  template <typename GetRunRequestT = Model::GetRunRequest>
  void GetRunAsync(const GetRunRequestT& request, const GetRunResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetRun, request, handler, context);
  }
 
  virtual Model::GetSuiteOutcome GetSuite(const Model::GetSuiteRequest& request) const;
 
  template <typename GetSuiteRequestT = Model::GetSuiteRequest>
  Model::GetSuiteOutcomeCallable GetSuiteCallable(const GetSuiteRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetSuite, request);
  }
 
  template <typename GetSuiteRequestT = Model::GetSuiteRequest>
  void GetSuiteAsync(const GetSuiteRequestT& request, const GetSuiteResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetSuite, request, handler, context);
  }
 
  virtual Model::GetTestOutcome GetTest(const Model::GetTestRequest& request) const;
 
  template <typename GetTestRequestT = Model::GetTestRequest>
  Model::GetTestOutcomeCallable GetTestCallable(const GetTestRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetTest, request);
  }
 
  template <typename GetTestRequestT = Model::GetTestRequest>
  void GetTestAsync(const GetTestRequestT& request, const GetTestResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetTest, request, handler, context);
  }
 
  virtual Model::GetTestGridProjectOutcome GetTestGridProject(const Model::GetTestGridProjectRequest& request) const;
 
  template <typename GetTestGridProjectRequestT = Model::GetTestGridProjectRequest>
  Model::GetTestGridProjectOutcomeCallable GetTestGridProjectCallable(const GetTestGridProjectRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetTestGridProject, request);
  }
 
  template <typename GetTestGridProjectRequestT = Model::GetTestGridProjectRequest>
  void GetTestGridProjectAsync(const GetTestGridProjectRequestT& request, const GetTestGridProjectResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetTestGridProject, request, handler, context);
  }
 
  virtual Model::GetTestGridSessionOutcome GetTestGridSession(const Model::GetTestGridSessionRequest& request = {}) const;
 
  template <typename GetTestGridSessionRequestT = Model::GetTestGridSessionRequest>
  Model::GetTestGridSessionOutcomeCallable GetTestGridSessionCallable(const GetTestGridSessionRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::GetTestGridSession, request);
  }
 
  template <typename GetTestGridSessionRequestT = Model::GetTestGridSessionRequest>
  void GetTestGridSessionAsync(const GetTestGridSessionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetTestGridSessionRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::GetTestGridSession, request, handler, context);
  }
 
  virtual Model::GetUploadOutcome GetUpload(const Model::GetUploadRequest& request) const;
 
  template <typename GetUploadRequestT = Model::GetUploadRequest>
  Model::GetUploadOutcomeCallable GetUploadCallable(const GetUploadRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetUpload, request);
  }
 
  template <typename GetUploadRequestT = Model::GetUploadRequest>
  void GetUploadAsync(const GetUploadRequestT& request, const GetUploadResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetUpload, request, handler, context);
  }
 
  virtual Model::GetVPCEConfigurationOutcome GetVPCEConfiguration(const Model::GetVPCEConfigurationRequest& request) const;
 
  template <typename GetVPCEConfigurationRequestT = Model::GetVPCEConfigurationRequest>
  Model::GetVPCEConfigurationOutcomeCallable GetVPCEConfigurationCallable(const GetVPCEConfigurationRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::GetVPCEConfiguration, request);
  }
 
  template <typename GetVPCEConfigurationRequestT = Model::GetVPCEConfigurationRequest>
  void GetVPCEConfigurationAsync(const GetVPCEConfigurationRequestT& request, const GetVPCEConfigurationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::GetVPCEConfiguration, request, handler, context);
  }
 
  virtual Model::InstallToRemoteAccessSessionOutcome InstallToRemoteAccessSession(
      const Model::InstallToRemoteAccessSessionRequest& request) const;
 
  template <typename InstallToRemoteAccessSessionRequestT = Model::InstallToRemoteAccessSessionRequest>
  Model::InstallToRemoteAccessSessionOutcomeCallable InstallToRemoteAccessSessionCallable(
      const InstallToRemoteAccessSessionRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::InstallToRemoteAccessSession, request);
  }
 
  template <typename InstallToRemoteAccessSessionRequestT = Model::InstallToRemoteAccessSessionRequest>
  void InstallToRemoteAccessSessionAsync(const InstallToRemoteAccessSessionRequestT& request,
                                         const InstallToRemoteAccessSessionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::InstallToRemoteAccessSession, request, handler, context);
  }
 
  virtual Model::ListArtifactsOutcome ListArtifacts(const Model::ListArtifactsRequest& request) const;
 
  template <typename ListArtifactsRequestT = Model::ListArtifactsRequest>
  Model::ListArtifactsOutcomeCallable ListArtifactsCallable(const ListArtifactsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListArtifacts, request);
  }
 
  template <typename ListArtifactsRequestT = Model::ListArtifactsRequest>
  void ListArtifactsAsync(const ListArtifactsRequestT& request, const ListArtifactsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListArtifacts, request, handler, context);
  }
 
  virtual Model::ListDeviceInstancesOutcome ListDeviceInstances(const Model::ListDeviceInstancesRequest& request = {}) const;
 
  template <typename ListDeviceInstancesRequestT = Model::ListDeviceInstancesRequest>
  Model::ListDeviceInstancesOutcomeCallable ListDeviceInstancesCallable(const ListDeviceInstancesRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListDeviceInstances, request);
  }
 
  template <typename ListDeviceInstancesRequestT = Model::ListDeviceInstancesRequest>
  void ListDeviceInstancesAsync(const ListDeviceInstancesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListDeviceInstancesRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListDeviceInstances, request, handler, context);
  }
 
  virtual Model::ListDevicePoolsOutcome ListDevicePools(const Model::ListDevicePoolsRequest& request) const;
 
  template <typename ListDevicePoolsRequestT = Model::ListDevicePoolsRequest>
  Model::ListDevicePoolsOutcomeCallable ListDevicePoolsCallable(const ListDevicePoolsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListDevicePools, request);
  }
 
  template <typename ListDevicePoolsRequestT = Model::ListDevicePoolsRequest>
  void ListDevicePoolsAsync(const ListDevicePoolsRequestT& request, const ListDevicePoolsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListDevicePools, request, handler, context);
  }
 
  virtual Model::ListDevicesOutcome ListDevices(const Model::ListDevicesRequest& request = {}) const;
 
  template <typename ListDevicesRequestT = Model::ListDevicesRequest>
  Model::ListDevicesOutcomeCallable ListDevicesCallable(const ListDevicesRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListDevices, request);
  }
 
  template <typename ListDevicesRequestT = Model::ListDevicesRequest>
  void ListDevicesAsync(const ListDevicesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListDevicesRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListDevices, request, handler, context);
  }
 
  virtual Model::ListInstanceProfilesOutcome ListInstanceProfiles(const Model::ListInstanceProfilesRequest& request = {}) const;
 
  template <typename ListInstanceProfilesRequestT = Model::ListInstanceProfilesRequest>
  Model::ListInstanceProfilesOutcomeCallable ListInstanceProfilesCallable(const ListInstanceProfilesRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListInstanceProfiles, request);
  }
 
  template <typename ListInstanceProfilesRequestT = Model::ListInstanceProfilesRequest>
  void ListInstanceProfilesAsync(const ListInstanceProfilesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListInstanceProfilesRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListInstanceProfiles, request, handler, context);
  }
 
  virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request) const;
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListJobs, request);
  }
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  void ListJobsAsync(const ListJobsRequestT& request, const ListJobsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListJobs, request, handler, context);
  }
 
  virtual Model::ListNetworkProfilesOutcome ListNetworkProfiles(const Model::ListNetworkProfilesRequest& request) const;
 
  template <typename ListNetworkProfilesRequestT = Model::ListNetworkProfilesRequest>
  Model::ListNetworkProfilesOutcomeCallable ListNetworkProfilesCallable(const ListNetworkProfilesRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListNetworkProfiles, request);
  }
 
  template <typename ListNetworkProfilesRequestT = Model::ListNetworkProfilesRequest>
  void ListNetworkProfilesAsync(const ListNetworkProfilesRequestT& request, const ListNetworkProfilesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListNetworkProfiles, request, handler, context);
  }
 
  virtual Model::ListOfferingPromotionsOutcome ListOfferingPromotions(const Model::ListOfferingPromotionsRequest& request = {}) const;
 
  template <typename ListOfferingPromotionsRequestT = Model::ListOfferingPromotionsRequest>
  Model::ListOfferingPromotionsOutcomeCallable ListOfferingPromotionsCallable(const ListOfferingPromotionsRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListOfferingPromotions, request);
  }
 
  template <typename ListOfferingPromotionsRequestT = Model::ListOfferingPromotionsRequest>
  void ListOfferingPromotionsAsync(const ListOfferingPromotionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListOfferingPromotionsRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListOfferingPromotions, request, handler, context);
  }
 
  virtual Model::ListOfferingTransactionsOutcome ListOfferingTransactions(const Model::ListOfferingTransactionsRequest& request = {}) const;
 
  template <typename ListOfferingTransactionsRequestT = Model::ListOfferingTransactionsRequest>
  Model::ListOfferingTransactionsOutcomeCallable ListOfferingTransactionsCallable(
      const ListOfferingTransactionsRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListOfferingTransactions, request);
  }
 
  template <typename ListOfferingTransactionsRequestT = Model::ListOfferingTransactionsRequest>
  void ListOfferingTransactionsAsync(const ListOfferingTransactionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListOfferingTransactionsRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListOfferingTransactions, request, handler, context);
  }
 
  virtual Model::ListOfferingsOutcome ListOfferings(const Model::ListOfferingsRequest& request = {}) const;
 
  template <typename ListOfferingsRequestT = Model::ListOfferingsRequest>
  Model::ListOfferingsOutcomeCallable ListOfferingsCallable(const ListOfferingsRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListOfferings, request);
  }
 
  template <typename ListOfferingsRequestT = Model::ListOfferingsRequest>
  void ListOfferingsAsync(const ListOfferingsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListOfferingsRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListOfferings, request, handler, context);
  }
 
  virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request = {}) const;
 
  template <typename ListProjectsRequestT = Model::ListProjectsRequest>
  Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListProjects, request);
  }
 
  template <typename ListProjectsRequestT = Model::ListProjectsRequest>
  void ListProjectsAsync(const ListProjectsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProjectsRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListProjects, request, handler, context);
  }
 
  virtual Model::ListRemoteAccessSessionsOutcome ListRemoteAccessSessions(const Model::ListRemoteAccessSessionsRequest& request) const;
 
  template <typename ListRemoteAccessSessionsRequestT = Model::ListRemoteAccessSessionsRequest>
  Model::ListRemoteAccessSessionsOutcomeCallable ListRemoteAccessSessionsCallable(const ListRemoteAccessSessionsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListRemoteAccessSessions, request);
  }
 
  template <typename ListRemoteAccessSessionsRequestT = Model::ListRemoteAccessSessionsRequest>
  void ListRemoteAccessSessionsAsync(const ListRemoteAccessSessionsRequestT& request,
                                     const ListRemoteAccessSessionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListRemoteAccessSessions, request, handler, context);
  }
 
  virtual Model::ListRunsOutcome ListRuns(const Model::ListRunsRequest& request) const;
 
  template <typename ListRunsRequestT = Model::ListRunsRequest>
  Model::ListRunsOutcomeCallable ListRunsCallable(const ListRunsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListRuns, request);
  }
 
  template <typename ListRunsRequestT = Model::ListRunsRequest>
  void ListRunsAsync(const ListRunsRequestT& request, const ListRunsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListRuns, request, handler, context);
  }
 
  virtual Model::ListSamplesOutcome ListSamples(const Model::ListSamplesRequest& request) const;
 
  template <typename ListSamplesRequestT = Model::ListSamplesRequest>
  Model::ListSamplesOutcomeCallable ListSamplesCallable(const ListSamplesRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListSamples, request);
  }
 
  template <typename ListSamplesRequestT = Model::ListSamplesRequest>
  void ListSamplesAsync(const ListSamplesRequestT& request, const ListSamplesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListSamples, request, handler, context);
  }
 
  virtual Model::ListSuitesOutcome ListSuites(const Model::ListSuitesRequest& request) const;
 
  template <typename ListSuitesRequestT = Model::ListSuitesRequest>
  Model::ListSuitesOutcomeCallable ListSuitesCallable(const ListSuitesRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListSuites, request);
  }
 
  template <typename ListSuitesRequestT = Model::ListSuitesRequest>
  void ListSuitesAsync(const ListSuitesRequestT& request, const ListSuitesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListSuites, 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(&DeviceFarmClient::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(&DeviceFarmClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTestGridProjectsOutcome ListTestGridProjects(const Model::ListTestGridProjectsRequest& request = {}) const;
 
  template <typename ListTestGridProjectsRequestT = Model::ListTestGridProjectsRequest>
  Model::ListTestGridProjectsOutcomeCallable ListTestGridProjectsCallable(const ListTestGridProjectsRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListTestGridProjects, request);
  }
 
  template <typename ListTestGridProjectsRequestT = Model::ListTestGridProjectsRequest>
  void ListTestGridProjectsAsync(const ListTestGridProjectsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListTestGridProjectsRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListTestGridProjects, request, handler, context);
  }
 
  virtual Model::ListTestGridSessionActionsOutcome ListTestGridSessionActions(
      const Model::ListTestGridSessionActionsRequest& request) const;
 
  template <typename ListTestGridSessionActionsRequestT = Model::ListTestGridSessionActionsRequest>
  Model::ListTestGridSessionActionsOutcomeCallable ListTestGridSessionActionsCallable(
      const ListTestGridSessionActionsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListTestGridSessionActions, request);
  }
 
  template <typename ListTestGridSessionActionsRequestT = Model::ListTestGridSessionActionsRequest>
  void ListTestGridSessionActionsAsync(const ListTestGridSessionActionsRequestT& request,
                                       const ListTestGridSessionActionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListTestGridSessionActions, request, handler, context);
  }
 
  virtual Model::ListTestGridSessionArtifactsOutcome ListTestGridSessionArtifacts(
      const Model::ListTestGridSessionArtifactsRequest& request) const;
 
  template <typename ListTestGridSessionArtifactsRequestT = Model::ListTestGridSessionArtifactsRequest>
  Model::ListTestGridSessionArtifactsOutcomeCallable ListTestGridSessionArtifactsCallable(
      const ListTestGridSessionArtifactsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListTestGridSessionArtifacts, request);
  }
 
  template <typename ListTestGridSessionArtifactsRequestT = Model::ListTestGridSessionArtifactsRequest>
  void ListTestGridSessionArtifactsAsync(const ListTestGridSessionArtifactsRequestT& request,
                                         const ListTestGridSessionArtifactsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListTestGridSessionArtifacts, request, handler, context);
  }
 
  virtual Model::ListTestGridSessionsOutcome ListTestGridSessions(const Model::ListTestGridSessionsRequest& request) const;
 
  template <typename ListTestGridSessionsRequestT = Model::ListTestGridSessionsRequest>
  Model::ListTestGridSessionsOutcomeCallable ListTestGridSessionsCallable(const ListTestGridSessionsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListTestGridSessions, request);
  }
 
  template <typename ListTestGridSessionsRequestT = Model::ListTestGridSessionsRequest>
  void ListTestGridSessionsAsync(const ListTestGridSessionsRequestT& request, const ListTestGridSessionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListTestGridSessions, request, handler, context);
  }
 
  virtual Model::ListTestsOutcome ListTests(const Model::ListTestsRequest& request) const;
 
  template <typename ListTestsRequestT = Model::ListTestsRequest>
  Model::ListTestsOutcomeCallable ListTestsCallable(const ListTestsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListTests, request);
  }
 
  template <typename ListTestsRequestT = Model::ListTestsRequest>
  void ListTestsAsync(const ListTestsRequestT& request, const ListTestsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListTests, request, handler, context);
  }
 
  virtual Model::ListUniqueProblemsOutcome ListUniqueProblems(const Model::ListUniqueProblemsRequest& request) const;
 
  template <typename ListUniqueProblemsRequestT = Model::ListUniqueProblemsRequest>
  Model::ListUniqueProblemsOutcomeCallable ListUniqueProblemsCallable(const ListUniqueProblemsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListUniqueProblems, request);
  }
 
  template <typename ListUniqueProblemsRequestT = Model::ListUniqueProblemsRequest>
  void ListUniqueProblemsAsync(const ListUniqueProblemsRequestT& request, const ListUniqueProblemsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListUniqueProblems, request, handler, context);
  }
 
  virtual Model::ListUploadsOutcome ListUploads(const Model::ListUploadsRequest& request) const;
 
  template <typename ListUploadsRequestT = Model::ListUploadsRequest>
  Model::ListUploadsOutcomeCallable ListUploadsCallable(const ListUploadsRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ListUploads, request);
  }
 
  template <typename ListUploadsRequestT = Model::ListUploadsRequest>
  void ListUploadsAsync(const ListUploadsRequestT& request, const ListUploadsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ListUploads, request, handler, context);
  }
 
  virtual Model::ListVPCEConfigurationsOutcome ListVPCEConfigurations(const Model::ListVPCEConfigurationsRequest& request = {}) const;
 
  template <typename ListVPCEConfigurationsRequestT = Model::ListVPCEConfigurationsRequest>
  Model::ListVPCEConfigurationsOutcomeCallable ListVPCEConfigurationsCallable(const ListVPCEConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&DeviceFarmClient::ListVPCEConfigurations, request);
  }
 
  template <typename ListVPCEConfigurationsRequestT = Model::ListVPCEConfigurationsRequest>
  void ListVPCEConfigurationsAsync(const ListVPCEConfigurationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListVPCEConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&DeviceFarmClient::ListVPCEConfigurations, request, handler, context);
  }
 
  virtual Model::PurchaseOfferingOutcome PurchaseOffering(const Model::PurchaseOfferingRequest& request) const;
 
  template <typename PurchaseOfferingRequestT = Model::PurchaseOfferingRequest>
  Model::PurchaseOfferingOutcomeCallable PurchaseOfferingCallable(const PurchaseOfferingRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::PurchaseOffering, request);
  }
 
  template <typename PurchaseOfferingRequestT = Model::PurchaseOfferingRequest>
  void PurchaseOfferingAsync(const PurchaseOfferingRequestT& request, const PurchaseOfferingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::PurchaseOffering, request, handler, context);
  }
 
  virtual Model::RenewOfferingOutcome RenewOffering(const Model::RenewOfferingRequest& request) const;
 
  template <typename RenewOfferingRequestT = Model::RenewOfferingRequest>
  Model::RenewOfferingOutcomeCallable RenewOfferingCallable(const RenewOfferingRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::RenewOffering, request);
  }
 
  template <typename RenewOfferingRequestT = Model::RenewOfferingRequest>
  void RenewOfferingAsync(const RenewOfferingRequestT& request, const RenewOfferingResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::RenewOffering, request, handler, context);
  }
 
  virtual Model::ScheduleRunOutcome ScheduleRun(const Model::ScheduleRunRequest& request) const;
 
  template <typename ScheduleRunRequestT = Model::ScheduleRunRequest>
  Model::ScheduleRunOutcomeCallable ScheduleRunCallable(const ScheduleRunRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::ScheduleRun, request);
  }
 
  template <typename ScheduleRunRequestT = Model::ScheduleRunRequest>
  void ScheduleRunAsync(const ScheduleRunRequestT& request, const ScheduleRunResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::ScheduleRun, request, handler, context);
  }
 
  virtual Model::StopJobOutcome StopJob(const Model::StopJobRequest& request) const;
 
  template <typename StopJobRequestT = Model::StopJobRequest>
  Model::StopJobOutcomeCallable StopJobCallable(const StopJobRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::StopJob, request);
  }
 
  template <typename StopJobRequestT = Model::StopJobRequest>
  void StopJobAsync(const StopJobRequestT& request, const StopJobResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::StopJob, request, handler, context);
  }
 
  virtual Model::StopRemoteAccessSessionOutcome StopRemoteAccessSession(const Model::StopRemoteAccessSessionRequest& request) const;
 
  template <typename StopRemoteAccessSessionRequestT = Model::StopRemoteAccessSessionRequest>
  Model::StopRemoteAccessSessionOutcomeCallable StopRemoteAccessSessionCallable(const StopRemoteAccessSessionRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::StopRemoteAccessSession, request);
  }
 
  template <typename StopRemoteAccessSessionRequestT = Model::StopRemoteAccessSessionRequest>
  void StopRemoteAccessSessionAsync(const StopRemoteAccessSessionRequestT& request,
                                    const StopRemoteAccessSessionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::StopRemoteAccessSession, request, handler, context);
  }
 
  virtual Model::StopRunOutcome StopRun(const Model::StopRunRequest& request) const;
 
  template <typename StopRunRequestT = Model::StopRunRequest>
  Model::StopRunOutcomeCallable StopRunCallable(const StopRunRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::StopRun, request);
  }
 
  template <typename StopRunRequestT = Model::StopRunRequest>
  void StopRunAsync(const StopRunRequestT& request, const StopRunResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::StopRun, 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(&DeviceFarmClient::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(&DeviceFarmClient::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(&DeviceFarmClient::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(&DeviceFarmClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateDeviceInstanceOutcome UpdateDeviceInstance(const Model::UpdateDeviceInstanceRequest& request) const;
 
  template <typename UpdateDeviceInstanceRequestT = Model::UpdateDeviceInstanceRequest>
  Model::UpdateDeviceInstanceOutcomeCallable UpdateDeviceInstanceCallable(const UpdateDeviceInstanceRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::UpdateDeviceInstance, request);
  }
 
  template <typename UpdateDeviceInstanceRequestT = Model::UpdateDeviceInstanceRequest>
  void UpdateDeviceInstanceAsync(const UpdateDeviceInstanceRequestT& request, const UpdateDeviceInstanceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::UpdateDeviceInstance, request, handler, context);
  }
 
  virtual Model::UpdateDevicePoolOutcome UpdateDevicePool(const Model::UpdateDevicePoolRequest& request) const;
 
  template <typename UpdateDevicePoolRequestT = Model::UpdateDevicePoolRequest>
  Model::UpdateDevicePoolOutcomeCallable UpdateDevicePoolCallable(const UpdateDevicePoolRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::UpdateDevicePool, request);
  }
 
  template <typename UpdateDevicePoolRequestT = Model::UpdateDevicePoolRequest>
  void UpdateDevicePoolAsync(const UpdateDevicePoolRequestT& request, const UpdateDevicePoolResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::UpdateDevicePool, request, handler, context);
  }
 
  virtual Model::UpdateInstanceProfileOutcome UpdateInstanceProfile(const Model::UpdateInstanceProfileRequest& request) const;
 
  template <typename UpdateInstanceProfileRequestT = Model::UpdateInstanceProfileRequest>
  Model::UpdateInstanceProfileOutcomeCallable UpdateInstanceProfileCallable(const UpdateInstanceProfileRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::UpdateInstanceProfile, request);
  }
 
  template <typename UpdateInstanceProfileRequestT = Model::UpdateInstanceProfileRequest>
  void UpdateInstanceProfileAsync(const UpdateInstanceProfileRequestT& request, const UpdateInstanceProfileResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::UpdateInstanceProfile, request, handler, context);
  }
 
  virtual Model::UpdateNetworkProfileOutcome UpdateNetworkProfile(const Model::UpdateNetworkProfileRequest& request) const;
 
  template <typename UpdateNetworkProfileRequestT = Model::UpdateNetworkProfileRequest>
  Model::UpdateNetworkProfileOutcomeCallable UpdateNetworkProfileCallable(const UpdateNetworkProfileRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::UpdateNetworkProfile, request);
  }
 
  template <typename UpdateNetworkProfileRequestT = Model::UpdateNetworkProfileRequest>
  void UpdateNetworkProfileAsync(const UpdateNetworkProfileRequestT& request, const UpdateNetworkProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::UpdateNetworkProfile, request, handler, context);
  }
 
  virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const;
 
  template <typename UpdateProjectRequestT = Model::UpdateProjectRequest>
  Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::UpdateProject, request);
  }
 
  template <typename UpdateProjectRequestT = Model::UpdateProjectRequest>
  void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::UpdateProject, request, handler, context);
  }
 
  virtual Model::UpdateTestGridProjectOutcome UpdateTestGridProject(const Model::UpdateTestGridProjectRequest& request) const;
 
  template <typename UpdateTestGridProjectRequestT = Model::UpdateTestGridProjectRequest>
  Model::UpdateTestGridProjectOutcomeCallable UpdateTestGridProjectCallable(const UpdateTestGridProjectRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::UpdateTestGridProject, request);
  }
 
  template <typename UpdateTestGridProjectRequestT = Model::UpdateTestGridProjectRequest>
  void UpdateTestGridProjectAsync(const UpdateTestGridProjectRequestT& request, const UpdateTestGridProjectResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::UpdateTestGridProject, request, handler, context);
  }
 
  virtual Model::UpdateUploadOutcome UpdateUpload(const Model::UpdateUploadRequest& request) const;
 
  template <typename UpdateUploadRequestT = Model::UpdateUploadRequest>
  Model::UpdateUploadOutcomeCallable UpdateUploadCallable(const UpdateUploadRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::UpdateUpload, request);
  }
 
  template <typename UpdateUploadRequestT = Model::UpdateUploadRequest>
  void UpdateUploadAsync(const UpdateUploadRequestT& request, const UpdateUploadResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::UpdateUpload, request, handler, context);
  }
 
  virtual Model::UpdateVPCEConfigurationOutcome UpdateVPCEConfiguration(const Model::UpdateVPCEConfigurationRequest& request) const;
 
  template <typename UpdateVPCEConfigurationRequestT = Model::UpdateVPCEConfigurationRequest>
  Model::UpdateVPCEConfigurationOutcomeCallable UpdateVPCEConfigurationCallable(const UpdateVPCEConfigurationRequestT& request) const {
    return SubmitCallable(&DeviceFarmClient::UpdateVPCEConfiguration, request);
  }
 
  template <typename UpdateVPCEConfigurationRequestT = Model::UpdateVPCEConfigurationRequest>
  void UpdateVPCEConfigurationAsync(const UpdateVPCEConfigurationRequestT& request,
                                    const UpdateVPCEConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeviceFarmClient::UpdateVPCEConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DeviceFarmEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DeviceFarmClient>;
  void init(const DeviceFarmClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DeviceFarmError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  DeviceFarmClientConfiguration m_clientConfiguration;
  std::shared_ptr<DeviceFarmEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DeviceFarm
}  // namespace Aws