CloudDirectoryClient.h

 
#pragma once
#include <aws/clouddirectory/CloudDirectory_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/clouddirectory/CloudDirectoryServiceClientModel.h>
 
namespace Aws
{
namespace CloudDirectory
{
  class AWS_CLOUDDIRECTORY_API CloudDirectoryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CloudDirectoryEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudDirectoryClient>;
      void init(const CloudDirectoryClientConfiguration& clientConfiguration);
 
      CloudDirectoryClientConfiguration m_clientConfiguration;
      std::shared_ptr<CloudDirectoryEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CloudDirectory
} // namespace Aws