DeviceFarmClient.h

 
#pragma once
#include <aws/devicefarm/DeviceFarm_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/devicefarm/DeviceFarmServiceClientModel.h>
 
namespace Aws
{
namespace DeviceFarm
{
  class AWS_DEVICEFARM_API DeviceFarmClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DeviceFarmEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DeviceFarmClient>;
      void init(const DeviceFarmClientConfiguration& clientConfiguration);
 
      DeviceFarmClientConfiguration m_clientConfiguration;
      std::shared_ptr<DeviceFarmEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace DeviceFarm
} // namespace Aws