CloudDirectoryClient.h

 
#pragma once
#include <aws/clouddirectory/CloudDirectoryPaginationBase.h>
#include <aws/clouddirectory/CloudDirectoryServiceClientModel.h>
#include <aws/clouddirectory/CloudDirectoryWaiter.h>
#include <aws/clouddirectory/CloudDirectory_EXPORTS.h>
#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>
 
namespace Aws {
namespace CloudDirectory {
class AWS_CLOUDDIRECTORY_API CloudDirectoryClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<CloudDirectoryClient>,
                                                    public CloudDirectoryPaginationBase<CloudDirectoryClient>,
                                                    public CloudDirectoryWaiter<CloudDirectoryClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CloudDirectoryClientConfiguration ClientConfigurationType;
  typedef CloudDirectoryEndpointProvider EndpointProviderType;
 
  CloudDirectoryClient(const Aws::CloudDirectory::CloudDirectoryClientConfiguration& clientConfiguration =
                           Aws::CloudDirectory::CloudDirectoryClientConfiguration(),
                       std::shared_ptr<CloudDirectoryEndpointProviderBase> endpointProvider = nullptr);
 
  CloudDirectoryClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<CloudDirectoryEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::CloudDirectory::CloudDirectoryClientConfiguration& clientConfiguration =
                           Aws::CloudDirectory::CloudDirectoryClientConfiguration());
 
  CloudDirectoryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<CloudDirectoryEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::CloudDirectory::CloudDirectoryClientConfiguration& clientConfiguration =
                           Aws::CloudDirectory::CloudDirectoryClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CloudDirectoryClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudDirectoryClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudDirectoryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CloudDirectoryClient();
 
  virtual Model::AddFacetToObjectOutcome AddFacetToObject(const Model::AddFacetToObjectRequest& request) const;
 
  template <typename AddFacetToObjectRequestT = Model::AddFacetToObjectRequest>
  Model::AddFacetToObjectOutcomeCallable AddFacetToObjectCallable(const AddFacetToObjectRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::AddFacetToObject, request);
  }
 
  template <typename AddFacetToObjectRequestT = Model::AddFacetToObjectRequest>
  void AddFacetToObjectAsync(const AddFacetToObjectRequestT& request, const AddFacetToObjectResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::AddFacetToObject, request, handler, context);
  }
 
  virtual Model::ApplySchemaOutcome ApplySchema(const Model::ApplySchemaRequest& request) const;
 
  template <typename ApplySchemaRequestT = Model::ApplySchemaRequest>
  Model::ApplySchemaOutcomeCallable ApplySchemaCallable(const ApplySchemaRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ApplySchema, request);
  }
 
  template <typename ApplySchemaRequestT = Model::ApplySchemaRequest>
  void ApplySchemaAsync(const ApplySchemaRequestT& request, const ApplySchemaResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ApplySchema, request, handler, context);
  }
 
  virtual Model::AttachObjectOutcome AttachObject(const Model::AttachObjectRequest& request) const;
 
  template <typename AttachObjectRequestT = Model::AttachObjectRequest>
  Model::AttachObjectOutcomeCallable AttachObjectCallable(const AttachObjectRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::AttachObject, request);
  }
 
  template <typename AttachObjectRequestT = Model::AttachObjectRequest>
  void AttachObjectAsync(const AttachObjectRequestT& request, const AttachObjectResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::AttachObject, request, handler, context);
  }
 
  virtual Model::AttachPolicyOutcome AttachPolicy(const Model::AttachPolicyRequest& request) const;
 
  template <typename AttachPolicyRequestT = Model::AttachPolicyRequest>
  Model::AttachPolicyOutcomeCallable AttachPolicyCallable(const AttachPolicyRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::AttachPolicy, request);
  }
 
  template <typename AttachPolicyRequestT = Model::AttachPolicyRequest>
  void AttachPolicyAsync(const AttachPolicyRequestT& request, const AttachPolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::AttachPolicy, request, handler, context);
  }
 
  virtual Model::AttachToIndexOutcome AttachToIndex(const Model::AttachToIndexRequest& request) const;
 
  template <typename AttachToIndexRequestT = Model::AttachToIndexRequest>
  Model::AttachToIndexOutcomeCallable AttachToIndexCallable(const AttachToIndexRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::AttachToIndex, request);
  }
 
  template <typename AttachToIndexRequestT = Model::AttachToIndexRequest>
  void AttachToIndexAsync(const AttachToIndexRequestT& request, const AttachToIndexResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::AttachToIndex, request, handler, context);
  }
 
  virtual Model::AttachTypedLinkOutcome AttachTypedLink(const Model::AttachTypedLinkRequest& request) const;
 
  template <typename AttachTypedLinkRequestT = Model::AttachTypedLinkRequest>
  Model::AttachTypedLinkOutcomeCallable AttachTypedLinkCallable(const AttachTypedLinkRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::AttachTypedLink, request);
  }
 
  template <typename AttachTypedLinkRequestT = Model::AttachTypedLinkRequest>
  void AttachTypedLinkAsync(const AttachTypedLinkRequestT& request, const AttachTypedLinkResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::AttachTypedLink, request, handler, context);
  }
 
  virtual Model::BatchReadOutcome BatchRead(const Model::BatchReadRequest& request) const;
 
  template <typename BatchReadRequestT = Model::BatchReadRequest>
  Model::BatchReadOutcomeCallable BatchReadCallable(const BatchReadRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::BatchRead, request);
  }
 
  template <typename BatchReadRequestT = Model::BatchReadRequest>
  void BatchReadAsync(const BatchReadRequestT& request, const BatchReadResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::BatchRead, request, handler, context);
  }
 
  virtual Model::BatchWriteOutcome BatchWrite(const Model::BatchWriteRequest& request) const;
 
  template <typename BatchWriteRequestT = Model::BatchWriteRequest>
  Model::BatchWriteOutcomeCallable BatchWriteCallable(const BatchWriteRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::BatchWrite, request);
  }
 
  template <typename BatchWriteRequestT = Model::BatchWriteRequest>
  void BatchWriteAsync(const BatchWriteRequestT& request, const BatchWriteResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::BatchWrite, request, handler, context);
  }
 
  virtual Model::CreateDirectoryOutcome CreateDirectory(const Model::CreateDirectoryRequest& request) const;
 
  template <typename CreateDirectoryRequestT = Model::CreateDirectoryRequest>
  Model::CreateDirectoryOutcomeCallable CreateDirectoryCallable(const CreateDirectoryRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::CreateDirectory, request);
  }
 
  template <typename CreateDirectoryRequestT = Model::CreateDirectoryRequest>
  void CreateDirectoryAsync(const CreateDirectoryRequestT& request, const CreateDirectoryResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::CreateDirectory, request, handler, context);
  }
 
  virtual Model::CreateFacetOutcome CreateFacet(const Model::CreateFacetRequest& request) const;
 
  template <typename CreateFacetRequestT = Model::CreateFacetRequest>
  Model::CreateFacetOutcomeCallable CreateFacetCallable(const CreateFacetRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::CreateFacet, request);
  }
 
  template <typename CreateFacetRequestT = Model::CreateFacetRequest>
  void CreateFacetAsync(const CreateFacetRequestT& request, const CreateFacetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::CreateFacet, request, handler, context);
  }
 
  virtual Model::CreateIndexOutcome CreateIndex(const Model::CreateIndexRequest& request) const;
 
  template <typename CreateIndexRequestT = Model::CreateIndexRequest>
  Model::CreateIndexOutcomeCallable CreateIndexCallable(const CreateIndexRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::CreateIndex, request);
  }
 
  template <typename CreateIndexRequestT = Model::CreateIndexRequest>
  void CreateIndexAsync(const CreateIndexRequestT& request, const CreateIndexResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::CreateIndex, request, handler, context);
  }
 
  virtual Model::CreateObjectOutcome CreateObject(const Model::CreateObjectRequest& request) const;
 
  template <typename CreateObjectRequestT = Model::CreateObjectRequest>
  Model::CreateObjectOutcomeCallable CreateObjectCallable(const CreateObjectRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::CreateObject, request);
  }
 
  template <typename CreateObjectRequestT = Model::CreateObjectRequest>
  void CreateObjectAsync(const CreateObjectRequestT& request, const CreateObjectResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::CreateObject, request, handler, context);
  }
 
  virtual Model::CreateSchemaOutcome CreateSchema(const Model::CreateSchemaRequest& request) const;
 
  template <typename CreateSchemaRequestT = Model::CreateSchemaRequest>
  Model::CreateSchemaOutcomeCallable CreateSchemaCallable(const CreateSchemaRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::CreateSchema, request);
  }
 
  template <typename CreateSchemaRequestT = Model::CreateSchemaRequest>
  void CreateSchemaAsync(const CreateSchemaRequestT& request, const CreateSchemaResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::CreateSchema, request, handler, context);
  }
 
  virtual Model::CreateTypedLinkFacetOutcome CreateTypedLinkFacet(const Model::CreateTypedLinkFacetRequest& request) const;
 
  template <typename CreateTypedLinkFacetRequestT = Model::CreateTypedLinkFacetRequest>
  Model::CreateTypedLinkFacetOutcomeCallable CreateTypedLinkFacetCallable(const CreateTypedLinkFacetRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::CreateTypedLinkFacet, request);
  }
 
  template <typename CreateTypedLinkFacetRequestT = Model::CreateTypedLinkFacetRequest>
  void CreateTypedLinkFacetAsync(const CreateTypedLinkFacetRequestT& request, const CreateTypedLinkFacetResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::CreateTypedLinkFacet, request, handler, context);
  }
 
  virtual Model::DeleteDirectoryOutcome DeleteDirectory(const Model::DeleteDirectoryRequest& request) const;
 
  template <typename DeleteDirectoryRequestT = Model::DeleteDirectoryRequest>
  Model::DeleteDirectoryOutcomeCallable DeleteDirectoryCallable(const DeleteDirectoryRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DeleteDirectory, request);
  }
 
  template <typename DeleteDirectoryRequestT = Model::DeleteDirectoryRequest>
  void DeleteDirectoryAsync(const DeleteDirectoryRequestT& request, const DeleteDirectoryResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DeleteDirectory, request, handler, context);
  }
 
  virtual Model::DeleteFacetOutcome DeleteFacet(const Model::DeleteFacetRequest& request) const;
 
  template <typename DeleteFacetRequestT = Model::DeleteFacetRequest>
  Model::DeleteFacetOutcomeCallable DeleteFacetCallable(const DeleteFacetRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DeleteFacet, request);
  }
 
  template <typename DeleteFacetRequestT = Model::DeleteFacetRequest>
  void DeleteFacetAsync(const DeleteFacetRequestT& request, const DeleteFacetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DeleteFacet, request, handler, context);
  }
 
  virtual Model::DeleteObjectOutcome DeleteObject(const Model::DeleteObjectRequest& request) const;
 
  template <typename DeleteObjectRequestT = Model::DeleteObjectRequest>
  Model::DeleteObjectOutcomeCallable DeleteObjectCallable(const DeleteObjectRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DeleteObject, request);
  }
 
  template <typename DeleteObjectRequestT = Model::DeleteObjectRequest>
  void DeleteObjectAsync(const DeleteObjectRequestT& request, const DeleteObjectResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DeleteObject, request, handler, context);
  }
 
  virtual Model::DeleteSchemaOutcome DeleteSchema(const Model::DeleteSchemaRequest& request) const;
 
  template <typename DeleteSchemaRequestT = Model::DeleteSchemaRequest>
  Model::DeleteSchemaOutcomeCallable DeleteSchemaCallable(const DeleteSchemaRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DeleteSchema, request);
  }
 
  template <typename DeleteSchemaRequestT = Model::DeleteSchemaRequest>
  void DeleteSchemaAsync(const DeleteSchemaRequestT& request, const DeleteSchemaResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DeleteSchema, request, handler, context);
  }
 
  virtual Model::DeleteTypedLinkFacetOutcome DeleteTypedLinkFacet(const Model::DeleteTypedLinkFacetRequest& request) const;
 
  template <typename DeleteTypedLinkFacetRequestT = Model::DeleteTypedLinkFacetRequest>
  Model::DeleteTypedLinkFacetOutcomeCallable DeleteTypedLinkFacetCallable(const DeleteTypedLinkFacetRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DeleteTypedLinkFacet, request);
  }
 
  template <typename DeleteTypedLinkFacetRequestT = Model::DeleteTypedLinkFacetRequest>
  void DeleteTypedLinkFacetAsync(const DeleteTypedLinkFacetRequestT& request, const DeleteTypedLinkFacetResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DeleteTypedLinkFacet, request, handler, context);
  }
 
  virtual Model::DetachFromIndexOutcome DetachFromIndex(const Model::DetachFromIndexRequest& request) const;
 
  template <typename DetachFromIndexRequestT = Model::DetachFromIndexRequest>
  Model::DetachFromIndexOutcomeCallable DetachFromIndexCallable(const DetachFromIndexRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DetachFromIndex, request);
  }
 
  template <typename DetachFromIndexRequestT = Model::DetachFromIndexRequest>
  void DetachFromIndexAsync(const DetachFromIndexRequestT& request, const DetachFromIndexResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DetachFromIndex, request, handler, context);
  }
 
  virtual Model::DetachObjectOutcome DetachObject(const Model::DetachObjectRequest& request) const;
 
  template <typename DetachObjectRequestT = Model::DetachObjectRequest>
  Model::DetachObjectOutcomeCallable DetachObjectCallable(const DetachObjectRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DetachObject, request);
  }
 
  template <typename DetachObjectRequestT = Model::DetachObjectRequest>
  void DetachObjectAsync(const DetachObjectRequestT& request, const DetachObjectResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DetachObject, request, handler, context);
  }
 
  virtual Model::DetachPolicyOutcome DetachPolicy(const Model::DetachPolicyRequest& request) const;
 
  template <typename DetachPolicyRequestT = Model::DetachPolicyRequest>
  Model::DetachPolicyOutcomeCallable DetachPolicyCallable(const DetachPolicyRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DetachPolicy, request);
  }
 
  template <typename DetachPolicyRequestT = Model::DetachPolicyRequest>
  void DetachPolicyAsync(const DetachPolicyRequestT& request, const DetachPolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DetachPolicy, request, handler, context);
  }
 
  virtual Model::DetachTypedLinkOutcome DetachTypedLink(const Model::DetachTypedLinkRequest& request) const;
 
  template <typename DetachTypedLinkRequestT = Model::DetachTypedLinkRequest>
  Model::DetachTypedLinkOutcomeCallable DetachTypedLinkCallable(const DetachTypedLinkRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DetachTypedLink, request);
  }
 
  template <typename DetachTypedLinkRequestT = Model::DetachTypedLinkRequest>
  void DetachTypedLinkAsync(const DetachTypedLinkRequestT& request, const DetachTypedLinkResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DetachTypedLink, request, handler, context);
  }
 
  virtual Model::DisableDirectoryOutcome DisableDirectory(const Model::DisableDirectoryRequest& request) const;
 
  template <typename DisableDirectoryRequestT = Model::DisableDirectoryRequest>
  Model::DisableDirectoryOutcomeCallable DisableDirectoryCallable(const DisableDirectoryRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::DisableDirectory, request);
  }
 
  template <typename DisableDirectoryRequestT = Model::DisableDirectoryRequest>
  void DisableDirectoryAsync(const DisableDirectoryRequestT& request, const DisableDirectoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::DisableDirectory, request, handler, context);
  }
 
  virtual Model::EnableDirectoryOutcome EnableDirectory(const Model::EnableDirectoryRequest& request) const;
 
  template <typename EnableDirectoryRequestT = Model::EnableDirectoryRequest>
  Model::EnableDirectoryOutcomeCallable EnableDirectoryCallable(const EnableDirectoryRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::EnableDirectory, request);
  }
 
  template <typename EnableDirectoryRequestT = Model::EnableDirectoryRequest>
  void EnableDirectoryAsync(const EnableDirectoryRequestT& request, const EnableDirectoryResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::EnableDirectory, request, handler, context);
  }
 
  virtual Model::GetAppliedSchemaVersionOutcome GetAppliedSchemaVersion(const Model::GetAppliedSchemaVersionRequest& request) const;
 
  template <typename GetAppliedSchemaVersionRequestT = Model::GetAppliedSchemaVersionRequest>
  Model::GetAppliedSchemaVersionOutcomeCallable GetAppliedSchemaVersionCallable(const GetAppliedSchemaVersionRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::GetAppliedSchemaVersion, request);
  }
 
  template <typename GetAppliedSchemaVersionRequestT = Model::GetAppliedSchemaVersionRequest>
  void GetAppliedSchemaVersionAsync(const GetAppliedSchemaVersionRequestT& request,
                                    const GetAppliedSchemaVersionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::GetAppliedSchemaVersion, request, handler, context);
  }
 
  virtual Model::GetDirectoryOutcome GetDirectory(const Model::GetDirectoryRequest& request) const;
 
  template <typename GetDirectoryRequestT = Model::GetDirectoryRequest>
  Model::GetDirectoryOutcomeCallable GetDirectoryCallable(const GetDirectoryRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::GetDirectory, request);
  }
 
  template <typename GetDirectoryRequestT = Model::GetDirectoryRequest>
  void GetDirectoryAsync(const GetDirectoryRequestT& request, const GetDirectoryResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::GetDirectory, request, handler, context);
  }
 
  virtual Model::GetFacetOutcome GetFacet(const Model::GetFacetRequest& request) const;
 
  template <typename GetFacetRequestT = Model::GetFacetRequest>
  Model::GetFacetOutcomeCallable GetFacetCallable(const GetFacetRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::GetFacet, request);
  }
 
  template <typename GetFacetRequestT = Model::GetFacetRequest>
  void GetFacetAsync(const GetFacetRequestT& request, const GetFacetResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::GetFacet, request, handler, context);
  }
 
  virtual Model::GetLinkAttributesOutcome GetLinkAttributes(const Model::GetLinkAttributesRequest& request) const;
 
  template <typename GetLinkAttributesRequestT = Model::GetLinkAttributesRequest>
  Model::GetLinkAttributesOutcomeCallable GetLinkAttributesCallable(const GetLinkAttributesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::GetLinkAttributes, request);
  }
 
  template <typename GetLinkAttributesRequestT = Model::GetLinkAttributesRequest>
  void GetLinkAttributesAsync(const GetLinkAttributesRequestT& request, const GetLinkAttributesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::GetLinkAttributes, request, handler, context);
  }
 
  virtual Model::GetObjectAttributesOutcome GetObjectAttributes(const Model::GetObjectAttributesRequest& request) const;
 
  template <typename GetObjectAttributesRequestT = Model::GetObjectAttributesRequest>
  Model::GetObjectAttributesOutcomeCallable GetObjectAttributesCallable(const GetObjectAttributesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::GetObjectAttributes, request);
  }
 
  template <typename GetObjectAttributesRequestT = Model::GetObjectAttributesRequest>
  void GetObjectAttributesAsync(const GetObjectAttributesRequestT& request, const GetObjectAttributesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::GetObjectAttributes, request, handler, context);
  }
 
  virtual Model::GetObjectInformationOutcome GetObjectInformation(const Model::GetObjectInformationRequest& request) const;
 
  template <typename GetObjectInformationRequestT = Model::GetObjectInformationRequest>
  Model::GetObjectInformationOutcomeCallable GetObjectInformationCallable(const GetObjectInformationRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::GetObjectInformation, request);
  }
 
  template <typename GetObjectInformationRequestT = Model::GetObjectInformationRequest>
  void GetObjectInformationAsync(const GetObjectInformationRequestT& request, const GetObjectInformationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::GetObjectInformation, request, handler, context);
  }
 
  virtual Model::GetSchemaAsJsonOutcome GetSchemaAsJson(const Model::GetSchemaAsJsonRequest& request) const;
 
  template <typename GetSchemaAsJsonRequestT = Model::GetSchemaAsJsonRequest>
  Model::GetSchemaAsJsonOutcomeCallable GetSchemaAsJsonCallable(const GetSchemaAsJsonRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::GetSchemaAsJson, request);
  }
 
  template <typename GetSchemaAsJsonRequestT = Model::GetSchemaAsJsonRequest>
  void GetSchemaAsJsonAsync(const GetSchemaAsJsonRequestT& request, const GetSchemaAsJsonResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::GetSchemaAsJson, request, handler, context);
  }
 
  virtual Model::GetTypedLinkFacetInformationOutcome GetTypedLinkFacetInformation(
      const Model::GetTypedLinkFacetInformationRequest& request) const;
 
  template <typename GetTypedLinkFacetInformationRequestT = Model::GetTypedLinkFacetInformationRequest>
  Model::GetTypedLinkFacetInformationOutcomeCallable GetTypedLinkFacetInformationCallable(
      const GetTypedLinkFacetInformationRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::GetTypedLinkFacetInformation, request);
  }
 
  template <typename GetTypedLinkFacetInformationRequestT = Model::GetTypedLinkFacetInformationRequest>
  void GetTypedLinkFacetInformationAsync(const GetTypedLinkFacetInformationRequestT& request,
                                         const GetTypedLinkFacetInformationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::GetTypedLinkFacetInformation, request, handler, context);
  }
 
  virtual Model::ListAppliedSchemaArnsOutcome ListAppliedSchemaArns(const Model::ListAppliedSchemaArnsRequest& request) const;
 
  template <typename ListAppliedSchemaArnsRequestT = Model::ListAppliedSchemaArnsRequest>
  Model::ListAppliedSchemaArnsOutcomeCallable ListAppliedSchemaArnsCallable(const ListAppliedSchemaArnsRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListAppliedSchemaArns, request);
  }
 
  template <typename ListAppliedSchemaArnsRequestT = Model::ListAppliedSchemaArnsRequest>
  void ListAppliedSchemaArnsAsync(const ListAppliedSchemaArnsRequestT& request, const ListAppliedSchemaArnsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListAppliedSchemaArns, request, handler, context);
  }
 
  virtual Model::ListAttachedIndicesOutcome ListAttachedIndices(const Model::ListAttachedIndicesRequest& request) const;
 
  template <typename ListAttachedIndicesRequestT = Model::ListAttachedIndicesRequest>
  Model::ListAttachedIndicesOutcomeCallable ListAttachedIndicesCallable(const ListAttachedIndicesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListAttachedIndices, request);
  }
 
  template <typename ListAttachedIndicesRequestT = Model::ListAttachedIndicesRequest>
  void ListAttachedIndicesAsync(const ListAttachedIndicesRequestT& request, const ListAttachedIndicesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListAttachedIndices, request, handler, context);
  }
 
  virtual Model::ListDevelopmentSchemaArnsOutcome ListDevelopmentSchemaArns(
      const Model::ListDevelopmentSchemaArnsRequest& request = {}) const;
 
  template <typename ListDevelopmentSchemaArnsRequestT = Model::ListDevelopmentSchemaArnsRequest>
  Model::ListDevelopmentSchemaArnsOutcomeCallable ListDevelopmentSchemaArnsCallable(
      const ListDevelopmentSchemaArnsRequestT& request = {}) const {
    return SubmitCallable(&CloudDirectoryClient::ListDevelopmentSchemaArns, request);
  }
 
  template <typename ListDevelopmentSchemaArnsRequestT = Model::ListDevelopmentSchemaArnsRequest>
  void ListDevelopmentSchemaArnsAsync(const ListDevelopmentSchemaArnsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListDevelopmentSchemaArnsRequestT& request = {}) const {
    return SubmitAsync(&CloudDirectoryClient::ListDevelopmentSchemaArns, request, handler, context);
  }
 
  virtual Model::ListDirectoriesOutcome ListDirectories(const Model::ListDirectoriesRequest& request = {}) const;
 
  template <typename ListDirectoriesRequestT = Model::ListDirectoriesRequest>
  Model::ListDirectoriesOutcomeCallable ListDirectoriesCallable(const ListDirectoriesRequestT& request = {}) const {
    return SubmitCallable(&CloudDirectoryClient::ListDirectories, request);
  }
 
  template <typename ListDirectoriesRequestT = Model::ListDirectoriesRequest>
  void ListDirectoriesAsync(const ListDirectoriesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListDirectoriesRequestT& request = {}) const {
    return SubmitAsync(&CloudDirectoryClient::ListDirectories, request, handler, context);
  }
 
  virtual Model::ListFacetAttributesOutcome ListFacetAttributes(const Model::ListFacetAttributesRequest& request) const;
 
  template <typename ListFacetAttributesRequestT = Model::ListFacetAttributesRequest>
  Model::ListFacetAttributesOutcomeCallable ListFacetAttributesCallable(const ListFacetAttributesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListFacetAttributes, request);
  }
 
  template <typename ListFacetAttributesRequestT = Model::ListFacetAttributesRequest>
  void ListFacetAttributesAsync(const ListFacetAttributesRequestT& request, const ListFacetAttributesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListFacetAttributes, request, handler, context);
  }
 
  virtual Model::ListFacetNamesOutcome ListFacetNames(const Model::ListFacetNamesRequest& request) const;
 
  template <typename ListFacetNamesRequestT = Model::ListFacetNamesRequest>
  Model::ListFacetNamesOutcomeCallable ListFacetNamesCallable(const ListFacetNamesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListFacetNames, request);
  }
 
  template <typename ListFacetNamesRequestT = Model::ListFacetNamesRequest>
  void ListFacetNamesAsync(const ListFacetNamesRequestT& request, const ListFacetNamesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListFacetNames, request, handler, context);
  }
 
  virtual Model::ListIncomingTypedLinksOutcome ListIncomingTypedLinks(const Model::ListIncomingTypedLinksRequest& request) const;
 
  template <typename ListIncomingTypedLinksRequestT = Model::ListIncomingTypedLinksRequest>
  Model::ListIncomingTypedLinksOutcomeCallable ListIncomingTypedLinksCallable(const ListIncomingTypedLinksRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListIncomingTypedLinks, request);
  }
 
  template <typename ListIncomingTypedLinksRequestT = Model::ListIncomingTypedLinksRequest>
  void ListIncomingTypedLinksAsync(const ListIncomingTypedLinksRequestT& request,
                                   const ListIncomingTypedLinksResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListIncomingTypedLinks, request, handler, context);
  }
 
  virtual Model::ListIndexOutcome ListIndex(const Model::ListIndexRequest& request) const;
 
  template <typename ListIndexRequestT = Model::ListIndexRequest>
  Model::ListIndexOutcomeCallable ListIndexCallable(const ListIndexRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListIndex, request);
  }
 
  template <typename ListIndexRequestT = Model::ListIndexRequest>
  void ListIndexAsync(const ListIndexRequestT& request, const ListIndexResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListIndex, request, handler, context);
  }
 
  virtual Model::ListManagedSchemaArnsOutcome ListManagedSchemaArns(const Model::ListManagedSchemaArnsRequest& request = {}) const;
 
  template <typename ListManagedSchemaArnsRequestT = Model::ListManagedSchemaArnsRequest>
  Model::ListManagedSchemaArnsOutcomeCallable ListManagedSchemaArnsCallable(const ListManagedSchemaArnsRequestT& request = {}) const {
    return SubmitCallable(&CloudDirectoryClient::ListManagedSchemaArns, request);
  }
 
  template <typename ListManagedSchemaArnsRequestT = Model::ListManagedSchemaArnsRequest>
  void ListManagedSchemaArnsAsync(const ListManagedSchemaArnsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListManagedSchemaArnsRequestT& request = {}) const {
    return SubmitAsync(&CloudDirectoryClient::ListManagedSchemaArns, request, handler, context);
  }
 
  virtual Model::ListObjectAttributesOutcome ListObjectAttributes(const Model::ListObjectAttributesRequest& request) const;
 
  template <typename ListObjectAttributesRequestT = Model::ListObjectAttributesRequest>
  Model::ListObjectAttributesOutcomeCallable ListObjectAttributesCallable(const ListObjectAttributesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListObjectAttributes, request);
  }
 
  template <typename ListObjectAttributesRequestT = Model::ListObjectAttributesRequest>
  void ListObjectAttributesAsync(const ListObjectAttributesRequestT& request, const ListObjectAttributesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListObjectAttributes, request, handler, context);
  }
 
  virtual Model::ListObjectChildrenOutcome ListObjectChildren(const Model::ListObjectChildrenRequest& request) const;
 
  template <typename ListObjectChildrenRequestT = Model::ListObjectChildrenRequest>
  Model::ListObjectChildrenOutcomeCallable ListObjectChildrenCallable(const ListObjectChildrenRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListObjectChildren, request);
  }
 
  template <typename ListObjectChildrenRequestT = Model::ListObjectChildrenRequest>
  void ListObjectChildrenAsync(const ListObjectChildrenRequestT& request, const ListObjectChildrenResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListObjectChildren, request, handler, context);
  }
 
  virtual Model::ListObjectParentPathsOutcome ListObjectParentPaths(const Model::ListObjectParentPathsRequest& request) const;
 
  template <typename ListObjectParentPathsRequestT = Model::ListObjectParentPathsRequest>
  Model::ListObjectParentPathsOutcomeCallable ListObjectParentPathsCallable(const ListObjectParentPathsRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListObjectParentPaths, request);
  }
 
  template <typename ListObjectParentPathsRequestT = Model::ListObjectParentPathsRequest>
  void ListObjectParentPathsAsync(const ListObjectParentPathsRequestT& request, const ListObjectParentPathsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListObjectParentPaths, request, handler, context);
  }
 
  virtual Model::ListObjectParentsOutcome ListObjectParents(const Model::ListObjectParentsRequest& request) const;
 
  template <typename ListObjectParentsRequestT = Model::ListObjectParentsRequest>
  Model::ListObjectParentsOutcomeCallable ListObjectParentsCallable(const ListObjectParentsRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListObjectParents, request);
  }
 
  template <typename ListObjectParentsRequestT = Model::ListObjectParentsRequest>
  void ListObjectParentsAsync(const ListObjectParentsRequestT& request, const ListObjectParentsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListObjectParents, request, handler, context);
  }
 
  virtual Model::ListObjectPoliciesOutcome ListObjectPolicies(const Model::ListObjectPoliciesRequest& request) const;
 
  template <typename ListObjectPoliciesRequestT = Model::ListObjectPoliciesRequest>
  Model::ListObjectPoliciesOutcomeCallable ListObjectPoliciesCallable(const ListObjectPoliciesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListObjectPolicies, request);
  }
 
  template <typename ListObjectPoliciesRequestT = Model::ListObjectPoliciesRequest>
  void ListObjectPoliciesAsync(const ListObjectPoliciesRequestT& request, const ListObjectPoliciesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListObjectPolicies, request, handler, context);
  }
 
  virtual Model::ListOutgoingTypedLinksOutcome ListOutgoingTypedLinks(const Model::ListOutgoingTypedLinksRequest& request) const;
 
  template <typename ListOutgoingTypedLinksRequestT = Model::ListOutgoingTypedLinksRequest>
  Model::ListOutgoingTypedLinksOutcomeCallable ListOutgoingTypedLinksCallable(const ListOutgoingTypedLinksRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListOutgoingTypedLinks, request);
  }
 
  template <typename ListOutgoingTypedLinksRequestT = Model::ListOutgoingTypedLinksRequest>
  void ListOutgoingTypedLinksAsync(const ListOutgoingTypedLinksRequestT& request,
                                   const ListOutgoingTypedLinksResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListOutgoingTypedLinks, request, handler, context);
  }
 
  virtual Model::ListPolicyAttachmentsOutcome ListPolicyAttachments(const Model::ListPolicyAttachmentsRequest& request) const;
 
  template <typename ListPolicyAttachmentsRequestT = Model::ListPolicyAttachmentsRequest>
  Model::ListPolicyAttachmentsOutcomeCallable ListPolicyAttachmentsCallable(const ListPolicyAttachmentsRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListPolicyAttachments, request);
  }
 
  template <typename ListPolicyAttachmentsRequestT = Model::ListPolicyAttachmentsRequest>
  void ListPolicyAttachmentsAsync(const ListPolicyAttachmentsRequestT& request, const ListPolicyAttachmentsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListPolicyAttachments, request, handler, context);
  }
 
  virtual Model::ListPublishedSchemaArnsOutcome ListPublishedSchemaArns(const Model::ListPublishedSchemaArnsRequest& request = {}) const;
 
  template <typename ListPublishedSchemaArnsRequestT = Model::ListPublishedSchemaArnsRequest>
  Model::ListPublishedSchemaArnsOutcomeCallable ListPublishedSchemaArnsCallable(const ListPublishedSchemaArnsRequestT& request = {}) const {
    return SubmitCallable(&CloudDirectoryClient::ListPublishedSchemaArns, request);
  }
 
  template <typename ListPublishedSchemaArnsRequestT = Model::ListPublishedSchemaArnsRequest>
  void ListPublishedSchemaArnsAsync(const ListPublishedSchemaArnsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListPublishedSchemaArnsRequestT& request = {}) const {
    return SubmitAsync(&CloudDirectoryClient::ListPublishedSchemaArns, 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(&CloudDirectoryClient::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(&CloudDirectoryClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTypedLinkFacetAttributesOutcome ListTypedLinkFacetAttributes(
      const Model::ListTypedLinkFacetAttributesRequest& request) const;
 
  template <typename ListTypedLinkFacetAttributesRequestT = Model::ListTypedLinkFacetAttributesRequest>
  Model::ListTypedLinkFacetAttributesOutcomeCallable ListTypedLinkFacetAttributesCallable(
      const ListTypedLinkFacetAttributesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListTypedLinkFacetAttributes, request);
  }
 
  template <typename ListTypedLinkFacetAttributesRequestT = Model::ListTypedLinkFacetAttributesRequest>
  void ListTypedLinkFacetAttributesAsync(const ListTypedLinkFacetAttributesRequestT& request,
                                         const ListTypedLinkFacetAttributesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListTypedLinkFacetAttributes, request, handler, context);
  }
 
  virtual Model::ListTypedLinkFacetNamesOutcome ListTypedLinkFacetNames(const Model::ListTypedLinkFacetNamesRequest& request) const;
 
  template <typename ListTypedLinkFacetNamesRequestT = Model::ListTypedLinkFacetNamesRequest>
  Model::ListTypedLinkFacetNamesOutcomeCallable ListTypedLinkFacetNamesCallable(const ListTypedLinkFacetNamesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::ListTypedLinkFacetNames, request);
  }
 
  template <typename ListTypedLinkFacetNamesRequestT = Model::ListTypedLinkFacetNamesRequest>
  void ListTypedLinkFacetNamesAsync(const ListTypedLinkFacetNamesRequestT& request,
                                    const ListTypedLinkFacetNamesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::ListTypedLinkFacetNames, request, handler, context);
  }
 
  virtual Model::LookupPolicyOutcome LookupPolicy(const Model::LookupPolicyRequest& request) const;
 
  template <typename LookupPolicyRequestT = Model::LookupPolicyRequest>
  Model::LookupPolicyOutcomeCallable LookupPolicyCallable(const LookupPolicyRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::LookupPolicy, request);
  }
 
  template <typename LookupPolicyRequestT = Model::LookupPolicyRequest>
  void LookupPolicyAsync(const LookupPolicyRequestT& request, const LookupPolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::LookupPolicy, request, handler, context);
  }
 
  virtual Model::PublishSchemaOutcome PublishSchema(const Model::PublishSchemaRequest& request) const;
 
  template <typename PublishSchemaRequestT = Model::PublishSchemaRequest>
  Model::PublishSchemaOutcomeCallable PublishSchemaCallable(const PublishSchemaRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::PublishSchema, request);
  }
 
  template <typename PublishSchemaRequestT = Model::PublishSchemaRequest>
  void PublishSchemaAsync(const PublishSchemaRequestT& request, const PublishSchemaResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::PublishSchema, request, handler, context);
  }
 
  virtual Model::PutSchemaFromJsonOutcome PutSchemaFromJson(const Model::PutSchemaFromJsonRequest& request) const;
 
  template <typename PutSchemaFromJsonRequestT = Model::PutSchemaFromJsonRequest>
  Model::PutSchemaFromJsonOutcomeCallable PutSchemaFromJsonCallable(const PutSchemaFromJsonRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::PutSchemaFromJson, request);
  }
 
  template <typename PutSchemaFromJsonRequestT = Model::PutSchemaFromJsonRequest>
  void PutSchemaFromJsonAsync(const PutSchemaFromJsonRequestT& request, const PutSchemaFromJsonResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::PutSchemaFromJson, request, handler, context);
  }
 
  virtual Model::RemoveFacetFromObjectOutcome RemoveFacetFromObject(const Model::RemoveFacetFromObjectRequest& request) const;
 
  template <typename RemoveFacetFromObjectRequestT = Model::RemoveFacetFromObjectRequest>
  Model::RemoveFacetFromObjectOutcomeCallable RemoveFacetFromObjectCallable(const RemoveFacetFromObjectRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::RemoveFacetFromObject, request);
  }
 
  template <typename RemoveFacetFromObjectRequestT = Model::RemoveFacetFromObjectRequest>
  void RemoveFacetFromObjectAsync(const RemoveFacetFromObjectRequestT& request, const RemoveFacetFromObjectResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::RemoveFacetFromObject, 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(&CloudDirectoryClient::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(&CloudDirectoryClient::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(&CloudDirectoryClient::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(&CloudDirectoryClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateFacetOutcome UpdateFacet(const Model::UpdateFacetRequest& request) const;
 
  template <typename UpdateFacetRequestT = Model::UpdateFacetRequest>
  Model::UpdateFacetOutcomeCallable UpdateFacetCallable(const UpdateFacetRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::UpdateFacet, request);
  }
 
  template <typename UpdateFacetRequestT = Model::UpdateFacetRequest>
  void UpdateFacetAsync(const UpdateFacetRequestT& request, const UpdateFacetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::UpdateFacet, request, handler, context);
  }
 
  virtual Model::UpdateLinkAttributesOutcome UpdateLinkAttributes(const Model::UpdateLinkAttributesRequest& request) const;
 
  template <typename UpdateLinkAttributesRequestT = Model::UpdateLinkAttributesRequest>
  Model::UpdateLinkAttributesOutcomeCallable UpdateLinkAttributesCallable(const UpdateLinkAttributesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::UpdateLinkAttributes, request);
  }
 
  template <typename UpdateLinkAttributesRequestT = Model::UpdateLinkAttributesRequest>
  void UpdateLinkAttributesAsync(const UpdateLinkAttributesRequestT& request, const UpdateLinkAttributesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::UpdateLinkAttributes, request, handler, context);
  }
 
  virtual Model::UpdateObjectAttributesOutcome UpdateObjectAttributes(const Model::UpdateObjectAttributesRequest& request) const;
 
  template <typename UpdateObjectAttributesRequestT = Model::UpdateObjectAttributesRequest>
  Model::UpdateObjectAttributesOutcomeCallable UpdateObjectAttributesCallable(const UpdateObjectAttributesRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::UpdateObjectAttributes, request);
  }
 
  template <typename UpdateObjectAttributesRequestT = Model::UpdateObjectAttributesRequest>
  void UpdateObjectAttributesAsync(const UpdateObjectAttributesRequestT& request,
                                   const UpdateObjectAttributesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::UpdateObjectAttributes, request, handler, context);
  }
 
  virtual Model::UpdateSchemaOutcome UpdateSchema(const Model::UpdateSchemaRequest& request) const;
 
  template <typename UpdateSchemaRequestT = Model::UpdateSchemaRequest>
  Model::UpdateSchemaOutcomeCallable UpdateSchemaCallable(const UpdateSchemaRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::UpdateSchema, request);
  }
 
  template <typename UpdateSchemaRequestT = Model::UpdateSchemaRequest>
  void UpdateSchemaAsync(const UpdateSchemaRequestT& request, const UpdateSchemaResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::UpdateSchema, request, handler, context);
  }
 
  virtual Model::UpdateTypedLinkFacetOutcome UpdateTypedLinkFacet(const Model::UpdateTypedLinkFacetRequest& request) const;
 
  template <typename UpdateTypedLinkFacetRequestT = Model::UpdateTypedLinkFacetRequest>
  Model::UpdateTypedLinkFacetOutcomeCallable UpdateTypedLinkFacetCallable(const UpdateTypedLinkFacetRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::UpdateTypedLinkFacet, request);
  }
 
  template <typename UpdateTypedLinkFacetRequestT = Model::UpdateTypedLinkFacetRequest>
  void UpdateTypedLinkFacetAsync(const UpdateTypedLinkFacetRequestT& request, const UpdateTypedLinkFacetResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::UpdateTypedLinkFacet, request, handler, context);
  }
 
  virtual Model::UpgradeAppliedSchemaOutcome UpgradeAppliedSchema(const Model::UpgradeAppliedSchemaRequest& request) const;
 
  template <typename UpgradeAppliedSchemaRequestT = Model::UpgradeAppliedSchemaRequest>
  Model::UpgradeAppliedSchemaOutcomeCallable UpgradeAppliedSchemaCallable(const UpgradeAppliedSchemaRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::UpgradeAppliedSchema, request);
  }
 
  template <typename UpgradeAppliedSchemaRequestT = Model::UpgradeAppliedSchemaRequest>
  void UpgradeAppliedSchemaAsync(const UpgradeAppliedSchemaRequestT& request, const UpgradeAppliedSchemaResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::UpgradeAppliedSchema, request, handler, context);
  }
 
  virtual Model::UpgradePublishedSchemaOutcome UpgradePublishedSchema(const Model::UpgradePublishedSchemaRequest& request) const;
 
  template <typename UpgradePublishedSchemaRequestT = Model::UpgradePublishedSchemaRequest>
  Model::UpgradePublishedSchemaOutcomeCallable UpgradePublishedSchemaCallable(const UpgradePublishedSchemaRequestT& request) const {
    return SubmitCallable(&CloudDirectoryClient::UpgradePublishedSchema, request);
  }
 
  template <typename UpgradePublishedSchemaRequestT = Model::UpgradePublishedSchemaRequest>
  void UpgradePublishedSchemaAsync(const UpgradePublishedSchemaRequestT& request,
                                   const UpgradePublishedSchemaResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudDirectoryClient::UpgradePublishedSchema, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CloudDirectoryEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudDirectoryClient>;
  void init(const CloudDirectoryClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CloudDirectoryError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  CloudDirectoryClientConfiguration m_clientConfiguration;
  std::shared_ptr<CloudDirectoryEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CloudDirectory
}  // namespace Aws