IoTWirelessClient.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/iotwireless/IoTWirelessPaginationBase.h>
#include <aws/iotwireless/IoTWirelessServiceClientModel.h>
#include <aws/iotwireless/IoTWirelessWaiter.h>
#include <aws/iotwireless/IoTWireless_EXPORTS.h>
 
namespace Aws {
namespace IoTWireless {
class AWS_IOTWIRELESS_API IoTWirelessClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<IoTWirelessClient>,
                                              public IoTWirelessPaginationBase<IoTWirelessClient>,
                                              public IoTWirelessWaiter<IoTWirelessClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef IoTWirelessClientConfiguration ClientConfigurationType;
  typedef IoTWirelessEndpointProvider EndpointProviderType;
 
  IoTWirelessClient(
      const Aws::IoTWireless::IoTWirelessClientConfiguration& clientConfiguration = Aws::IoTWireless::IoTWirelessClientConfiguration(),
      std::shared_ptr<IoTWirelessEndpointProviderBase> endpointProvider = nullptr);
 
  IoTWirelessClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<IoTWirelessEndpointProviderBase> endpointProvider = nullptr,
      const Aws::IoTWireless::IoTWirelessClientConfiguration& clientConfiguration = Aws::IoTWireless::IoTWirelessClientConfiguration());
 
  IoTWirelessClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<IoTWirelessEndpointProviderBase> endpointProvider = nullptr,
      const Aws::IoTWireless::IoTWirelessClientConfiguration& clientConfiguration = Aws::IoTWireless::IoTWirelessClientConfiguration());
 
  /* Legacy constructors due deprecation */
  IoTWirelessClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  IoTWirelessClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  IoTWirelessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~IoTWirelessClient();
 
  virtual Model::AssociateAwsAccountWithPartnerAccountOutcome AssociateAwsAccountWithPartnerAccount(
      const Model::AssociateAwsAccountWithPartnerAccountRequest& request) const;
 
  template <typename AssociateAwsAccountWithPartnerAccountRequestT = Model::AssociateAwsAccountWithPartnerAccountRequest>
  Model::AssociateAwsAccountWithPartnerAccountOutcomeCallable AssociateAwsAccountWithPartnerAccountCallable(
      const AssociateAwsAccountWithPartnerAccountRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::AssociateAwsAccountWithPartnerAccount, request);
  }
 
  template <typename AssociateAwsAccountWithPartnerAccountRequestT = Model::AssociateAwsAccountWithPartnerAccountRequest>
  void AssociateAwsAccountWithPartnerAccountAsync(const AssociateAwsAccountWithPartnerAccountRequestT& request,
                                                  const AssociateAwsAccountWithPartnerAccountResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::AssociateAwsAccountWithPartnerAccount, request, handler, context);
  }
 
  virtual Model::AssociateMulticastGroupWithFuotaTaskOutcome AssociateMulticastGroupWithFuotaTask(
      const Model::AssociateMulticastGroupWithFuotaTaskRequest& request) const;
 
  template <typename AssociateMulticastGroupWithFuotaTaskRequestT = Model::AssociateMulticastGroupWithFuotaTaskRequest>
  Model::AssociateMulticastGroupWithFuotaTaskOutcomeCallable AssociateMulticastGroupWithFuotaTaskCallable(
      const AssociateMulticastGroupWithFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::AssociateMulticastGroupWithFuotaTask, request);
  }
 
  template <typename AssociateMulticastGroupWithFuotaTaskRequestT = Model::AssociateMulticastGroupWithFuotaTaskRequest>
  void AssociateMulticastGroupWithFuotaTaskAsync(const AssociateMulticastGroupWithFuotaTaskRequestT& request,
                                                 const AssociateMulticastGroupWithFuotaTaskResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::AssociateMulticastGroupWithFuotaTask, request, handler, context);
  }
 
  virtual Model::AssociateWirelessDeviceWithFuotaTaskOutcome AssociateWirelessDeviceWithFuotaTask(
      const Model::AssociateWirelessDeviceWithFuotaTaskRequest& request) const;
 
  template <typename AssociateWirelessDeviceWithFuotaTaskRequestT = Model::AssociateWirelessDeviceWithFuotaTaskRequest>
  Model::AssociateWirelessDeviceWithFuotaTaskOutcomeCallable AssociateWirelessDeviceWithFuotaTaskCallable(
      const AssociateWirelessDeviceWithFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::AssociateWirelessDeviceWithFuotaTask, request);
  }
 
  template <typename AssociateWirelessDeviceWithFuotaTaskRequestT = Model::AssociateWirelessDeviceWithFuotaTaskRequest>
  void AssociateWirelessDeviceWithFuotaTaskAsync(const AssociateWirelessDeviceWithFuotaTaskRequestT& request,
                                                 const AssociateWirelessDeviceWithFuotaTaskResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::AssociateWirelessDeviceWithFuotaTask, request, handler, context);
  }
 
  virtual Model::AssociateWirelessDeviceWithMulticastGroupOutcome AssociateWirelessDeviceWithMulticastGroup(
      const Model::AssociateWirelessDeviceWithMulticastGroupRequest& request) const;
 
  template <typename AssociateWirelessDeviceWithMulticastGroupRequestT = Model::AssociateWirelessDeviceWithMulticastGroupRequest>
  Model::AssociateWirelessDeviceWithMulticastGroupOutcomeCallable AssociateWirelessDeviceWithMulticastGroupCallable(
      const AssociateWirelessDeviceWithMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::AssociateWirelessDeviceWithMulticastGroup, request);
  }
 
  template <typename AssociateWirelessDeviceWithMulticastGroupRequestT = Model::AssociateWirelessDeviceWithMulticastGroupRequest>
  void AssociateWirelessDeviceWithMulticastGroupAsync(
      const AssociateWirelessDeviceWithMulticastGroupRequestT& request,
      const AssociateWirelessDeviceWithMulticastGroupResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::AssociateWirelessDeviceWithMulticastGroup, request, handler, context);
  }
 
  virtual Model::AssociateWirelessDeviceWithThingOutcome AssociateWirelessDeviceWithThing(
      const Model::AssociateWirelessDeviceWithThingRequest& request) const;
 
  template <typename AssociateWirelessDeviceWithThingRequestT = Model::AssociateWirelessDeviceWithThingRequest>
  Model::AssociateWirelessDeviceWithThingOutcomeCallable AssociateWirelessDeviceWithThingCallable(
      const AssociateWirelessDeviceWithThingRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::AssociateWirelessDeviceWithThing, request);
  }
 
  template <typename AssociateWirelessDeviceWithThingRequestT = Model::AssociateWirelessDeviceWithThingRequest>
  void AssociateWirelessDeviceWithThingAsync(const AssociateWirelessDeviceWithThingRequestT& request,
                                             const AssociateWirelessDeviceWithThingResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::AssociateWirelessDeviceWithThing, request, handler, context);
  }
 
  virtual Model::AssociateWirelessGatewayWithCertificateOutcome AssociateWirelessGatewayWithCertificate(
      const Model::AssociateWirelessGatewayWithCertificateRequest& request) const;
 
  template <typename AssociateWirelessGatewayWithCertificateRequestT = Model::AssociateWirelessGatewayWithCertificateRequest>
  Model::AssociateWirelessGatewayWithCertificateOutcomeCallable AssociateWirelessGatewayWithCertificateCallable(
      const AssociateWirelessGatewayWithCertificateRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::AssociateWirelessGatewayWithCertificate, request);
  }
 
  template <typename AssociateWirelessGatewayWithCertificateRequestT = Model::AssociateWirelessGatewayWithCertificateRequest>
  void AssociateWirelessGatewayWithCertificateAsync(const AssociateWirelessGatewayWithCertificateRequestT& request,
                                                    const AssociateWirelessGatewayWithCertificateResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::AssociateWirelessGatewayWithCertificate, request, handler, context);
  }
 
  virtual Model::AssociateWirelessGatewayWithThingOutcome AssociateWirelessGatewayWithThing(
      const Model::AssociateWirelessGatewayWithThingRequest& request) const;
 
  template <typename AssociateWirelessGatewayWithThingRequestT = Model::AssociateWirelessGatewayWithThingRequest>
  Model::AssociateWirelessGatewayWithThingOutcomeCallable AssociateWirelessGatewayWithThingCallable(
      const AssociateWirelessGatewayWithThingRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::AssociateWirelessGatewayWithThing, request);
  }
 
  template <typename AssociateWirelessGatewayWithThingRequestT = Model::AssociateWirelessGatewayWithThingRequest>
  void AssociateWirelessGatewayWithThingAsync(const AssociateWirelessGatewayWithThingRequestT& request,
                                              const AssociateWirelessGatewayWithThingResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::AssociateWirelessGatewayWithThing, request, handler, context);
  }
 
  virtual Model::CancelMulticastGroupSessionOutcome CancelMulticastGroupSession(
      const Model::CancelMulticastGroupSessionRequest& request) const;
 
  template <typename CancelMulticastGroupSessionRequestT = Model::CancelMulticastGroupSessionRequest>
  Model::CancelMulticastGroupSessionOutcomeCallable CancelMulticastGroupSessionCallable(
      const CancelMulticastGroupSessionRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CancelMulticastGroupSession, request);
  }
 
  template <typename CancelMulticastGroupSessionRequestT = Model::CancelMulticastGroupSessionRequest>
  void CancelMulticastGroupSessionAsync(const CancelMulticastGroupSessionRequestT& request,
                                        const CancelMulticastGroupSessionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CancelMulticastGroupSession, request, handler, context);
  }
 
  virtual Model::CreateDestinationOutcome CreateDestination(const Model::CreateDestinationRequest& request) const;
 
  template <typename CreateDestinationRequestT = Model::CreateDestinationRequest>
  Model::CreateDestinationOutcomeCallable CreateDestinationCallable(const CreateDestinationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CreateDestination, request);
  }
 
  template <typename CreateDestinationRequestT = Model::CreateDestinationRequest>
  void CreateDestinationAsync(const CreateDestinationRequestT& request, const CreateDestinationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CreateDestination, request, handler, context);
  }
 
  virtual Model::CreateDeviceProfileOutcome CreateDeviceProfile(const Model::CreateDeviceProfileRequest& request = {}) const;
 
  template <typename CreateDeviceProfileRequestT = Model::CreateDeviceProfileRequest>
  Model::CreateDeviceProfileOutcomeCallable CreateDeviceProfileCallable(const CreateDeviceProfileRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::CreateDeviceProfile, request);
  }
 
  template <typename CreateDeviceProfileRequestT = Model::CreateDeviceProfileRequest>
  void CreateDeviceProfileAsync(const CreateDeviceProfileResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const CreateDeviceProfileRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::CreateDeviceProfile, request, handler, context);
  }
 
  virtual Model::CreateFuotaTaskOutcome CreateFuotaTask(const Model::CreateFuotaTaskRequest& request) const;
 
  template <typename CreateFuotaTaskRequestT = Model::CreateFuotaTaskRequest>
  Model::CreateFuotaTaskOutcomeCallable CreateFuotaTaskCallable(const CreateFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CreateFuotaTask, request);
  }
 
  template <typename CreateFuotaTaskRequestT = Model::CreateFuotaTaskRequest>
  void CreateFuotaTaskAsync(const CreateFuotaTaskRequestT& request, const CreateFuotaTaskResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CreateFuotaTask, request, handler, context);
  }
 
  virtual Model::CreateMulticastGroupOutcome CreateMulticastGroup(const Model::CreateMulticastGroupRequest& request) const;
 
  template <typename CreateMulticastGroupRequestT = Model::CreateMulticastGroupRequest>
  Model::CreateMulticastGroupOutcomeCallable CreateMulticastGroupCallable(const CreateMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CreateMulticastGroup, request);
  }
 
  template <typename CreateMulticastGroupRequestT = Model::CreateMulticastGroupRequest>
  void CreateMulticastGroupAsync(const CreateMulticastGroupRequestT& request, const CreateMulticastGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CreateMulticastGroup, request, handler, context);
  }
 
  virtual Model::CreateNetworkAnalyzerConfigurationOutcome CreateNetworkAnalyzerConfiguration(
      const Model::CreateNetworkAnalyzerConfigurationRequest& request) const;
 
  template <typename CreateNetworkAnalyzerConfigurationRequestT = Model::CreateNetworkAnalyzerConfigurationRequest>
  Model::CreateNetworkAnalyzerConfigurationOutcomeCallable CreateNetworkAnalyzerConfigurationCallable(
      const CreateNetworkAnalyzerConfigurationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CreateNetworkAnalyzerConfiguration, request);
  }
 
  template <typename CreateNetworkAnalyzerConfigurationRequestT = Model::CreateNetworkAnalyzerConfigurationRequest>
  void CreateNetworkAnalyzerConfigurationAsync(const CreateNetworkAnalyzerConfigurationRequestT& request,
                                               const CreateNetworkAnalyzerConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CreateNetworkAnalyzerConfiguration, request, handler, context);
  }
 
  virtual Model::CreateServiceProfileOutcome CreateServiceProfile(const Model::CreateServiceProfileRequest& request = {}) const;
 
  template <typename CreateServiceProfileRequestT = Model::CreateServiceProfileRequest>
  Model::CreateServiceProfileOutcomeCallable CreateServiceProfileCallable(const CreateServiceProfileRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::CreateServiceProfile, request);
  }
 
  template <typename CreateServiceProfileRequestT = Model::CreateServiceProfileRequest>
  void CreateServiceProfileAsync(const CreateServiceProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const CreateServiceProfileRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::CreateServiceProfile, request, handler, context);
  }
 
  virtual Model::CreateWirelessDeviceOutcome CreateWirelessDevice(const Model::CreateWirelessDeviceRequest& request) const;
 
  template <typename CreateWirelessDeviceRequestT = Model::CreateWirelessDeviceRequest>
  Model::CreateWirelessDeviceOutcomeCallable CreateWirelessDeviceCallable(const CreateWirelessDeviceRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CreateWirelessDevice, request);
  }
 
  template <typename CreateWirelessDeviceRequestT = Model::CreateWirelessDeviceRequest>
  void CreateWirelessDeviceAsync(const CreateWirelessDeviceRequestT& request, const CreateWirelessDeviceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CreateWirelessDevice, request, handler, context);
  }
 
  virtual Model::CreateWirelessGatewayOutcome CreateWirelessGateway(const Model::CreateWirelessGatewayRequest& request) const;
 
  template <typename CreateWirelessGatewayRequestT = Model::CreateWirelessGatewayRequest>
  Model::CreateWirelessGatewayOutcomeCallable CreateWirelessGatewayCallable(const CreateWirelessGatewayRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CreateWirelessGateway, request);
  }
 
  template <typename CreateWirelessGatewayRequestT = Model::CreateWirelessGatewayRequest>
  void CreateWirelessGatewayAsync(const CreateWirelessGatewayRequestT& request, const CreateWirelessGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CreateWirelessGateway, request, handler, context);
  }
 
  virtual Model::CreateWirelessGatewayTaskOutcome CreateWirelessGatewayTask(const Model::CreateWirelessGatewayTaskRequest& request) const;
 
  template <typename CreateWirelessGatewayTaskRequestT = Model::CreateWirelessGatewayTaskRequest>
  Model::CreateWirelessGatewayTaskOutcomeCallable CreateWirelessGatewayTaskCallable(
      const CreateWirelessGatewayTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CreateWirelessGatewayTask, request);
  }
 
  template <typename CreateWirelessGatewayTaskRequestT = Model::CreateWirelessGatewayTaskRequest>
  void CreateWirelessGatewayTaskAsync(const CreateWirelessGatewayTaskRequestT& request,
                                      const CreateWirelessGatewayTaskResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CreateWirelessGatewayTask, request, handler, context);
  }
 
  virtual Model::CreateWirelessGatewayTaskDefinitionOutcome CreateWirelessGatewayTaskDefinition(
      const Model::CreateWirelessGatewayTaskDefinitionRequest& request) const;
 
  template <typename CreateWirelessGatewayTaskDefinitionRequestT = Model::CreateWirelessGatewayTaskDefinitionRequest>
  Model::CreateWirelessGatewayTaskDefinitionOutcomeCallable CreateWirelessGatewayTaskDefinitionCallable(
      const CreateWirelessGatewayTaskDefinitionRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::CreateWirelessGatewayTaskDefinition, request);
  }
 
  template <typename CreateWirelessGatewayTaskDefinitionRequestT = Model::CreateWirelessGatewayTaskDefinitionRequest>
  void CreateWirelessGatewayTaskDefinitionAsync(const CreateWirelessGatewayTaskDefinitionRequestT& request,
                                                const CreateWirelessGatewayTaskDefinitionResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::CreateWirelessGatewayTaskDefinition, request, handler, context);
  }
 
  virtual Model::DeleteDestinationOutcome DeleteDestination(const Model::DeleteDestinationRequest& request) const;
 
  template <typename DeleteDestinationRequestT = Model::DeleteDestinationRequest>
  Model::DeleteDestinationOutcomeCallable DeleteDestinationCallable(const DeleteDestinationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteDestination, request);
  }
 
  template <typename DeleteDestinationRequestT = Model::DeleteDestinationRequest>
  void DeleteDestinationAsync(const DeleteDestinationRequestT& request, const DeleteDestinationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteDestination, request, handler, context);
  }
 
  virtual Model::DeleteDeviceProfileOutcome DeleteDeviceProfile(const Model::DeleteDeviceProfileRequest& request) const;
 
  template <typename DeleteDeviceProfileRequestT = Model::DeleteDeviceProfileRequest>
  Model::DeleteDeviceProfileOutcomeCallable DeleteDeviceProfileCallable(const DeleteDeviceProfileRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteDeviceProfile, request);
  }
 
  template <typename DeleteDeviceProfileRequestT = Model::DeleteDeviceProfileRequest>
  void DeleteDeviceProfileAsync(const DeleteDeviceProfileRequestT& request, const DeleteDeviceProfileResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteDeviceProfile, request, handler, context);
  }
 
  virtual Model::DeleteFuotaTaskOutcome DeleteFuotaTask(const Model::DeleteFuotaTaskRequest& request) const;
 
  template <typename DeleteFuotaTaskRequestT = Model::DeleteFuotaTaskRequest>
  Model::DeleteFuotaTaskOutcomeCallable DeleteFuotaTaskCallable(const DeleteFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteFuotaTask, request);
  }
 
  template <typename DeleteFuotaTaskRequestT = Model::DeleteFuotaTaskRequest>
  void DeleteFuotaTaskAsync(const DeleteFuotaTaskRequestT& request, const DeleteFuotaTaskResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteFuotaTask, request, handler, context);
  }
 
  virtual Model::DeleteMulticastGroupOutcome DeleteMulticastGroup(const Model::DeleteMulticastGroupRequest& request) const;
 
  template <typename DeleteMulticastGroupRequestT = Model::DeleteMulticastGroupRequest>
  Model::DeleteMulticastGroupOutcomeCallable DeleteMulticastGroupCallable(const DeleteMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteMulticastGroup, request);
  }
 
  template <typename DeleteMulticastGroupRequestT = Model::DeleteMulticastGroupRequest>
  void DeleteMulticastGroupAsync(const DeleteMulticastGroupRequestT& request, const DeleteMulticastGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteMulticastGroup, request, handler, context);
  }
 
  virtual Model::DeleteNetworkAnalyzerConfigurationOutcome DeleteNetworkAnalyzerConfiguration(
      const Model::DeleteNetworkAnalyzerConfigurationRequest& request) const;
 
  template <typename DeleteNetworkAnalyzerConfigurationRequestT = Model::DeleteNetworkAnalyzerConfigurationRequest>
  Model::DeleteNetworkAnalyzerConfigurationOutcomeCallable DeleteNetworkAnalyzerConfigurationCallable(
      const DeleteNetworkAnalyzerConfigurationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteNetworkAnalyzerConfiguration, request);
  }
 
  template <typename DeleteNetworkAnalyzerConfigurationRequestT = Model::DeleteNetworkAnalyzerConfigurationRequest>
  void DeleteNetworkAnalyzerConfigurationAsync(const DeleteNetworkAnalyzerConfigurationRequestT& request,
                                               const DeleteNetworkAnalyzerConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteNetworkAnalyzerConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteQueuedMessagesOutcome DeleteQueuedMessages(const Model::DeleteQueuedMessagesRequest& request) const;
 
  template <typename DeleteQueuedMessagesRequestT = Model::DeleteQueuedMessagesRequest>
  Model::DeleteQueuedMessagesOutcomeCallable DeleteQueuedMessagesCallable(const DeleteQueuedMessagesRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteQueuedMessages, request);
  }
 
  template <typename DeleteQueuedMessagesRequestT = Model::DeleteQueuedMessagesRequest>
  void DeleteQueuedMessagesAsync(const DeleteQueuedMessagesRequestT& request, const DeleteQueuedMessagesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteQueuedMessages, request, handler, context);
  }
 
  virtual Model::DeleteServiceProfileOutcome DeleteServiceProfile(const Model::DeleteServiceProfileRequest& request) const;
 
  template <typename DeleteServiceProfileRequestT = Model::DeleteServiceProfileRequest>
  Model::DeleteServiceProfileOutcomeCallable DeleteServiceProfileCallable(const DeleteServiceProfileRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteServiceProfile, request);
  }
 
  template <typename DeleteServiceProfileRequestT = Model::DeleteServiceProfileRequest>
  void DeleteServiceProfileAsync(const DeleteServiceProfileRequestT& request, const DeleteServiceProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteServiceProfile, request, handler, context);
  }
 
  virtual Model::DeleteWirelessDeviceOutcome DeleteWirelessDevice(const Model::DeleteWirelessDeviceRequest& request) const;
 
  template <typename DeleteWirelessDeviceRequestT = Model::DeleteWirelessDeviceRequest>
  Model::DeleteWirelessDeviceOutcomeCallable DeleteWirelessDeviceCallable(const DeleteWirelessDeviceRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteWirelessDevice, request);
  }
 
  template <typename DeleteWirelessDeviceRequestT = Model::DeleteWirelessDeviceRequest>
  void DeleteWirelessDeviceAsync(const DeleteWirelessDeviceRequestT& request, const DeleteWirelessDeviceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteWirelessDevice, request, handler, context);
  }
 
  virtual Model::DeleteWirelessDeviceImportTaskOutcome DeleteWirelessDeviceImportTask(
      const Model::DeleteWirelessDeviceImportTaskRequest& request) const;
 
  template <typename DeleteWirelessDeviceImportTaskRequestT = Model::DeleteWirelessDeviceImportTaskRequest>
  Model::DeleteWirelessDeviceImportTaskOutcomeCallable DeleteWirelessDeviceImportTaskCallable(
      const DeleteWirelessDeviceImportTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteWirelessDeviceImportTask, request);
  }
 
  template <typename DeleteWirelessDeviceImportTaskRequestT = Model::DeleteWirelessDeviceImportTaskRequest>
  void DeleteWirelessDeviceImportTaskAsync(const DeleteWirelessDeviceImportTaskRequestT& request,
                                           const DeleteWirelessDeviceImportTaskResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteWirelessDeviceImportTask, request, handler, context);
  }
 
  virtual Model::DeleteWirelessGatewayOutcome DeleteWirelessGateway(const Model::DeleteWirelessGatewayRequest& request) const;
 
  template <typename DeleteWirelessGatewayRequestT = Model::DeleteWirelessGatewayRequest>
  Model::DeleteWirelessGatewayOutcomeCallable DeleteWirelessGatewayCallable(const DeleteWirelessGatewayRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteWirelessGateway, request);
  }
 
  template <typename DeleteWirelessGatewayRequestT = Model::DeleteWirelessGatewayRequest>
  void DeleteWirelessGatewayAsync(const DeleteWirelessGatewayRequestT& request, const DeleteWirelessGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteWirelessGateway, request, handler, context);
  }
 
  virtual Model::DeleteWirelessGatewayTaskOutcome DeleteWirelessGatewayTask(const Model::DeleteWirelessGatewayTaskRequest& request) const;
 
  template <typename DeleteWirelessGatewayTaskRequestT = Model::DeleteWirelessGatewayTaskRequest>
  Model::DeleteWirelessGatewayTaskOutcomeCallable DeleteWirelessGatewayTaskCallable(
      const DeleteWirelessGatewayTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteWirelessGatewayTask, request);
  }
 
  template <typename DeleteWirelessGatewayTaskRequestT = Model::DeleteWirelessGatewayTaskRequest>
  void DeleteWirelessGatewayTaskAsync(const DeleteWirelessGatewayTaskRequestT& request,
                                      const DeleteWirelessGatewayTaskResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteWirelessGatewayTask, request, handler, context);
  }
 
  virtual Model::DeleteWirelessGatewayTaskDefinitionOutcome DeleteWirelessGatewayTaskDefinition(
      const Model::DeleteWirelessGatewayTaskDefinitionRequest& request) const;
 
  template <typename DeleteWirelessGatewayTaskDefinitionRequestT = Model::DeleteWirelessGatewayTaskDefinitionRequest>
  Model::DeleteWirelessGatewayTaskDefinitionOutcomeCallable DeleteWirelessGatewayTaskDefinitionCallable(
      const DeleteWirelessGatewayTaskDefinitionRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeleteWirelessGatewayTaskDefinition, request);
  }
 
  template <typename DeleteWirelessGatewayTaskDefinitionRequestT = Model::DeleteWirelessGatewayTaskDefinitionRequest>
  void DeleteWirelessGatewayTaskDefinitionAsync(const DeleteWirelessGatewayTaskDefinitionRequestT& request,
                                                const DeleteWirelessGatewayTaskDefinitionResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeleteWirelessGatewayTaskDefinition, request, handler, context);
  }
 
  virtual Model::DeregisterWirelessDeviceOutcome DeregisterWirelessDevice(const Model::DeregisterWirelessDeviceRequest& request) const;
 
  template <typename DeregisterWirelessDeviceRequestT = Model::DeregisterWirelessDeviceRequest>
  Model::DeregisterWirelessDeviceOutcomeCallable DeregisterWirelessDeviceCallable(const DeregisterWirelessDeviceRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DeregisterWirelessDevice, request);
  }
 
  template <typename DeregisterWirelessDeviceRequestT = Model::DeregisterWirelessDeviceRequest>
  void DeregisterWirelessDeviceAsync(const DeregisterWirelessDeviceRequestT& request,
                                     const DeregisterWirelessDeviceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DeregisterWirelessDevice, request, handler, context);
  }
 
  virtual Model::DisassociateAwsAccountFromPartnerAccountOutcome DisassociateAwsAccountFromPartnerAccount(
      const Model::DisassociateAwsAccountFromPartnerAccountRequest& request) const;
 
  template <typename DisassociateAwsAccountFromPartnerAccountRequestT = Model::DisassociateAwsAccountFromPartnerAccountRequest>
  Model::DisassociateAwsAccountFromPartnerAccountOutcomeCallable DisassociateAwsAccountFromPartnerAccountCallable(
      const DisassociateAwsAccountFromPartnerAccountRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DisassociateAwsAccountFromPartnerAccount, request);
  }
 
  template <typename DisassociateAwsAccountFromPartnerAccountRequestT = Model::DisassociateAwsAccountFromPartnerAccountRequest>
  void DisassociateAwsAccountFromPartnerAccountAsync(
      const DisassociateAwsAccountFromPartnerAccountRequestT& request,
      const DisassociateAwsAccountFromPartnerAccountResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DisassociateAwsAccountFromPartnerAccount, request, handler, context);
  }
 
  virtual Model::DisassociateMulticastGroupFromFuotaTaskOutcome DisassociateMulticastGroupFromFuotaTask(
      const Model::DisassociateMulticastGroupFromFuotaTaskRequest& request) const;
 
  template <typename DisassociateMulticastGroupFromFuotaTaskRequestT = Model::DisassociateMulticastGroupFromFuotaTaskRequest>
  Model::DisassociateMulticastGroupFromFuotaTaskOutcomeCallable DisassociateMulticastGroupFromFuotaTaskCallable(
      const DisassociateMulticastGroupFromFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DisassociateMulticastGroupFromFuotaTask, request);
  }
 
  template <typename DisassociateMulticastGroupFromFuotaTaskRequestT = Model::DisassociateMulticastGroupFromFuotaTaskRequest>
  void DisassociateMulticastGroupFromFuotaTaskAsync(const DisassociateMulticastGroupFromFuotaTaskRequestT& request,
                                                    const DisassociateMulticastGroupFromFuotaTaskResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DisassociateMulticastGroupFromFuotaTask, request, handler, context);
  }
 
  virtual Model::DisassociateWirelessDeviceFromFuotaTaskOutcome DisassociateWirelessDeviceFromFuotaTask(
      const Model::DisassociateWirelessDeviceFromFuotaTaskRequest& request) const;
 
  template <typename DisassociateWirelessDeviceFromFuotaTaskRequestT = Model::DisassociateWirelessDeviceFromFuotaTaskRequest>
  Model::DisassociateWirelessDeviceFromFuotaTaskOutcomeCallable DisassociateWirelessDeviceFromFuotaTaskCallable(
      const DisassociateWirelessDeviceFromFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DisassociateWirelessDeviceFromFuotaTask, request);
  }
 
  template <typename DisassociateWirelessDeviceFromFuotaTaskRequestT = Model::DisassociateWirelessDeviceFromFuotaTaskRequest>
  void DisassociateWirelessDeviceFromFuotaTaskAsync(const DisassociateWirelessDeviceFromFuotaTaskRequestT& request,
                                                    const DisassociateWirelessDeviceFromFuotaTaskResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DisassociateWirelessDeviceFromFuotaTask, request, handler, context);
  }
 
  virtual Model::DisassociateWirelessDeviceFromMulticastGroupOutcome DisassociateWirelessDeviceFromMulticastGroup(
      const Model::DisassociateWirelessDeviceFromMulticastGroupRequest& request) const;
 
  template <typename DisassociateWirelessDeviceFromMulticastGroupRequestT = Model::DisassociateWirelessDeviceFromMulticastGroupRequest>
  Model::DisassociateWirelessDeviceFromMulticastGroupOutcomeCallable DisassociateWirelessDeviceFromMulticastGroupCallable(
      const DisassociateWirelessDeviceFromMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DisassociateWirelessDeviceFromMulticastGroup, request);
  }
 
  template <typename DisassociateWirelessDeviceFromMulticastGroupRequestT = Model::DisassociateWirelessDeviceFromMulticastGroupRequest>
  void DisassociateWirelessDeviceFromMulticastGroupAsync(
      const DisassociateWirelessDeviceFromMulticastGroupRequestT& request,
      const DisassociateWirelessDeviceFromMulticastGroupResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DisassociateWirelessDeviceFromMulticastGroup, request, handler, context);
  }
 
  virtual Model::DisassociateWirelessDeviceFromThingOutcome DisassociateWirelessDeviceFromThing(
      const Model::DisassociateWirelessDeviceFromThingRequest& request) const;
 
  template <typename DisassociateWirelessDeviceFromThingRequestT = Model::DisassociateWirelessDeviceFromThingRequest>
  Model::DisassociateWirelessDeviceFromThingOutcomeCallable DisassociateWirelessDeviceFromThingCallable(
      const DisassociateWirelessDeviceFromThingRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DisassociateWirelessDeviceFromThing, request);
  }
 
  template <typename DisassociateWirelessDeviceFromThingRequestT = Model::DisassociateWirelessDeviceFromThingRequest>
  void DisassociateWirelessDeviceFromThingAsync(const DisassociateWirelessDeviceFromThingRequestT& request,
                                                const DisassociateWirelessDeviceFromThingResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DisassociateWirelessDeviceFromThing, request, handler, context);
  }
 
  virtual Model::DisassociateWirelessGatewayFromCertificateOutcome DisassociateWirelessGatewayFromCertificate(
      const Model::DisassociateWirelessGatewayFromCertificateRequest& request) const;
 
  template <typename DisassociateWirelessGatewayFromCertificateRequestT = Model::DisassociateWirelessGatewayFromCertificateRequest>
  Model::DisassociateWirelessGatewayFromCertificateOutcomeCallable DisassociateWirelessGatewayFromCertificateCallable(
      const DisassociateWirelessGatewayFromCertificateRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DisassociateWirelessGatewayFromCertificate, request);
  }
 
  template <typename DisassociateWirelessGatewayFromCertificateRequestT = Model::DisassociateWirelessGatewayFromCertificateRequest>
  void DisassociateWirelessGatewayFromCertificateAsync(
      const DisassociateWirelessGatewayFromCertificateRequestT& request,
      const DisassociateWirelessGatewayFromCertificateResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DisassociateWirelessGatewayFromCertificate, request, handler, context);
  }
 
  virtual Model::DisassociateWirelessGatewayFromThingOutcome DisassociateWirelessGatewayFromThing(
      const Model::DisassociateWirelessGatewayFromThingRequest& request) const;
 
  template <typename DisassociateWirelessGatewayFromThingRequestT = Model::DisassociateWirelessGatewayFromThingRequest>
  Model::DisassociateWirelessGatewayFromThingOutcomeCallable DisassociateWirelessGatewayFromThingCallable(
      const DisassociateWirelessGatewayFromThingRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::DisassociateWirelessGatewayFromThing, request);
  }
 
  template <typename DisassociateWirelessGatewayFromThingRequestT = Model::DisassociateWirelessGatewayFromThingRequest>
  void DisassociateWirelessGatewayFromThingAsync(const DisassociateWirelessGatewayFromThingRequestT& request,
                                                 const DisassociateWirelessGatewayFromThingResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::DisassociateWirelessGatewayFromThing, request, handler, context);
  }
 
  virtual Model::GetDestinationOutcome GetDestination(const Model::GetDestinationRequest& request) const;
 
  template <typename GetDestinationRequestT = Model::GetDestinationRequest>
  Model::GetDestinationOutcomeCallable GetDestinationCallable(const GetDestinationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetDestination, request);
  }
 
  template <typename GetDestinationRequestT = Model::GetDestinationRequest>
  void GetDestinationAsync(const GetDestinationRequestT& request, const GetDestinationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetDestination, request, handler, context);
  }
 
  virtual Model::GetDeviceProfileOutcome GetDeviceProfile(const Model::GetDeviceProfileRequest& request) const;
 
  template <typename GetDeviceProfileRequestT = Model::GetDeviceProfileRequest>
  Model::GetDeviceProfileOutcomeCallable GetDeviceProfileCallable(const GetDeviceProfileRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetDeviceProfile, request);
  }
 
  template <typename GetDeviceProfileRequestT = Model::GetDeviceProfileRequest>
  void GetDeviceProfileAsync(const GetDeviceProfileRequestT& request, const GetDeviceProfileResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetDeviceProfile, request, handler, context);
  }
 
  virtual Model::GetEventConfigurationByResourceTypesOutcome GetEventConfigurationByResourceTypes(
      const Model::GetEventConfigurationByResourceTypesRequest& request = {}) const;
 
  template <typename GetEventConfigurationByResourceTypesRequestT = Model::GetEventConfigurationByResourceTypesRequest>
  Model::GetEventConfigurationByResourceTypesOutcomeCallable GetEventConfigurationByResourceTypesCallable(
      const GetEventConfigurationByResourceTypesRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::GetEventConfigurationByResourceTypes, request);
  }
 
  template <typename GetEventConfigurationByResourceTypesRequestT = Model::GetEventConfigurationByResourceTypesRequest>
  void GetEventConfigurationByResourceTypesAsync(const GetEventConfigurationByResourceTypesResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const GetEventConfigurationByResourceTypesRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::GetEventConfigurationByResourceTypes, request, handler, context);
  }
 
  virtual Model::GetFuotaTaskOutcome GetFuotaTask(const Model::GetFuotaTaskRequest& request) const;
 
  template <typename GetFuotaTaskRequestT = Model::GetFuotaTaskRequest>
  Model::GetFuotaTaskOutcomeCallable GetFuotaTaskCallable(const GetFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetFuotaTask, request);
  }
 
  template <typename GetFuotaTaskRequestT = Model::GetFuotaTaskRequest>
  void GetFuotaTaskAsync(const GetFuotaTaskRequestT& request, const GetFuotaTaskResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetFuotaTask, request, handler, context);
  }
 
  virtual Model::GetLogLevelsByResourceTypesOutcome GetLogLevelsByResourceTypes(
      const Model::GetLogLevelsByResourceTypesRequest& request = {}) const;
 
  template <typename GetLogLevelsByResourceTypesRequestT = Model::GetLogLevelsByResourceTypesRequest>
  Model::GetLogLevelsByResourceTypesOutcomeCallable GetLogLevelsByResourceTypesCallable(
      const GetLogLevelsByResourceTypesRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::GetLogLevelsByResourceTypes, request);
  }
 
  template <typename GetLogLevelsByResourceTypesRequestT = Model::GetLogLevelsByResourceTypesRequest>
  void GetLogLevelsByResourceTypesAsync(const GetLogLevelsByResourceTypesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const GetLogLevelsByResourceTypesRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::GetLogLevelsByResourceTypes, request, handler, context);
  }
 
  virtual Model::GetMetricConfigurationOutcome GetMetricConfiguration(const Model::GetMetricConfigurationRequest& request = {}) const;
 
  template <typename GetMetricConfigurationRequestT = Model::GetMetricConfigurationRequest>
  Model::GetMetricConfigurationOutcomeCallable GetMetricConfigurationCallable(const GetMetricConfigurationRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::GetMetricConfiguration, request);
  }
 
  template <typename GetMetricConfigurationRequestT = Model::GetMetricConfigurationRequest>
  void GetMetricConfigurationAsync(const GetMetricConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const GetMetricConfigurationRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::GetMetricConfiguration, request, handler, context);
  }
 
  virtual Model::GetMetricsOutcome GetMetrics(const Model::GetMetricsRequest& request = {}) const;
 
  template <typename GetMetricsRequestT = Model::GetMetricsRequest>
  Model::GetMetricsOutcomeCallable GetMetricsCallable(const GetMetricsRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::GetMetrics, request);
  }
 
  template <typename GetMetricsRequestT = Model::GetMetricsRequest>
  void GetMetricsAsync(const GetMetricsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const GetMetricsRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::GetMetrics, request, handler, context);
  }
 
  virtual Model::GetMulticastGroupOutcome GetMulticastGroup(const Model::GetMulticastGroupRequest& request) const;
 
  template <typename GetMulticastGroupRequestT = Model::GetMulticastGroupRequest>
  Model::GetMulticastGroupOutcomeCallable GetMulticastGroupCallable(const GetMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetMulticastGroup, request);
  }
 
  template <typename GetMulticastGroupRequestT = Model::GetMulticastGroupRequest>
  void GetMulticastGroupAsync(const GetMulticastGroupRequestT& request, const GetMulticastGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetMulticastGroup, request, handler, context);
  }
 
  virtual Model::GetMulticastGroupSessionOutcome GetMulticastGroupSession(const Model::GetMulticastGroupSessionRequest& request) const;
 
  template <typename GetMulticastGroupSessionRequestT = Model::GetMulticastGroupSessionRequest>
  Model::GetMulticastGroupSessionOutcomeCallable GetMulticastGroupSessionCallable(const GetMulticastGroupSessionRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetMulticastGroupSession, request);
  }
 
  template <typename GetMulticastGroupSessionRequestT = Model::GetMulticastGroupSessionRequest>
  void GetMulticastGroupSessionAsync(const GetMulticastGroupSessionRequestT& request,
                                     const GetMulticastGroupSessionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetMulticastGroupSession, request, handler, context);
  }
 
  virtual Model::GetNetworkAnalyzerConfigurationOutcome GetNetworkAnalyzerConfiguration(
      const Model::GetNetworkAnalyzerConfigurationRequest& request) const;
 
  template <typename GetNetworkAnalyzerConfigurationRequestT = Model::GetNetworkAnalyzerConfigurationRequest>
  Model::GetNetworkAnalyzerConfigurationOutcomeCallable GetNetworkAnalyzerConfigurationCallable(
      const GetNetworkAnalyzerConfigurationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetNetworkAnalyzerConfiguration, request);
  }
 
  template <typename GetNetworkAnalyzerConfigurationRequestT = Model::GetNetworkAnalyzerConfigurationRequest>
  void GetNetworkAnalyzerConfigurationAsync(const GetNetworkAnalyzerConfigurationRequestT& request,
                                            const GetNetworkAnalyzerConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetNetworkAnalyzerConfiguration, request, handler, context);
  }
 
  virtual Model::GetPartnerAccountOutcome GetPartnerAccount(const Model::GetPartnerAccountRequest& request) const;
 
  template <typename GetPartnerAccountRequestT = Model::GetPartnerAccountRequest>
  Model::GetPartnerAccountOutcomeCallable GetPartnerAccountCallable(const GetPartnerAccountRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetPartnerAccount, request);
  }
 
  template <typename GetPartnerAccountRequestT = Model::GetPartnerAccountRequest>
  void GetPartnerAccountAsync(const GetPartnerAccountRequestT& request, const GetPartnerAccountResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetPartnerAccount, request, handler, context);
  }
 
  virtual Model::GetPositionEstimateOutcome GetPositionEstimate(const Model::GetPositionEstimateRequest& request = {}) const;
 
  template <typename GetPositionEstimateRequestT = Model::GetPositionEstimateRequest>
  Model::GetPositionEstimateOutcomeCallable GetPositionEstimateCallable(const GetPositionEstimateRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::GetPositionEstimate, request);
  }
 
  template <typename GetPositionEstimateRequestT = Model::GetPositionEstimateRequest>
  void GetPositionEstimateAsync(const GetPositionEstimateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const GetPositionEstimateRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::GetPositionEstimate, request, handler, context);
  }
 
  virtual Model::GetResourceEventConfigurationOutcome GetResourceEventConfiguration(
      const Model::GetResourceEventConfigurationRequest& request) const;
 
  template <typename GetResourceEventConfigurationRequestT = Model::GetResourceEventConfigurationRequest>
  Model::GetResourceEventConfigurationOutcomeCallable GetResourceEventConfigurationCallable(
      const GetResourceEventConfigurationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetResourceEventConfiguration, request);
  }
 
  template <typename GetResourceEventConfigurationRequestT = Model::GetResourceEventConfigurationRequest>
  void GetResourceEventConfigurationAsync(const GetResourceEventConfigurationRequestT& request,
                                          const GetResourceEventConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetResourceEventConfiguration, request, handler, context);
  }
 
  virtual Model::GetResourceLogLevelOutcome GetResourceLogLevel(const Model::GetResourceLogLevelRequest& request) const;
 
  template <typename GetResourceLogLevelRequestT = Model::GetResourceLogLevelRequest>
  Model::GetResourceLogLevelOutcomeCallable GetResourceLogLevelCallable(const GetResourceLogLevelRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetResourceLogLevel, request);
  }
 
  template <typename GetResourceLogLevelRequestT = Model::GetResourceLogLevelRequest>
  void GetResourceLogLevelAsync(const GetResourceLogLevelRequestT& request, const GetResourceLogLevelResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetResourceLogLevel, request, handler, context);
  }
 
  virtual Model::GetResourcePositionOutcome GetResourcePosition(const Model::GetResourcePositionRequest& request) const;
 
  template <typename GetResourcePositionRequestT = Model::GetResourcePositionRequest>
  Model::GetResourcePositionOutcomeCallable GetResourcePositionCallable(const GetResourcePositionRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetResourcePosition, request);
  }
 
  template <typename GetResourcePositionRequestT = Model::GetResourcePositionRequest>
  void GetResourcePositionAsync(const GetResourcePositionRequestT& request, const GetResourcePositionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetResourcePosition, request, handler, context);
  }
 
  virtual Model::GetServiceEndpointOutcome GetServiceEndpoint(const Model::GetServiceEndpointRequest& request = {}) const;
 
  template <typename GetServiceEndpointRequestT = Model::GetServiceEndpointRequest>
  Model::GetServiceEndpointOutcomeCallable GetServiceEndpointCallable(const GetServiceEndpointRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::GetServiceEndpoint, request);
  }
 
  template <typename GetServiceEndpointRequestT = Model::GetServiceEndpointRequest>
  void GetServiceEndpointAsync(const GetServiceEndpointResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetServiceEndpointRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::GetServiceEndpoint, request, handler, context);
  }
 
  virtual Model::GetServiceProfileOutcome GetServiceProfile(const Model::GetServiceProfileRequest& request) const;
 
  template <typename GetServiceProfileRequestT = Model::GetServiceProfileRequest>
  Model::GetServiceProfileOutcomeCallable GetServiceProfileCallable(const GetServiceProfileRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetServiceProfile, request);
  }
 
  template <typename GetServiceProfileRequestT = Model::GetServiceProfileRequest>
  void GetServiceProfileAsync(const GetServiceProfileRequestT& request, const GetServiceProfileResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetServiceProfile, request, handler, context);
  }
 
  virtual Model::GetWirelessDeviceOutcome GetWirelessDevice(const Model::GetWirelessDeviceRequest& request) const;
 
  template <typename GetWirelessDeviceRequestT = Model::GetWirelessDeviceRequest>
  Model::GetWirelessDeviceOutcomeCallable GetWirelessDeviceCallable(const GetWirelessDeviceRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessDevice, request);
  }
 
  template <typename GetWirelessDeviceRequestT = Model::GetWirelessDeviceRequest>
  void GetWirelessDeviceAsync(const GetWirelessDeviceRequestT& request, const GetWirelessDeviceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessDevice, request, handler, context);
  }
 
  virtual Model::GetWirelessDeviceImportTaskOutcome GetWirelessDeviceImportTask(
      const Model::GetWirelessDeviceImportTaskRequest& request) const;
 
  template <typename GetWirelessDeviceImportTaskRequestT = Model::GetWirelessDeviceImportTaskRequest>
  Model::GetWirelessDeviceImportTaskOutcomeCallable GetWirelessDeviceImportTaskCallable(
      const GetWirelessDeviceImportTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessDeviceImportTask, request);
  }
 
  template <typename GetWirelessDeviceImportTaskRequestT = Model::GetWirelessDeviceImportTaskRequest>
  void GetWirelessDeviceImportTaskAsync(const GetWirelessDeviceImportTaskRequestT& request,
                                        const GetWirelessDeviceImportTaskResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessDeviceImportTask, request, handler, context);
  }
 
  virtual Model::GetWirelessDeviceStatisticsOutcome GetWirelessDeviceStatistics(
      const Model::GetWirelessDeviceStatisticsRequest& request) const;
 
  template <typename GetWirelessDeviceStatisticsRequestT = Model::GetWirelessDeviceStatisticsRequest>
  Model::GetWirelessDeviceStatisticsOutcomeCallable GetWirelessDeviceStatisticsCallable(
      const GetWirelessDeviceStatisticsRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessDeviceStatistics, request);
  }
 
  template <typename GetWirelessDeviceStatisticsRequestT = Model::GetWirelessDeviceStatisticsRequest>
  void GetWirelessDeviceStatisticsAsync(const GetWirelessDeviceStatisticsRequestT& request,
                                        const GetWirelessDeviceStatisticsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessDeviceStatistics, request, handler, context);
  }
 
  virtual Model::GetWirelessGatewayOutcome GetWirelessGateway(const Model::GetWirelessGatewayRequest& request) const;
 
  template <typename GetWirelessGatewayRequestT = Model::GetWirelessGatewayRequest>
  Model::GetWirelessGatewayOutcomeCallable GetWirelessGatewayCallable(const GetWirelessGatewayRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessGateway, request);
  }
 
  template <typename GetWirelessGatewayRequestT = Model::GetWirelessGatewayRequest>
  void GetWirelessGatewayAsync(const GetWirelessGatewayRequestT& request, const GetWirelessGatewayResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessGateway, request, handler, context);
  }
 
  virtual Model::GetWirelessGatewayCertificateOutcome GetWirelessGatewayCertificate(
      const Model::GetWirelessGatewayCertificateRequest& request) const;
 
  template <typename GetWirelessGatewayCertificateRequestT = Model::GetWirelessGatewayCertificateRequest>
  Model::GetWirelessGatewayCertificateOutcomeCallable GetWirelessGatewayCertificateCallable(
      const GetWirelessGatewayCertificateRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayCertificate, request);
  }
 
  template <typename GetWirelessGatewayCertificateRequestT = Model::GetWirelessGatewayCertificateRequest>
  void GetWirelessGatewayCertificateAsync(const GetWirelessGatewayCertificateRequestT& request,
                                          const GetWirelessGatewayCertificateResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayCertificate, request, handler, context);
  }
 
  virtual Model::GetWirelessGatewayFirmwareInformationOutcome GetWirelessGatewayFirmwareInformation(
      const Model::GetWirelessGatewayFirmwareInformationRequest& request) const;
 
  template <typename GetWirelessGatewayFirmwareInformationRequestT = Model::GetWirelessGatewayFirmwareInformationRequest>
  Model::GetWirelessGatewayFirmwareInformationOutcomeCallable GetWirelessGatewayFirmwareInformationCallable(
      const GetWirelessGatewayFirmwareInformationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayFirmwareInformation, request);
  }
 
  template <typename GetWirelessGatewayFirmwareInformationRequestT = Model::GetWirelessGatewayFirmwareInformationRequest>
  void GetWirelessGatewayFirmwareInformationAsync(const GetWirelessGatewayFirmwareInformationRequestT& request,
                                                  const GetWirelessGatewayFirmwareInformationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayFirmwareInformation, request, handler, context);
  }
 
  virtual Model::GetWirelessGatewayStatisticsOutcome GetWirelessGatewayStatistics(
      const Model::GetWirelessGatewayStatisticsRequest& request) const;
 
  template <typename GetWirelessGatewayStatisticsRequestT = Model::GetWirelessGatewayStatisticsRequest>
  Model::GetWirelessGatewayStatisticsOutcomeCallable GetWirelessGatewayStatisticsCallable(
      const GetWirelessGatewayStatisticsRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayStatistics, request);
  }
 
  template <typename GetWirelessGatewayStatisticsRequestT = Model::GetWirelessGatewayStatisticsRequest>
  void GetWirelessGatewayStatisticsAsync(const GetWirelessGatewayStatisticsRequestT& request,
                                         const GetWirelessGatewayStatisticsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayStatistics, request, handler, context);
  }
 
  virtual Model::GetWirelessGatewayTaskOutcome GetWirelessGatewayTask(const Model::GetWirelessGatewayTaskRequest& request) const;
 
  template <typename GetWirelessGatewayTaskRequestT = Model::GetWirelessGatewayTaskRequest>
  Model::GetWirelessGatewayTaskOutcomeCallable GetWirelessGatewayTaskCallable(const GetWirelessGatewayTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayTask, request);
  }
 
  template <typename GetWirelessGatewayTaskRequestT = Model::GetWirelessGatewayTaskRequest>
  void GetWirelessGatewayTaskAsync(const GetWirelessGatewayTaskRequestT& request,
                                   const GetWirelessGatewayTaskResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayTask, request, handler, context);
  }
 
  virtual Model::GetWirelessGatewayTaskDefinitionOutcome GetWirelessGatewayTaskDefinition(
      const Model::GetWirelessGatewayTaskDefinitionRequest& request) const;
 
  template <typename GetWirelessGatewayTaskDefinitionRequestT = Model::GetWirelessGatewayTaskDefinitionRequest>
  Model::GetWirelessGatewayTaskDefinitionOutcomeCallable GetWirelessGatewayTaskDefinitionCallable(
      const GetWirelessGatewayTaskDefinitionRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::GetWirelessGatewayTaskDefinition, request);
  }
 
  template <typename GetWirelessGatewayTaskDefinitionRequestT = Model::GetWirelessGatewayTaskDefinitionRequest>
  void GetWirelessGatewayTaskDefinitionAsync(const GetWirelessGatewayTaskDefinitionRequestT& request,
                                             const GetWirelessGatewayTaskDefinitionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::GetWirelessGatewayTaskDefinition, request, handler, context);
  }
 
  virtual Model::ListDestinationsOutcome ListDestinations(const Model::ListDestinationsRequest& request = {}) const;
 
  template <typename ListDestinationsRequestT = Model::ListDestinationsRequest>
  Model::ListDestinationsOutcomeCallable ListDestinationsCallable(const ListDestinationsRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListDestinations, request);
  }
 
  template <typename ListDestinationsRequestT = Model::ListDestinationsRequest>
  void ListDestinationsAsync(const ListDestinationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListDestinationsRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListDestinations, request, handler, context);
  }
 
  virtual Model::ListDeviceProfilesOutcome ListDeviceProfiles(const Model::ListDeviceProfilesRequest& request = {}) const;
 
  template <typename ListDeviceProfilesRequestT = Model::ListDeviceProfilesRequest>
  Model::ListDeviceProfilesOutcomeCallable ListDeviceProfilesCallable(const ListDeviceProfilesRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListDeviceProfiles, request);
  }
 
  template <typename ListDeviceProfilesRequestT = Model::ListDeviceProfilesRequest>
  void ListDeviceProfilesAsync(const ListDeviceProfilesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListDeviceProfilesRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListDeviceProfiles, request, handler, context);
  }
 
  virtual Model::ListDevicesForWirelessDeviceImportTaskOutcome ListDevicesForWirelessDeviceImportTask(
      const Model::ListDevicesForWirelessDeviceImportTaskRequest& request) const;
 
  template <typename ListDevicesForWirelessDeviceImportTaskRequestT = Model::ListDevicesForWirelessDeviceImportTaskRequest>
  Model::ListDevicesForWirelessDeviceImportTaskOutcomeCallable ListDevicesForWirelessDeviceImportTaskCallable(
      const ListDevicesForWirelessDeviceImportTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::ListDevicesForWirelessDeviceImportTask, request);
  }
 
  template <typename ListDevicesForWirelessDeviceImportTaskRequestT = Model::ListDevicesForWirelessDeviceImportTaskRequest>
  void ListDevicesForWirelessDeviceImportTaskAsync(const ListDevicesForWirelessDeviceImportTaskRequestT& request,
                                                   const ListDevicesForWirelessDeviceImportTaskResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::ListDevicesForWirelessDeviceImportTask, request, handler, context);
  }
 
  virtual Model::ListEventConfigurationsOutcome ListEventConfigurations(const Model::ListEventConfigurationsRequest& request) const;
 
  template <typename ListEventConfigurationsRequestT = Model::ListEventConfigurationsRequest>
  Model::ListEventConfigurationsOutcomeCallable ListEventConfigurationsCallable(const ListEventConfigurationsRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::ListEventConfigurations, request);
  }
 
  template <typename ListEventConfigurationsRequestT = Model::ListEventConfigurationsRequest>
  void ListEventConfigurationsAsync(const ListEventConfigurationsRequestT& request,
                                    const ListEventConfigurationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::ListEventConfigurations, request, handler, context);
  }
 
  virtual Model::ListFuotaTasksOutcome ListFuotaTasks(const Model::ListFuotaTasksRequest& request = {}) const;
 
  template <typename ListFuotaTasksRequestT = Model::ListFuotaTasksRequest>
  Model::ListFuotaTasksOutcomeCallable ListFuotaTasksCallable(const ListFuotaTasksRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListFuotaTasks, request);
  }
 
  template <typename ListFuotaTasksRequestT = Model::ListFuotaTasksRequest>
  void ListFuotaTasksAsync(const ListFuotaTasksResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListFuotaTasksRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListFuotaTasks, request, handler, context);
  }
 
  virtual Model::ListMulticastGroupsOutcome ListMulticastGroups(const Model::ListMulticastGroupsRequest& request = {}) const;
 
  template <typename ListMulticastGroupsRequestT = Model::ListMulticastGroupsRequest>
  Model::ListMulticastGroupsOutcomeCallable ListMulticastGroupsCallable(const ListMulticastGroupsRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListMulticastGroups, request);
  }
 
  template <typename ListMulticastGroupsRequestT = Model::ListMulticastGroupsRequest>
  void ListMulticastGroupsAsync(const ListMulticastGroupsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListMulticastGroupsRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListMulticastGroups, request, handler, context);
  }
 
  virtual Model::ListMulticastGroupsByFuotaTaskOutcome ListMulticastGroupsByFuotaTask(
      const Model::ListMulticastGroupsByFuotaTaskRequest& request) const;
 
  template <typename ListMulticastGroupsByFuotaTaskRequestT = Model::ListMulticastGroupsByFuotaTaskRequest>
  Model::ListMulticastGroupsByFuotaTaskOutcomeCallable ListMulticastGroupsByFuotaTaskCallable(
      const ListMulticastGroupsByFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::ListMulticastGroupsByFuotaTask, request);
  }
 
  template <typename ListMulticastGroupsByFuotaTaskRequestT = Model::ListMulticastGroupsByFuotaTaskRequest>
  void ListMulticastGroupsByFuotaTaskAsync(const ListMulticastGroupsByFuotaTaskRequestT& request,
                                           const ListMulticastGroupsByFuotaTaskResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::ListMulticastGroupsByFuotaTask, request, handler, context);
  }
 
  virtual Model::ListNetworkAnalyzerConfigurationsOutcome ListNetworkAnalyzerConfigurations(
      const Model::ListNetworkAnalyzerConfigurationsRequest& request = {}) const;
 
  template <typename ListNetworkAnalyzerConfigurationsRequestT = Model::ListNetworkAnalyzerConfigurationsRequest>
  Model::ListNetworkAnalyzerConfigurationsOutcomeCallable ListNetworkAnalyzerConfigurationsCallable(
      const ListNetworkAnalyzerConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListNetworkAnalyzerConfigurations, request);
  }
 
  template <typename ListNetworkAnalyzerConfigurationsRequestT = Model::ListNetworkAnalyzerConfigurationsRequest>
  void ListNetworkAnalyzerConfigurationsAsync(const ListNetworkAnalyzerConfigurationsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const ListNetworkAnalyzerConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListNetworkAnalyzerConfigurations, request, handler, context);
  }
 
  virtual Model::ListPartnerAccountsOutcome ListPartnerAccounts(const Model::ListPartnerAccountsRequest& request = {}) const;
 
  template <typename ListPartnerAccountsRequestT = Model::ListPartnerAccountsRequest>
  Model::ListPartnerAccountsOutcomeCallable ListPartnerAccountsCallable(const ListPartnerAccountsRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListPartnerAccounts, request);
  }
 
  template <typename ListPartnerAccountsRequestT = Model::ListPartnerAccountsRequest>
  void ListPartnerAccountsAsync(const ListPartnerAccountsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListPartnerAccountsRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListPartnerAccounts, request, handler, context);
  }
 
  virtual Model::ListQueuedMessagesOutcome ListQueuedMessages(const Model::ListQueuedMessagesRequest& request) const;
 
  template <typename ListQueuedMessagesRequestT = Model::ListQueuedMessagesRequest>
  Model::ListQueuedMessagesOutcomeCallable ListQueuedMessagesCallable(const ListQueuedMessagesRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::ListQueuedMessages, request);
  }
 
  template <typename ListQueuedMessagesRequestT = Model::ListQueuedMessagesRequest>
  void ListQueuedMessagesAsync(const ListQueuedMessagesRequestT& request, const ListQueuedMessagesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::ListQueuedMessages, request, handler, context);
  }
 
  virtual Model::ListServiceProfilesOutcome ListServiceProfiles(const Model::ListServiceProfilesRequest& request = {}) const;
 
  template <typename ListServiceProfilesRequestT = Model::ListServiceProfilesRequest>
  Model::ListServiceProfilesOutcomeCallable ListServiceProfilesCallable(const ListServiceProfilesRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListServiceProfiles, request);
  }
 
  template <typename ListServiceProfilesRequestT = Model::ListServiceProfilesRequest>
  void ListServiceProfilesAsync(const ListServiceProfilesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListServiceProfilesRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListServiceProfiles, 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(&IoTWirelessClient::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(&IoTWirelessClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWirelessDeviceImportTasksOutcome ListWirelessDeviceImportTasks(
      const Model::ListWirelessDeviceImportTasksRequest& request = {}) const;
 
  template <typename ListWirelessDeviceImportTasksRequestT = Model::ListWirelessDeviceImportTasksRequest>
  Model::ListWirelessDeviceImportTasksOutcomeCallable ListWirelessDeviceImportTasksCallable(
      const ListWirelessDeviceImportTasksRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListWirelessDeviceImportTasks, request);
  }
 
  template <typename ListWirelessDeviceImportTasksRequestT = Model::ListWirelessDeviceImportTasksRequest>
  void ListWirelessDeviceImportTasksAsync(const ListWirelessDeviceImportTasksResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const ListWirelessDeviceImportTasksRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListWirelessDeviceImportTasks, request, handler, context);
  }
 
  virtual Model::ListWirelessDevicesOutcome ListWirelessDevices(const Model::ListWirelessDevicesRequest& request = {}) const;
 
  template <typename ListWirelessDevicesRequestT = Model::ListWirelessDevicesRequest>
  Model::ListWirelessDevicesOutcomeCallable ListWirelessDevicesCallable(const ListWirelessDevicesRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListWirelessDevices, request);
  }
 
  template <typename ListWirelessDevicesRequestT = Model::ListWirelessDevicesRequest>
  void ListWirelessDevicesAsync(const ListWirelessDevicesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListWirelessDevicesRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListWirelessDevices, request, handler, context);
  }
 
  virtual Model::ListWirelessGatewayTaskDefinitionsOutcome ListWirelessGatewayTaskDefinitions(
      const Model::ListWirelessGatewayTaskDefinitionsRequest& request = {}) const;
 
  template <typename ListWirelessGatewayTaskDefinitionsRequestT = Model::ListWirelessGatewayTaskDefinitionsRequest>
  Model::ListWirelessGatewayTaskDefinitionsOutcomeCallable ListWirelessGatewayTaskDefinitionsCallable(
      const ListWirelessGatewayTaskDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListWirelessGatewayTaskDefinitions, request);
  }
 
  template <typename ListWirelessGatewayTaskDefinitionsRequestT = Model::ListWirelessGatewayTaskDefinitionsRequest>
  void ListWirelessGatewayTaskDefinitionsAsync(const ListWirelessGatewayTaskDefinitionsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const ListWirelessGatewayTaskDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListWirelessGatewayTaskDefinitions, request, handler, context);
  }
 
  virtual Model::ListWirelessGatewaysOutcome ListWirelessGateways(const Model::ListWirelessGatewaysRequest& request = {}) const;
 
  template <typename ListWirelessGatewaysRequestT = Model::ListWirelessGatewaysRequest>
  Model::ListWirelessGatewaysOutcomeCallable ListWirelessGatewaysCallable(const ListWirelessGatewaysRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ListWirelessGateways, request);
  }
 
  template <typename ListWirelessGatewaysRequestT = Model::ListWirelessGatewaysRequest>
  void ListWirelessGatewaysAsync(const ListWirelessGatewaysResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListWirelessGatewaysRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ListWirelessGateways, request, handler, context);
  }
 
  virtual Model::PutResourceLogLevelOutcome PutResourceLogLevel(const Model::PutResourceLogLevelRequest& request) const;
 
  template <typename PutResourceLogLevelRequestT = Model::PutResourceLogLevelRequest>
  Model::PutResourceLogLevelOutcomeCallable PutResourceLogLevelCallable(const PutResourceLogLevelRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::PutResourceLogLevel, request);
  }
 
  template <typename PutResourceLogLevelRequestT = Model::PutResourceLogLevelRequest>
  void PutResourceLogLevelAsync(const PutResourceLogLevelRequestT& request, const PutResourceLogLevelResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::PutResourceLogLevel, request, handler, context);
  }
 
  virtual Model::ResetAllResourceLogLevelsOutcome ResetAllResourceLogLevels(
      const Model::ResetAllResourceLogLevelsRequest& request = {}) const;
 
  template <typename ResetAllResourceLogLevelsRequestT = Model::ResetAllResourceLogLevelsRequest>
  Model::ResetAllResourceLogLevelsOutcomeCallable ResetAllResourceLogLevelsCallable(
      const ResetAllResourceLogLevelsRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::ResetAllResourceLogLevels, request);
  }
 
  template <typename ResetAllResourceLogLevelsRequestT = Model::ResetAllResourceLogLevelsRequest>
  void ResetAllResourceLogLevelsAsync(const ResetAllResourceLogLevelsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ResetAllResourceLogLevelsRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::ResetAllResourceLogLevels, request, handler, context);
  }
 
  virtual Model::ResetResourceLogLevelOutcome ResetResourceLogLevel(const Model::ResetResourceLogLevelRequest& request) const;
 
  template <typename ResetResourceLogLevelRequestT = Model::ResetResourceLogLevelRequest>
  Model::ResetResourceLogLevelOutcomeCallable ResetResourceLogLevelCallable(const ResetResourceLogLevelRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::ResetResourceLogLevel, request);
  }
 
  template <typename ResetResourceLogLevelRequestT = Model::ResetResourceLogLevelRequest>
  void ResetResourceLogLevelAsync(const ResetResourceLogLevelRequestT& request, const ResetResourceLogLevelResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::ResetResourceLogLevel, request, handler, context);
  }
 
  virtual Model::SendDataToMulticastGroupOutcome SendDataToMulticastGroup(const Model::SendDataToMulticastGroupRequest& request) const;
 
  template <typename SendDataToMulticastGroupRequestT = Model::SendDataToMulticastGroupRequest>
  Model::SendDataToMulticastGroupOutcomeCallable SendDataToMulticastGroupCallable(const SendDataToMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::SendDataToMulticastGroup, request);
  }
 
  template <typename SendDataToMulticastGroupRequestT = Model::SendDataToMulticastGroupRequest>
  void SendDataToMulticastGroupAsync(const SendDataToMulticastGroupRequestT& request,
                                     const SendDataToMulticastGroupResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::SendDataToMulticastGroup, request, handler, context);
  }
 
  virtual Model::SendDataToWirelessDeviceOutcome SendDataToWirelessDevice(const Model::SendDataToWirelessDeviceRequest& request) const;
 
  template <typename SendDataToWirelessDeviceRequestT = Model::SendDataToWirelessDeviceRequest>
  Model::SendDataToWirelessDeviceOutcomeCallable SendDataToWirelessDeviceCallable(const SendDataToWirelessDeviceRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::SendDataToWirelessDevice, request);
  }
 
  template <typename SendDataToWirelessDeviceRequestT = Model::SendDataToWirelessDeviceRequest>
  void SendDataToWirelessDeviceAsync(const SendDataToWirelessDeviceRequestT& request,
                                     const SendDataToWirelessDeviceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::SendDataToWirelessDevice, request, handler, context);
  }
 
  virtual Model::StartBulkAssociateWirelessDeviceWithMulticastGroupOutcome StartBulkAssociateWirelessDeviceWithMulticastGroup(
      const Model::StartBulkAssociateWirelessDeviceWithMulticastGroupRequest& request) const;
 
  template <typename StartBulkAssociateWirelessDeviceWithMulticastGroupRequestT =
                Model::StartBulkAssociateWirelessDeviceWithMulticastGroupRequest>
  Model::StartBulkAssociateWirelessDeviceWithMulticastGroupOutcomeCallable StartBulkAssociateWirelessDeviceWithMulticastGroupCallable(
      const StartBulkAssociateWirelessDeviceWithMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::StartBulkAssociateWirelessDeviceWithMulticastGroup, request);
  }
 
  template <typename StartBulkAssociateWirelessDeviceWithMulticastGroupRequestT =
                Model::StartBulkAssociateWirelessDeviceWithMulticastGroupRequest>
  void StartBulkAssociateWirelessDeviceWithMulticastGroupAsync(
      const StartBulkAssociateWirelessDeviceWithMulticastGroupRequestT& request,
      const StartBulkAssociateWirelessDeviceWithMulticastGroupResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::StartBulkAssociateWirelessDeviceWithMulticastGroup, request, handler, context);
  }
 
  virtual Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupOutcome StartBulkDisassociateWirelessDeviceFromMulticastGroup(
      const Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest& request) const;
 
  template <typename StartBulkDisassociateWirelessDeviceFromMulticastGroupRequestT =
                Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest>
  Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupOutcomeCallable StartBulkDisassociateWirelessDeviceFromMulticastGroupCallable(
      const StartBulkDisassociateWirelessDeviceFromMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::StartBulkDisassociateWirelessDeviceFromMulticastGroup, request);
  }
 
  template <typename StartBulkDisassociateWirelessDeviceFromMulticastGroupRequestT =
                Model::StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest>
  void StartBulkDisassociateWirelessDeviceFromMulticastGroupAsync(
      const StartBulkDisassociateWirelessDeviceFromMulticastGroupRequestT& request,
      const StartBulkDisassociateWirelessDeviceFromMulticastGroupResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::StartBulkDisassociateWirelessDeviceFromMulticastGroup, request, handler, context);
  }
 
  virtual Model::StartFuotaTaskOutcome StartFuotaTask(const Model::StartFuotaTaskRequest& request) const;
 
  template <typename StartFuotaTaskRequestT = Model::StartFuotaTaskRequest>
  Model::StartFuotaTaskOutcomeCallable StartFuotaTaskCallable(const StartFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::StartFuotaTask, request);
  }
 
  template <typename StartFuotaTaskRequestT = Model::StartFuotaTaskRequest>
  void StartFuotaTaskAsync(const StartFuotaTaskRequestT& request, const StartFuotaTaskResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::StartFuotaTask, request, handler, context);
  }
 
  virtual Model::StartMulticastGroupSessionOutcome StartMulticastGroupSession(
      const Model::StartMulticastGroupSessionRequest& request) const;
 
  template <typename StartMulticastGroupSessionRequestT = Model::StartMulticastGroupSessionRequest>
  Model::StartMulticastGroupSessionOutcomeCallable StartMulticastGroupSessionCallable(
      const StartMulticastGroupSessionRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::StartMulticastGroupSession, request);
  }
 
  template <typename StartMulticastGroupSessionRequestT = Model::StartMulticastGroupSessionRequest>
  void StartMulticastGroupSessionAsync(const StartMulticastGroupSessionRequestT& request,
                                       const StartMulticastGroupSessionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::StartMulticastGroupSession, request, handler, context);
  }
 
  virtual Model::StartSingleWirelessDeviceImportTaskOutcome StartSingleWirelessDeviceImportTask(
      const Model::StartSingleWirelessDeviceImportTaskRequest& request) const;
 
  template <typename StartSingleWirelessDeviceImportTaskRequestT = Model::StartSingleWirelessDeviceImportTaskRequest>
  Model::StartSingleWirelessDeviceImportTaskOutcomeCallable StartSingleWirelessDeviceImportTaskCallable(
      const StartSingleWirelessDeviceImportTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::StartSingleWirelessDeviceImportTask, request);
  }
 
  template <typename StartSingleWirelessDeviceImportTaskRequestT = Model::StartSingleWirelessDeviceImportTaskRequest>
  void StartSingleWirelessDeviceImportTaskAsync(const StartSingleWirelessDeviceImportTaskRequestT& request,
                                                const StartSingleWirelessDeviceImportTaskResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::StartSingleWirelessDeviceImportTask, request, handler, context);
  }
 
  virtual Model::StartWirelessDeviceImportTaskOutcome StartWirelessDeviceImportTask(
      const Model::StartWirelessDeviceImportTaskRequest& request) const;
 
  template <typename StartWirelessDeviceImportTaskRequestT = Model::StartWirelessDeviceImportTaskRequest>
  Model::StartWirelessDeviceImportTaskOutcomeCallable StartWirelessDeviceImportTaskCallable(
      const StartWirelessDeviceImportTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::StartWirelessDeviceImportTask, request);
  }
 
  template <typename StartWirelessDeviceImportTaskRequestT = Model::StartWirelessDeviceImportTaskRequest>
  void StartWirelessDeviceImportTaskAsync(const StartWirelessDeviceImportTaskRequestT& request,
                                          const StartWirelessDeviceImportTaskResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::StartWirelessDeviceImportTask, 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(&IoTWirelessClient::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(&IoTWirelessClient::TagResource, request, handler, context);
  }
 
  virtual Model::TestWirelessDeviceOutcome TestWirelessDevice(const Model::TestWirelessDeviceRequest& request) const;
 
  template <typename TestWirelessDeviceRequestT = Model::TestWirelessDeviceRequest>
  Model::TestWirelessDeviceOutcomeCallable TestWirelessDeviceCallable(const TestWirelessDeviceRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::TestWirelessDevice, request);
  }
 
  template <typename TestWirelessDeviceRequestT = Model::TestWirelessDeviceRequest>
  void TestWirelessDeviceAsync(const TestWirelessDeviceRequestT& request, const TestWirelessDeviceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::TestWirelessDevice, 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(&IoTWirelessClient::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(&IoTWirelessClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateDestinationOutcome UpdateDestination(const Model::UpdateDestinationRequest& request) const;
 
  template <typename UpdateDestinationRequestT = Model::UpdateDestinationRequest>
  Model::UpdateDestinationOutcomeCallable UpdateDestinationCallable(const UpdateDestinationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateDestination, request);
  }
 
  template <typename UpdateDestinationRequestT = Model::UpdateDestinationRequest>
  void UpdateDestinationAsync(const UpdateDestinationRequestT& request, const UpdateDestinationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateDestination, request, handler, context);
  }
 
  virtual Model::UpdateEventConfigurationByResourceTypesOutcome UpdateEventConfigurationByResourceTypes(
      const Model::UpdateEventConfigurationByResourceTypesRequest& request = {}) const;
 
  template <typename UpdateEventConfigurationByResourceTypesRequestT = Model::UpdateEventConfigurationByResourceTypesRequest>
  Model::UpdateEventConfigurationByResourceTypesOutcomeCallable UpdateEventConfigurationByResourceTypesCallable(
      const UpdateEventConfigurationByResourceTypesRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::UpdateEventConfigurationByResourceTypes, request);
  }
 
  template <typename UpdateEventConfigurationByResourceTypesRequestT = Model::UpdateEventConfigurationByResourceTypesRequest>
  void UpdateEventConfigurationByResourceTypesAsync(const UpdateEventConfigurationByResourceTypesResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                    const UpdateEventConfigurationByResourceTypesRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::UpdateEventConfigurationByResourceTypes, request, handler, context);
  }
 
  virtual Model::UpdateFuotaTaskOutcome UpdateFuotaTask(const Model::UpdateFuotaTaskRequest& request) const;
 
  template <typename UpdateFuotaTaskRequestT = Model::UpdateFuotaTaskRequest>
  Model::UpdateFuotaTaskOutcomeCallable UpdateFuotaTaskCallable(const UpdateFuotaTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateFuotaTask, request);
  }
 
  template <typename UpdateFuotaTaskRequestT = Model::UpdateFuotaTaskRequest>
  void UpdateFuotaTaskAsync(const UpdateFuotaTaskRequestT& request, const UpdateFuotaTaskResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateFuotaTask, request, handler, context);
  }
 
  virtual Model::UpdateLogLevelsByResourceTypesOutcome UpdateLogLevelsByResourceTypes(
      const Model::UpdateLogLevelsByResourceTypesRequest& request = {}) const;
 
  template <typename UpdateLogLevelsByResourceTypesRequestT = Model::UpdateLogLevelsByResourceTypesRequest>
  Model::UpdateLogLevelsByResourceTypesOutcomeCallable UpdateLogLevelsByResourceTypesCallable(
      const UpdateLogLevelsByResourceTypesRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::UpdateLogLevelsByResourceTypes, request);
  }
 
  template <typename UpdateLogLevelsByResourceTypesRequestT = Model::UpdateLogLevelsByResourceTypesRequest>
  void UpdateLogLevelsByResourceTypesAsync(const UpdateLogLevelsByResourceTypesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const UpdateLogLevelsByResourceTypesRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::UpdateLogLevelsByResourceTypes, request, handler, context);
  }
 
  virtual Model::UpdateMetricConfigurationOutcome UpdateMetricConfiguration(
      const Model::UpdateMetricConfigurationRequest& request = {}) const;
 
  template <typename UpdateMetricConfigurationRequestT = Model::UpdateMetricConfigurationRequest>
  Model::UpdateMetricConfigurationOutcomeCallable UpdateMetricConfigurationCallable(
      const UpdateMetricConfigurationRequestT& request = {}) const {
    return SubmitCallable(&IoTWirelessClient::UpdateMetricConfiguration, request);
  }
 
  template <typename UpdateMetricConfigurationRequestT = Model::UpdateMetricConfigurationRequest>
  void UpdateMetricConfigurationAsync(const UpdateMetricConfigurationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const UpdateMetricConfigurationRequestT& request = {}) const {
    return SubmitAsync(&IoTWirelessClient::UpdateMetricConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateMulticastGroupOutcome UpdateMulticastGroup(const Model::UpdateMulticastGroupRequest& request) const;
 
  template <typename UpdateMulticastGroupRequestT = Model::UpdateMulticastGroupRequest>
  Model::UpdateMulticastGroupOutcomeCallable UpdateMulticastGroupCallable(const UpdateMulticastGroupRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateMulticastGroup, request);
  }
 
  template <typename UpdateMulticastGroupRequestT = Model::UpdateMulticastGroupRequest>
  void UpdateMulticastGroupAsync(const UpdateMulticastGroupRequestT& request, const UpdateMulticastGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateMulticastGroup, request, handler, context);
  }
 
  virtual Model::UpdateNetworkAnalyzerConfigurationOutcome UpdateNetworkAnalyzerConfiguration(
      const Model::UpdateNetworkAnalyzerConfigurationRequest& request) const;
 
  template <typename UpdateNetworkAnalyzerConfigurationRequestT = Model::UpdateNetworkAnalyzerConfigurationRequest>
  Model::UpdateNetworkAnalyzerConfigurationOutcomeCallable UpdateNetworkAnalyzerConfigurationCallable(
      const UpdateNetworkAnalyzerConfigurationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateNetworkAnalyzerConfiguration, request);
  }
 
  template <typename UpdateNetworkAnalyzerConfigurationRequestT = Model::UpdateNetworkAnalyzerConfigurationRequest>
  void UpdateNetworkAnalyzerConfigurationAsync(const UpdateNetworkAnalyzerConfigurationRequestT& request,
                                               const UpdateNetworkAnalyzerConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateNetworkAnalyzerConfiguration, request, handler, context);
  }
 
  virtual Model::UpdatePartnerAccountOutcome UpdatePartnerAccount(const Model::UpdatePartnerAccountRequest& request) const;
 
  template <typename UpdatePartnerAccountRequestT = Model::UpdatePartnerAccountRequest>
  Model::UpdatePartnerAccountOutcomeCallable UpdatePartnerAccountCallable(const UpdatePartnerAccountRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdatePartnerAccount, request);
  }
 
  template <typename UpdatePartnerAccountRequestT = Model::UpdatePartnerAccountRequest>
  void UpdatePartnerAccountAsync(const UpdatePartnerAccountRequestT& request, const UpdatePartnerAccountResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdatePartnerAccount, request, handler, context);
  }
 
  virtual Model::UpdateResourceEventConfigurationOutcome UpdateResourceEventConfiguration(
      const Model::UpdateResourceEventConfigurationRequest& request) const;
 
  template <typename UpdateResourceEventConfigurationRequestT = Model::UpdateResourceEventConfigurationRequest>
  Model::UpdateResourceEventConfigurationOutcomeCallable UpdateResourceEventConfigurationCallable(
      const UpdateResourceEventConfigurationRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateResourceEventConfiguration, request);
  }
 
  template <typename UpdateResourceEventConfigurationRequestT = Model::UpdateResourceEventConfigurationRequest>
  void UpdateResourceEventConfigurationAsync(const UpdateResourceEventConfigurationRequestT& request,
                                             const UpdateResourceEventConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateResourceEventConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateResourcePositionOutcome UpdateResourcePosition(const Model::UpdateResourcePositionRequest& request) const;
 
  template <typename UpdateResourcePositionRequestT = Model::UpdateResourcePositionRequest>
  Model::UpdateResourcePositionOutcomeCallable UpdateResourcePositionCallable(const UpdateResourcePositionRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateResourcePosition, request);
  }
 
  template <typename UpdateResourcePositionRequestT = Model::UpdateResourcePositionRequest>
  void UpdateResourcePositionAsync(const UpdateResourcePositionRequestT& request,
                                   const UpdateResourcePositionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateResourcePosition, request, handler, context);
  }
 
  virtual Model::UpdateWirelessDeviceOutcome UpdateWirelessDevice(const Model::UpdateWirelessDeviceRequest& request) const;
 
  template <typename UpdateWirelessDeviceRequestT = Model::UpdateWirelessDeviceRequest>
  Model::UpdateWirelessDeviceOutcomeCallable UpdateWirelessDeviceCallable(const UpdateWirelessDeviceRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateWirelessDevice, request);
  }
 
  template <typename UpdateWirelessDeviceRequestT = Model::UpdateWirelessDeviceRequest>
  void UpdateWirelessDeviceAsync(const UpdateWirelessDeviceRequestT& request, const UpdateWirelessDeviceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateWirelessDevice, request, handler, context);
  }
 
  virtual Model::UpdateWirelessDeviceImportTaskOutcome UpdateWirelessDeviceImportTask(
      const Model::UpdateWirelessDeviceImportTaskRequest& request) const;
 
  template <typename UpdateWirelessDeviceImportTaskRequestT = Model::UpdateWirelessDeviceImportTaskRequest>
  Model::UpdateWirelessDeviceImportTaskOutcomeCallable UpdateWirelessDeviceImportTaskCallable(
      const UpdateWirelessDeviceImportTaskRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateWirelessDeviceImportTask, request);
  }
 
  template <typename UpdateWirelessDeviceImportTaskRequestT = Model::UpdateWirelessDeviceImportTaskRequest>
  void UpdateWirelessDeviceImportTaskAsync(const UpdateWirelessDeviceImportTaskRequestT& request,
                                           const UpdateWirelessDeviceImportTaskResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateWirelessDeviceImportTask, request, handler, context);
  }
 
  virtual Model::UpdateWirelessGatewayOutcome UpdateWirelessGateway(const Model::UpdateWirelessGatewayRequest& request) const;
 
  template <typename UpdateWirelessGatewayRequestT = Model::UpdateWirelessGatewayRequest>
  Model::UpdateWirelessGatewayOutcomeCallable UpdateWirelessGatewayCallable(const UpdateWirelessGatewayRequestT& request) const {
    return SubmitCallable(&IoTWirelessClient::UpdateWirelessGateway, request);
  }
 
  template <typename UpdateWirelessGatewayRequestT = Model::UpdateWirelessGatewayRequest>
  void UpdateWirelessGatewayAsync(const UpdateWirelessGatewayRequestT& request, const UpdateWirelessGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&IoTWirelessClient::UpdateWirelessGateway, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<IoTWirelessEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTWirelessClient>;
  void init(const IoTWirelessClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, IoTWirelessError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  IoTWirelessClientConfiguration m_clientConfiguration;
  std::shared_ptr<IoTWirelessEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace IoTWireless
}  // namespace Aws