KinesisAnalyticsV2Client.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/kinesisanalyticsv2/KinesisAnalyticsV2PaginationBase.h>
#include <aws/kinesisanalyticsv2/KinesisAnalyticsV2ServiceClientModel.h>
#include <aws/kinesisanalyticsv2/KinesisAnalyticsV2Waiter.h>
#include <aws/kinesisanalyticsv2/KinesisAnalyticsV2_EXPORTS.h>
 
namespace Aws {
namespace KinesisAnalyticsV2 {
class AWS_KINESISANALYTICSV2_API KinesisAnalyticsV2Client : public Aws::Client::AWSJsonClient,
                                                            public Aws::Client::ClientWithAsyncTemplateMethods<KinesisAnalyticsV2Client>,
                                                            public KinesisAnalyticsV2PaginationBase<KinesisAnalyticsV2Client>,
                                                            public KinesisAnalyticsV2Waiter<KinesisAnalyticsV2Client> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KinesisAnalyticsV2ClientConfiguration ClientConfigurationType;
  typedef KinesisAnalyticsV2EndpointProvider EndpointProviderType;
 
  KinesisAnalyticsV2Client(const Aws::KinesisAnalyticsV2::KinesisAnalyticsV2ClientConfiguration& clientConfiguration =
                               Aws::KinesisAnalyticsV2::KinesisAnalyticsV2ClientConfiguration(),
                           std::shared_ptr<KinesisAnalyticsV2EndpointProviderBase> endpointProvider = nullptr);
 
  KinesisAnalyticsV2Client(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<KinesisAnalyticsV2EndpointProviderBase> endpointProvider = nullptr,
                           const Aws::KinesisAnalyticsV2::KinesisAnalyticsV2ClientConfiguration& clientConfiguration =
                               Aws::KinesisAnalyticsV2::KinesisAnalyticsV2ClientConfiguration());
 
  KinesisAnalyticsV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<KinesisAnalyticsV2EndpointProviderBase> endpointProvider = nullptr,
                           const Aws::KinesisAnalyticsV2::KinesisAnalyticsV2ClientConfiguration& clientConfiguration =
                               Aws::KinesisAnalyticsV2::KinesisAnalyticsV2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KinesisAnalyticsV2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KinesisAnalyticsV2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KinesisAnalyticsV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KinesisAnalyticsV2Client();
 
  virtual Model::AddApplicationCloudWatchLoggingOptionOutcome AddApplicationCloudWatchLoggingOption(
      const Model::AddApplicationCloudWatchLoggingOptionRequest& request) const;
 
  template <typename AddApplicationCloudWatchLoggingOptionRequestT = Model::AddApplicationCloudWatchLoggingOptionRequest>
  Model::AddApplicationCloudWatchLoggingOptionOutcomeCallable AddApplicationCloudWatchLoggingOptionCallable(
      const AddApplicationCloudWatchLoggingOptionRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::AddApplicationCloudWatchLoggingOption, request);
  }
 
  template <typename AddApplicationCloudWatchLoggingOptionRequestT = Model::AddApplicationCloudWatchLoggingOptionRequest>
  void AddApplicationCloudWatchLoggingOptionAsync(const AddApplicationCloudWatchLoggingOptionRequestT& request,
                                                  const AddApplicationCloudWatchLoggingOptionResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::AddApplicationCloudWatchLoggingOption, request, handler, context);
  }
 
  virtual Model::AddApplicationInputOutcome AddApplicationInput(const Model::AddApplicationInputRequest& request) const;
 
  template <typename AddApplicationInputRequestT = Model::AddApplicationInputRequest>
  Model::AddApplicationInputOutcomeCallable AddApplicationInputCallable(const AddApplicationInputRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::AddApplicationInput, request);
  }
 
  template <typename AddApplicationInputRequestT = Model::AddApplicationInputRequest>
  void AddApplicationInputAsync(const AddApplicationInputRequestT& request, const AddApplicationInputResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::AddApplicationInput, request, handler, context);
  }
 
  virtual Model::AddApplicationInputProcessingConfigurationOutcome AddApplicationInputProcessingConfiguration(
      const Model::AddApplicationInputProcessingConfigurationRequest& request) const;
 
  template <typename AddApplicationInputProcessingConfigurationRequestT = Model::AddApplicationInputProcessingConfigurationRequest>
  Model::AddApplicationInputProcessingConfigurationOutcomeCallable AddApplicationInputProcessingConfigurationCallable(
      const AddApplicationInputProcessingConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::AddApplicationInputProcessingConfiguration, request);
  }
 
  template <typename AddApplicationInputProcessingConfigurationRequestT = Model::AddApplicationInputProcessingConfigurationRequest>
  void AddApplicationInputProcessingConfigurationAsync(
      const AddApplicationInputProcessingConfigurationRequestT& request,
      const AddApplicationInputProcessingConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::AddApplicationInputProcessingConfiguration, request, handler, context);
  }
 
  virtual Model::AddApplicationOutputOutcome AddApplicationOutput(const Model::AddApplicationOutputRequest& request) const;
 
  template <typename AddApplicationOutputRequestT = Model::AddApplicationOutputRequest>
  Model::AddApplicationOutputOutcomeCallable AddApplicationOutputCallable(const AddApplicationOutputRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::AddApplicationOutput, request);
  }
 
  template <typename AddApplicationOutputRequestT = Model::AddApplicationOutputRequest>
  void AddApplicationOutputAsync(const AddApplicationOutputRequestT& request, const AddApplicationOutputResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::AddApplicationOutput, request, handler, context);
  }
 
  virtual Model::AddApplicationReferenceDataSourceOutcome AddApplicationReferenceDataSource(
      const Model::AddApplicationReferenceDataSourceRequest& request) const;
 
  template <typename AddApplicationReferenceDataSourceRequestT = Model::AddApplicationReferenceDataSourceRequest>
  Model::AddApplicationReferenceDataSourceOutcomeCallable AddApplicationReferenceDataSourceCallable(
      const AddApplicationReferenceDataSourceRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::AddApplicationReferenceDataSource, request);
  }
 
  template <typename AddApplicationReferenceDataSourceRequestT = Model::AddApplicationReferenceDataSourceRequest>
  void AddApplicationReferenceDataSourceAsync(const AddApplicationReferenceDataSourceRequestT& request,
                                              const AddApplicationReferenceDataSourceResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::AddApplicationReferenceDataSource, request, handler, context);
  }
 
  virtual Model::AddApplicationVpcConfigurationOutcome AddApplicationVpcConfiguration(
      const Model::AddApplicationVpcConfigurationRequest& request) const;
 
  template <typename AddApplicationVpcConfigurationRequestT = Model::AddApplicationVpcConfigurationRequest>
  Model::AddApplicationVpcConfigurationOutcomeCallable AddApplicationVpcConfigurationCallable(
      const AddApplicationVpcConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::AddApplicationVpcConfiguration, request);
  }
 
  template <typename AddApplicationVpcConfigurationRequestT = Model::AddApplicationVpcConfigurationRequest>
  void AddApplicationVpcConfigurationAsync(const AddApplicationVpcConfigurationRequestT& request,
                                           const AddApplicationVpcConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::AddApplicationVpcConfiguration, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateApplicationPresignedUrlOutcome CreateApplicationPresignedUrl(
      const Model::CreateApplicationPresignedUrlRequest& request) const;
 
  template <typename CreateApplicationPresignedUrlRequestT = Model::CreateApplicationPresignedUrlRequest>
  Model::CreateApplicationPresignedUrlOutcomeCallable CreateApplicationPresignedUrlCallable(
      const CreateApplicationPresignedUrlRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::CreateApplicationPresignedUrl, request);
  }
 
  template <typename CreateApplicationPresignedUrlRequestT = Model::CreateApplicationPresignedUrlRequest>
  void CreateApplicationPresignedUrlAsync(const CreateApplicationPresignedUrlRequestT& request,
                                          const CreateApplicationPresignedUrlResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::CreateApplicationPresignedUrl, request, handler, context);
  }
 
  virtual Model::CreateApplicationSnapshotOutcome CreateApplicationSnapshot(const Model::CreateApplicationSnapshotRequest& request) const;
 
  template <typename CreateApplicationSnapshotRequestT = Model::CreateApplicationSnapshotRequest>
  Model::CreateApplicationSnapshotOutcomeCallable CreateApplicationSnapshotCallable(
      const CreateApplicationSnapshotRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::CreateApplicationSnapshot, request);
  }
 
  template <typename CreateApplicationSnapshotRequestT = Model::CreateApplicationSnapshotRequest>
  void CreateApplicationSnapshotAsync(const CreateApplicationSnapshotRequestT& request,
                                      const CreateApplicationSnapshotResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::CreateApplicationSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteApplicationCloudWatchLoggingOptionOutcome DeleteApplicationCloudWatchLoggingOption(
      const Model::DeleteApplicationCloudWatchLoggingOptionRequest& request) const;
 
  template <typename DeleteApplicationCloudWatchLoggingOptionRequestT = Model::DeleteApplicationCloudWatchLoggingOptionRequest>
  Model::DeleteApplicationCloudWatchLoggingOptionOutcomeCallable DeleteApplicationCloudWatchLoggingOptionCallable(
      const DeleteApplicationCloudWatchLoggingOptionRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DeleteApplicationCloudWatchLoggingOption, request);
  }
 
  template <typename DeleteApplicationCloudWatchLoggingOptionRequestT = Model::DeleteApplicationCloudWatchLoggingOptionRequest>
  void DeleteApplicationCloudWatchLoggingOptionAsync(
      const DeleteApplicationCloudWatchLoggingOptionRequestT& request,
      const DeleteApplicationCloudWatchLoggingOptionResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DeleteApplicationCloudWatchLoggingOption, request, handler, context);
  }
 
  virtual Model::DeleteApplicationInputProcessingConfigurationOutcome DeleteApplicationInputProcessingConfiguration(
      const Model::DeleteApplicationInputProcessingConfigurationRequest& request) const;
 
  template <typename DeleteApplicationInputProcessingConfigurationRequestT = Model::DeleteApplicationInputProcessingConfigurationRequest>
  Model::DeleteApplicationInputProcessingConfigurationOutcomeCallable DeleteApplicationInputProcessingConfigurationCallable(
      const DeleteApplicationInputProcessingConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DeleteApplicationInputProcessingConfiguration, request);
  }
 
  template <typename DeleteApplicationInputProcessingConfigurationRequestT = Model::DeleteApplicationInputProcessingConfigurationRequest>
  void DeleteApplicationInputProcessingConfigurationAsync(
      const DeleteApplicationInputProcessingConfigurationRequestT& request,
      const DeleteApplicationInputProcessingConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DeleteApplicationInputProcessingConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutputOutcome DeleteApplicationOutput(const Model::DeleteApplicationOutputRequest& request) const;
 
  template <typename DeleteApplicationOutputRequestT = Model::DeleteApplicationOutputRequest>
  Model::DeleteApplicationOutputOutcomeCallable DeleteApplicationOutputCallable(const DeleteApplicationOutputRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DeleteApplicationOutput, request);
  }
 
  template <typename DeleteApplicationOutputRequestT = Model::DeleteApplicationOutputRequest>
  void DeleteApplicationOutputAsync(const DeleteApplicationOutputRequestT& request,
                                    const DeleteApplicationOutputResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DeleteApplicationOutput, request, handler, context);
  }
 
  virtual Model::DeleteApplicationReferenceDataSourceOutcome DeleteApplicationReferenceDataSource(
      const Model::DeleteApplicationReferenceDataSourceRequest& request) const;
 
  template <typename DeleteApplicationReferenceDataSourceRequestT = Model::DeleteApplicationReferenceDataSourceRequest>
  Model::DeleteApplicationReferenceDataSourceOutcomeCallable DeleteApplicationReferenceDataSourceCallable(
      const DeleteApplicationReferenceDataSourceRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DeleteApplicationReferenceDataSource, request);
  }
 
  template <typename DeleteApplicationReferenceDataSourceRequestT = Model::DeleteApplicationReferenceDataSourceRequest>
  void DeleteApplicationReferenceDataSourceAsync(const DeleteApplicationReferenceDataSourceRequestT& request,
                                                 const DeleteApplicationReferenceDataSourceResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DeleteApplicationReferenceDataSource, request, handler, context);
  }
 
  virtual Model::DeleteApplicationSnapshotOutcome DeleteApplicationSnapshot(const Model::DeleteApplicationSnapshotRequest& request) const;
 
  template <typename DeleteApplicationSnapshotRequestT = Model::DeleteApplicationSnapshotRequest>
  Model::DeleteApplicationSnapshotOutcomeCallable DeleteApplicationSnapshotCallable(
      const DeleteApplicationSnapshotRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DeleteApplicationSnapshot, request);
  }
 
  template <typename DeleteApplicationSnapshotRequestT = Model::DeleteApplicationSnapshotRequest>
  void DeleteApplicationSnapshotAsync(const DeleteApplicationSnapshotRequestT& request,
                                      const DeleteApplicationSnapshotResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DeleteApplicationSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteApplicationVpcConfigurationOutcome DeleteApplicationVpcConfiguration(
      const Model::DeleteApplicationVpcConfigurationRequest& request) const;
 
  template <typename DeleteApplicationVpcConfigurationRequestT = Model::DeleteApplicationVpcConfigurationRequest>
  Model::DeleteApplicationVpcConfigurationOutcomeCallable DeleteApplicationVpcConfigurationCallable(
      const DeleteApplicationVpcConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DeleteApplicationVpcConfiguration, request);
  }
 
  template <typename DeleteApplicationVpcConfigurationRequestT = Model::DeleteApplicationVpcConfigurationRequest>
  void DeleteApplicationVpcConfigurationAsync(const DeleteApplicationVpcConfigurationRequestT& request,
                                              const DeleteApplicationVpcConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DeleteApplicationVpcConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeApplicationOutcome DescribeApplication(const Model::DescribeApplicationRequest& request) const;
 
  template <typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
  Model::DescribeApplicationOutcomeCallable DescribeApplicationCallable(const DescribeApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DescribeApplication, request);
  }
 
  template <typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
  void DescribeApplicationAsync(const DescribeApplicationRequestT& request, const DescribeApplicationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DescribeApplication, request, handler, context);
  }
 
  virtual Model::DescribeApplicationOperationOutcome DescribeApplicationOperation(
      const Model::DescribeApplicationOperationRequest& request) const;
 
  template <typename DescribeApplicationOperationRequestT = Model::DescribeApplicationOperationRequest>
  Model::DescribeApplicationOperationOutcomeCallable DescribeApplicationOperationCallable(
      const DescribeApplicationOperationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DescribeApplicationOperation, request);
  }
 
  template <typename DescribeApplicationOperationRequestT = Model::DescribeApplicationOperationRequest>
  void DescribeApplicationOperationAsync(const DescribeApplicationOperationRequestT& request,
                                         const DescribeApplicationOperationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DescribeApplicationOperation, request, handler, context);
  }
 
  virtual Model::DescribeApplicationSnapshotOutcome DescribeApplicationSnapshot(
      const Model::DescribeApplicationSnapshotRequest& request) const;
 
  template <typename DescribeApplicationSnapshotRequestT = Model::DescribeApplicationSnapshotRequest>
  Model::DescribeApplicationSnapshotOutcomeCallable DescribeApplicationSnapshotCallable(
      const DescribeApplicationSnapshotRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DescribeApplicationSnapshot, request);
  }
 
  template <typename DescribeApplicationSnapshotRequestT = Model::DescribeApplicationSnapshotRequest>
  void DescribeApplicationSnapshotAsync(const DescribeApplicationSnapshotRequestT& request,
                                        const DescribeApplicationSnapshotResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DescribeApplicationSnapshot, request, handler, context);
  }
 
  virtual Model::DescribeApplicationVersionOutcome DescribeApplicationVersion(
      const Model::DescribeApplicationVersionRequest& request) const;
 
  template <typename DescribeApplicationVersionRequestT = Model::DescribeApplicationVersionRequest>
  Model::DescribeApplicationVersionOutcomeCallable DescribeApplicationVersionCallable(
      const DescribeApplicationVersionRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DescribeApplicationVersion, request);
  }
 
  template <typename DescribeApplicationVersionRequestT = Model::DescribeApplicationVersionRequest>
  void DescribeApplicationVersionAsync(const DescribeApplicationVersionRequestT& request,
                                       const DescribeApplicationVersionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DescribeApplicationVersion, request, handler, context);
  }
 
  virtual Model::DiscoverInputSchemaOutcome DiscoverInputSchema(const Model::DiscoverInputSchemaRequest& request) const;
 
  template <typename DiscoverInputSchemaRequestT = Model::DiscoverInputSchemaRequest>
  Model::DiscoverInputSchemaOutcomeCallable DiscoverInputSchemaCallable(const DiscoverInputSchemaRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::DiscoverInputSchema, request);
  }
 
  template <typename DiscoverInputSchemaRequestT = Model::DiscoverInputSchemaRequest>
  void DiscoverInputSchemaAsync(const DiscoverInputSchemaRequestT& request, const DiscoverInputSchemaResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::DiscoverInputSchema, request, handler, context);
  }
 
  virtual Model::ListApplicationOperationsOutcome ListApplicationOperations(const Model::ListApplicationOperationsRequest& request) const;
 
  template <typename ListApplicationOperationsRequestT = Model::ListApplicationOperationsRequest>
  Model::ListApplicationOperationsOutcomeCallable ListApplicationOperationsCallable(
      const ListApplicationOperationsRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::ListApplicationOperations, request);
  }
 
  template <typename ListApplicationOperationsRequestT = Model::ListApplicationOperationsRequest>
  void ListApplicationOperationsAsync(const ListApplicationOperationsRequestT& request,
                                      const ListApplicationOperationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::ListApplicationOperations, request, handler, context);
  }
 
  virtual Model::ListApplicationSnapshotsOutcome ListApplicationSnapshots(const Model::ListApplicationSnapshotsRequest& request) const;
 
  template <typename ListApplicationSnapshotsRequestT = Model::ListApplicationSnapshotsRequest>
  Model::ListApplicationSnapshotsOutcomeCallable ListApplicationSnapshotsCallable(const ListApplicationSnapshotsRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::ListApplicationSnapshots, request);
  }
 
  template <typename ListApplicationSnapshotsRequestT = Model::ListApplicationSnapshotsRequest>
  void ListApplicationSnapshotsAsync(const ListApplicationSnapshotsRequestT& request,
                                     const ListApplicationSnapshotsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::ListApplicationSnapshots, request, handler, context);
  }
 
  virtual Model::ListApplicationVersionsOutcome ListApplicationVersions(const Model::ListApplicationVersionsRequest& request) const;
 
  template <typename ListApplicationVersionsRequestT = Model::ListApplicationVersionsRequest>
  Model::ListApplicationVersionsOutcomeCallable ListApplicationVersionsCallable(const ListApplicationVersionsRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::ListApplicationVersions, request);
  }
 
  template <typename ListApplicationVersionsRequestT = Model::ListApplicationVersionsRequest>
  void ListApplicationVersionsAsync(const ListApplicationVersionsRequestT& request,
                                    const ListApplicationVersionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::ListApplicationVersions, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::ListApplications, 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(&KinesisAnalyticsV2Client::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(&KinesisAnalyticsV2Client::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RollbackApplicationOutcome RollbackApplication(const Model::RollbackApplicationRequest& request) const;
 
  template <typename RollbackApplicationRequestT = Model::RollbackApplicationRequest>
  Model::RollbackApplicationOutcomeCallable RollbackApplicationCallable(const RollbackApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::RollbackApplication, request);
  }
 
  template <typename RollbackApplicationRequestT = Model::RollbackApplicationRequest>
  void RollbackApplicationAsync(const RollbackApplicationRequestT& request, const RollbackApplicationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::RollbackApplication, request, handler, context);
  }
 
  virtual Model::StartApplicationOutcome StartApplication(const Model::StartApplicationRequest& request) const;
 
  template <typename StartApplicationRequestT = Model::StartApplicationRequest>
  Model::StartApplicationOutcomeCallable StartApplicationCallable(const StartApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::StartApplication, request);
  }
 
  template <typename StartApplicationRequestT = Model::StartApplicationRequest>
  void StartApplicationAsync(const StartApplicationRequestT& request, const StartApplicationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::StartApplication, request, handler, context);
  }
 
  virtual Model::StopApplicationOutcome StopApplication(const Model::StopApplicationRequest& request) const;
 
  template <typename StopApplicationRequestT = Model::StopApplicationRequest>
  Model::StopApplicationOutcomeCallable StopApplicationCallable(const StopApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::StopApplication, request);
  }
 
  template <typename StopApplicationRequestT = Model::StopApplicationRequest>
  void StopApplicationAsync(const StopApplicationRequestT& request, const StopApplicationResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::StopApplication, 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(&KinesisAnalyticsV2Client::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(&KinesisAnalyticsV2Client::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::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(&KinesisAnalyticsV2Client::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateApplicationMaintenanceConfigurationOutcome UpdateApplicationMaintenanceConfiguration(
      const Model::UpdateApplicationMaintenanceConfigurationRequest& request) const;
 
  template <typename UpdateApplicationMaintenanceConfigurationRequestT = Model::UpdateApplicationMaintenanceConfigurationRequest>
  Model::UpdateApplicationMaintenanceConfigurationOutcomeCallable UpdateApplicationMaintenanceConfigurationCallable(
      const UpdateApplicationMaintenanceConfigurationRequestT& request) const {
    return SubmitCallable(&KinesisAnalyticsV2Client::UpdateApplicationMaintenanceConfiguration, request);
  }
 
  template <typename UpdateApplicationMaintenanceConfigurationRequestT = Model::UpdateApplicationMaintenanceConfigurationRequest>
  void UpdateApplicationMaintenanceConfigurationAsync(
      const UpdateApplicationMaintenanceConfigurationRequestT& request,
      const UpdateApplicationMaintenanceConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KinesisAnalyticsV2Client::UpdateApplicationMaintenanceConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KinesisAnalyticsV2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KinesisAnalyticsV2Client>;
  void init(const KinesisAnalyticsV2ClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, KinesisAnalyticsV2Error> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  KinesisAnalyticsV2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<KinesisAnalyticsV2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace KinesisAnalyticsV2
}  // namespace Aws