✨feat(hos_client_create, hos_client_destory): 多次调用destory不会导致重复释放

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/ServiceDiscoveryClient.cpp

@@ -0,0 +1,758 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/utils/Outcome.h>
+#include <aws/core/auth/AWSAuthSigner.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/core/client/RetryStrategy.h>
+#include <aws/core/http/HttpClient.h>
+#include <aws/core/http/HttpResponse.h>
+#include <aws/core/http/HttpClientFactory.h>
+#include <aws/core/auth/AWSCredentialsProviderChain.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/threading/Executor.h>
+#include <aws/core/utils/DNS.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <aws/servicediscovery/ServiceDiscoveryClient.h>
+#include <aws/servicediscovery/ServiceDiscoveryEndpoint.h>
+#include <aws/servicediscovery/ServiceDiscoveryErrorMarshaller.h>
+#include <aws/servicediscovery/model/CreateHttpNamespaceRequest.h>
+#include <aws/servicediscovery/model/CreatePrivateDnsNamespaceRequest.h>
+#include <aws/servicediscovery/model/CreatePublicDnsNamespaceRequest.h>
+#include <aws/servicediscovery/model/CreateServiceRequest.h>
+#include <aws/servicediscovery/model/DeleteNamespaceRequest.h>
+#include <aws/servicediscovery/model/DeleteServiceRequest.h>
+#include <aws/servicediscovery/model/DeregisterInstanceRequest.h>
+#include <aws/servicediscovery/model/DiscoverInstancesRequest.h>
+#include <aws/servicediscovery/model/GetInstanceRequest.h>
+#include <aws/servicediscovery/model/GetInstancesHealthStatusRequest.h>
+#include <aws/servicediscovery/model/GetNamespaceRequest.h>
+#include <aws/servicediscovery/model/GetOperationRequest.h>
+#include <aws/servicediscovery/model/GetServiceRequest.h>
+#include <aws/servicediscovery/model/ListInstancesRequest.h>
+#include <aws/servicediscovery/model/ListNamespacesRequest.h>
+#include <aws/servicediscovery/model/ListOperationsRequest.h>
+#include <aws/servicediscovery/model/ListServicesRequest.h>
+#include <aws/servicediscovery/model/ListTagsForResourceRequest.h>
+#include <aws/servicediscovery/model/RegisterInstanceRequest.h>
+#include <aws/servicediscovery/model/TagResourceRequest.h>
+#include <aws/servicediscovery/model/UntagResourceRequest.h>
+#include <aws/servicediscovery/model/UpdateInstanceCustomHealthStatusRequest.h>
+#include <aws/servicediscovery/model/UpdateServiceRequest.h>
+
+using namespace Aws;
+using namespace Aws::Auth;
+using namespace Aws::Client;
+using namespace Aws::ServiceDiscovery;
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Http;
+using namespace Aws::Utils::Json;
+
+static const char* SERVICE_NAME = "servicediscovery";
+static const char* ALLOCATION_TAG = "ServiceDiscoveryClient";
+
+
+ServiceDiscoveryClient::ServiceDiscoveryClient(const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
+        SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<ServiceDiscoveryErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+ServiceDiscoveryClient::ServiceDiscoveryClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
+         SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<ServiceDiscoveryErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+ServiceDiscoveryClient::ServiceDiscoveryClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
+  const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
+         SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<ServiceDiscoveryErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+ServiceDiscoveryClient::~ServiceDiscoveryClient()
+{
+}
+
+void ServiceDiscoveryClient::init(const ClientConfiguration& config)
+{
+  SetServiceClientName("ServiceDiscovery");
+  m_configScheme = SchemeMapper::ToString(config.scheme);
+  m_scheme = m_configScheme;
+  if (config.endpointOverride.empty())
+  {
+      m_baseUri = ServiceDiscoveryEndpoint::ForRegion(config.region, config.useDualStack);
+  }
+  else
+  {
+      OverrideEndpoint(config.endpointOverride);
+  }
+  m_enableHostPrefixInjection = config.enableHostPrefixInjection;
+}
+
+void ServiceDiscoveryClient::OverrideEndpoint(const Aws::String& endpoint)
+{
+  if (endpoint.compare(0, 7, "http://") == 0)
+  {
+      m_scheme = "http";
+      m_baseUri = endpoint.substr(7);
+  }
+  else if (endpoint.compare(0, 8, "https://") == 0)
+  {
+      m_scheme = "https";
+      m_baseUri = endpoint.substr(8);
+  }
+  else
+  {
+      m_scheme = m_configScheme;
+      m_baseUri = endpoint;
+  }
+}
+
+CreateHttpNamespaceOutcome ServiceDiscoveryClient::CreateHttpNamespace(const CreateHttpNamespaceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateHttpNamespaceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+CreateHttpNamespaceOutcomeCallable ServiceDiscoveryClient::CreateHttpNamespaceCallable(const CreateHttpNamespaceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateHttpNamespaceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateHttpNamespace(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::CreateHttpNamespaceAsync(const CreateHttpNamespaceRequest& request, const CreateHttpNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateHttpNamespaceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::CreateHttpNamespaceAsyncHelper(const CreateHttpNamespaceRequest& request, const CreateHttpNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateHttpNamespace(request), context);
+}
+
+CreatePrivateDnsNamespaceOutcome ServiceDiscoveryClient::CreatePrivateDnsNamespace(const CreatePrivateDnsNamespaceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreatePrivateDnsNamespaceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+CreatePrivateDnsNamespaceOutcomeCallable ServiceDiscoveryClient::CreatePrivateDnsNamespaceCallable(const CreatePrivateDnsNamespaceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreatePrivateDnsNamespaceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreatePrivateDnsNamespace(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::CreatePrivateDnsNamespaceAsync(const CreatePrivateDnsNamespaceRequest& request, const CreatePrivateDnsNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreatePrivateDnsNamespaceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::CreatePrivateDnsNamespaceAsyncHelper(const CreatePrivateDnsNamespaceRequest& request, const CreatePrivateDnsNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreatePrivateDnsNamespace(request), context);
+}
+
+CreatePublicDnsNamespaceOutcome ServiceDiscoveryClient::CreatePublicDnsNamespace(const CreatePublicDnsNamespaceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreatePublicDnsNamespaceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+CreatePublicDnsNamespaceOutcomeCallable ServiceDiscoveryClient::CreatePublicDnsNamespaceCallable(const CreatePublicDnsNamespaceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreatePublicDnsNamespaceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreatePublicDnsNamespace(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::CreatePublicDnsNamespaceAsync(const CreatePublicDnsNamespaceRequest& request, const CreatePublicDnsNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreatePublicDnsNamespaceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::CreatePublicDnsNamespaceAsyncHelper(const CreatePublicDnsNamespaceRequest& request, const CreatePublicDnsNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreatePublicDnsNamespace(request), context);
+}
+
+CreateServiceOutcome ServiceDiscoveryClient::CreateService(const CreateServiceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+CreateServiceOutcomeCallable ServiceDiscoveryClient::CreateServiceCallable(const CreateServiceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateService(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::CreateServiceAsync(const CreateServiceRequest& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateServiceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::CreateServiceAsyncHelper(const CreateServiceRequest& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateService(request), context);
+}
+
+DeleteNamespaceOutcome ServiceDiscoveryClient::DeleteNamespace(const DeleteNamespaceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteNamespaceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DeleteNamespaceOutcomeCallable ServiceDiscoveryClient::DeleteNamespaceCallable(const DeleteNamespaceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteNamespaceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteNamespace(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::DeleteNamespaceAsync(const DeleteNamespaceRequest& request, const DeleteNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteNamespaceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::DeleteNamespaceAsyncHelper(const DeleteNamespaceRequest& request, const DeleteNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteNamespace(request), context);
+}
+
+DeleteServiceOutcome ServiceDiscoveryClient::DeleteService(const DeleteServiceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DeleteServiceOutcomeCallable ServiceDiscoveryClient::DeleteServiceCallable(const DeleteServiceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteService(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::DeleteServiceAsync(const DeleteServiceRequest& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteServiceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::DeleteServiceAsyncHelper(const DeleteServiceRequest& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteService(request), context);
+}
+
+DeregisterInstanceOutcome ServiceDiscoveryClient::DeregisterInstance(const DeregisterInstanceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeregisterInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DeregisterInstanceOutcomeCallable ServiceDiscoveryClient::DeregisterInstanceCallable(const DeregisterInstanceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeregisterInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeregisterInstance(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::DeregisterInstanceAsync(const DeregisterInstanceRequest& request, const DeregisterInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeregisterInstanceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::DeregisterInstanceAsyncHelper(const DeregisterInstanceRequest& request, const DeregisterInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeregisterInstance(request), context);
+}
+
+DiscoverInstancesOutcome ServiceDiscoveryClient::DiscoverInstances(const DiscoverInstancesRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  if (m_enableHostPrefixInjection)
+  {
+    uri.SetAuthority("data-" + uri.GetAuthority());
+    if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
+    {
+      AWS_LOGSTREAM_ERROR("DiscoverInstances", "Invalid DNS host: " << uri.GetAuthority());
+      return DiscoverInstancesOutcome(Aws::Client::AWSError<ServiceDiscoveryErrors>(ServiceDiscoveryErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
+    }
+  }
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DiscoverInstancesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DiscoverInstancesOutcomeCallable ServiceDiscoveryClient::DiscoverInstancesCallable(const DiscoverInstancesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DiscoverInstancesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DiscoverInstances(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::DiscoverInstancesAsync(const DiscoverInstancesRequest& request, const DiscoverInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DiscoverInstancesAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::DiscoverInstancesAsyncHelper(const DiscoverInstancesRequest& request, const DiscoverInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DiscoverInstances(request), context);
+}
+
+GetInstanceOutcome ServiceDiscoveryClient::GetInstance(const GetInstanceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetInstanceOutcomeCallable ServiceDiscoveryClient::GetInstanceCallable(const GetInstanceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetInstance(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::GetInstanceAsync(const GetInstanceRequest& request, const GetInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetInstanceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::GetInstanceAsyncHelper(const GetInstanceRequest& request, const GetInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetInstance(request), context);
+}
+
+GetInstancesHealthStatusOutcome ServiceDiscoveryClient::GetInstancesHealthStatus(const GetInstancesHealthStatusRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetInstancesHealthStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetInstancesHealthStatusOutcomeCallable ServiceDiscoveryClient::GetInstancesHealthStatusCallable(const GetInstancesHealthStatusRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetInstancesHealthStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetInstancesHealthStatus(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::GetInstancesHealthStatusAsync(const GetInstancesHealthStatusRequest& request, const GetInstancesHealthStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetInstancesHealthStatusAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::GetInstancesHealthStatusAsyncHelper(const GetInstancesHealthStatusRequest& request, const GetInstancesHealthStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetInstancesHealthStatus(request), context);
+}
+
+GetNamespaceOutcome ServiceDiscoveryClient::GetNamespace(const GetNamespaceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetNamespaceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetNamespaceOutcomeCallable ServiceDiscoveryClient::GetNamespaceCallable(const GetNamespaceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetNamespaceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetNamespace(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::GetNamespaceAsync(const GetNamespaceRequest& request, const GetNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetNamespaceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::GetNamespaceAsyncHelper(const GetNamespaceRequest& request, const GetNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetNamespace(request), context);
+}
+
+GetOperationOutcome ServiceDiscoveryClient::GetOperation(const GetOperationRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetOperationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetOperationOutcomeCallable ServiceDiscoveryClient::GetOperationCallable(const GetOperationRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetOperationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetOperation(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::GetOperationAsync(const GetOperationRequest& request, const GetOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetOperationAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::GetOperationAsyncHelper(const GetOperationRequest& request, const GetOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetOperation(request), context);
+}
+
+GetServiceOutcome ServiceDiscoveryClient::GetService(const GetServiceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetServiceOutcomeCallable ServiceDiscoveryClient::GetServiceCallable(const GetServiceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetService(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::GetServiceAsync(const GetServiceRequest& request, const GetServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetServiceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::GetServiceAsyncHelper(const GetServiceRequest& request, const GetServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetService(request), context);
+}
+
+ListInstancesOutcome ServiceDiscoveryClient::ListInstances(const ListInstancesRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListInstancesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListInstancesOutcomeCallable ServiceDiscoveryClient::ListInstancesCallable(const ListInstancesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListInstancesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListInstances(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::ListInstancesAsync(const ListInstancesRequest& request, const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListInstancesAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::ListInstancesAsyncHelper(const ListInstancesRequest& request, const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListInstances(request), context);
+}
+
+ListNamespacesOutcome ServiceDiscoveryClient::ListNamespaces(const ListNamespacesRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListNamespacesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListNamespacesOutcomeCallable ServiceDiscoveryClient::ListNamespacesCallable(const ListNamespacesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListNamespacesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListNamespaces(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::ListNamespacesAsync(const ListNamespacesRequest& request, const ListNamespacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListNamespacesAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::ListNamespacesAsyncHelper(const ListNamespacesRequest& request, const ListNamespacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListNamespaces(request), context);
+}
+
+ListOperationsOutcome ServiceDiscoveryClient::ListOperations(const ListOperationsRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListOperationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListOperationsOutcomeCallable ServiceDiscoveryClient::ListOperationsCallable(const ListOperationsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListOperationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListOperations(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::ListOperationsAsync(const ListOperationsRequest& request, const ListOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListOperationsAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::ListOperationsAsyncHelper(const ListOperationsRequest& request, const ListOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListOperations(request), context);
+}
+
+ListServicesOutcome ServiceDiscoveryClient::ListServices(const ListServicesRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListServicesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListServicesOutcomeCallable ServiceDiscoveryClient::ListServicesCallable(const ListServicesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListServicesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListServices(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::ListServicesAsync(const ListServicesRequest& request, const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListServicesAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::ListServicesAsyncHelper(const ListServicesRequest& request, const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListServices(request), context);
+}
+
+ListTagsForResourceOutcome ServiceDiscoveryClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListTagsForResourceOutcomeCallable ServiceDiscoveryClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListTagsForResource(request), context);
+}
+
+RegisterInstanceOutcome ServiceDiscoveryClient::RegisterInstance(const RegisterInstanceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return RegisterInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+RegisterInstanceOutcomeCallable ServiceDiscoveryClient::RegisterInstanceCallable(const RegisterInstanceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< RegisterInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RegisterInstance(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::RegisterInstanceAsync(const RegisterInstanceRequest& request, const RegisterInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->RegisterInstanceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::RegisterInstanceAsyncHelper(const RegisterInstanceRequest& request, const RegisterInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, RegisterInstance(request), context);
+}
+
+TagResourceOutcome ServiceDiscoveryClient::TagResource(const TagResourceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+TagResourceOutcomeCallable ServiceDiscoveryClient::TagResourceCallable(const TagResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, TagResource(request), context);
+}
+
+UntagResourceOutcome ServiceDiscoveryClient::UntagResource(const UntagResourceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+UntagResourceOutcomeCallable ServiceDiscoveryClient::UntagResourceCallable(const UntagResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UntagResource(request), context);
+}
+
+UpdateInstanceCustomHealthStatusOutcome ServiceDiscoveryClient::UpdateInstanceCustomHealthStatus(const UpdateInstanceCustomHealthStatusRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UpdateInstanceCustomHealthStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+UpdateInstanceCustomHealthStatusOutcomeCallable ServiceDiscoveryClient::UpdateInstanceCustomHealthStatusCallable(const UpdateInstanceCustomHealthStatusRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< UpdateInstanceCustomHealthStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateInstanceCustomHealthStatus(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::UpdateInstanceCustomHealthStatusAsync(const UpdateInstanceCustomHealthStatusRequest& request, const UpdateInstanceCustomHealthStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->UpdateInstanceCustomHealthStatusAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::UpdateInstanceCustomHealthStatusAsyncHelper(const UpdateInstanceCustomHealthStatusRequest& request, const UpdateInstanceCustomHealthStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UpdateInstanceCustomHealthStatus(request), context);
+}
+
+UpdateServiceOutcome ServiceDiscoveryClient::UpdateService(const UpdateServiceRequest& request) const
+{
+  Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UpdateServiceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+UpdateServiceOutcomeCallable ServiceDiscoveryClient::UpdateServiceCallable(const UpdateServiceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< UpdateServiceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateService(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ServiceDiscoveryClient::UpdateServiceAsync(const UpdateServiceRequest& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->UpdateServiceAsyncHelper( request, handler, context ); } );
+}
+
+void ServiceDiscoveryClient::UpdateServiceAsyncHelper(const UpdateServiceRequest& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UpdateService(request), context);
+}
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/ServiceDiscoveryEndpoint.cpp

@@ -0,0 +1,64 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/ServiceDiscoveryEndpoint.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/HashingUtils.h>
+
+using namespace Aws;
+using namespace Aws::ServiceDiscovery;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace ServiceDiscoveryEndpoint
+{
+  static const int CN_NORTH_1_HASH = Aws::Utils::HashingUtils::HashString("cn-north-1");
+  static const int CN_NORTHWEST_1_HASH = Aws::Utils::HashingUtils::HashString("cn-northwest-1");
+  static const int US_ISO_EAST_1_HASH = Aws::Utils::HashingUtils::HashString("us-iso-east-1");
+  static const int US_ISOB_EAST_1_HASH = Aws::Utils::HashingUtils::HashString("us-isob-east-1");
+
+
+  Aws::String ForRegion(const Aws::String& regionName, bool useDualStack)
+  {
+    // Fallback to us-east-1 if global endpoint does not exists.
+    Aws::String region = regionName == Aws::Region::AWS_GLOBAL ? Aws::Region::US_EAST_1 : regionName;
+    auto hash = Aws::Utils::HashingUtils::HashString(region.c_str());
+
+    Aws::StringStream ss;
+    ss << "servicediscovery" << ".";
+
+    if(useDualStack)
+    {
+      ss << "dualstack.";
+    }
+
+    ss << region;
+
+    if (hash == CN_NORTH_1_HASH || hash == CN_NORTHWEST_1_HASH)
+    {
+      ss << ".amazonaws.com.cn";
+    }
+    else if (hash == US_ISO_EAST_1_HASH)
+    {
+      ss << ".c2s.ic.gov";
+    }
+    else if (hash == US_ISOB_EAST_1_HASH)
+    {
+      ss << ".sc2s.sgov.gov";
+    }
+    else
+    {
+      ss << ".amazonaws.com";
+    }
+
+    return ss.str();
+  }
+
+} // namespace ServiceDiscoveryEndpoint
+} // namespace ServiceDiscovery
+} // namespace Aws
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/ServiceDiscoveryErrorMarshaller.cpp

@@ -0,0 +1,22 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSError.h>
+#include <aws/servicediscovery/ServiceDiscoveryErrorMarshaller.h>
+#include <aws/servicediscovery/ServiceDiscoveryErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::ServiceDiscovery;
+
+AWSError<CoreErrors> ServiceDiscoveryErrorMarshaller::FindErrorByName(const char* errorName) const
+{
+  AWSError<CoreErrors> error = ServiceDiscoveryErrorMapper::GetErrorForName(errorName);
+  if(error.GetErrorType() != CoreErrors::UNKNOWN)
+  {
+    return error;
+  }
+
+  return AWSErrorMarshaller::FindErrorByName(errorName);
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/ServiceDiscoveryErrors.cpp

@@ -0,0 +1,126 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/servicediscovery/ServiceDiscoveryErrors.h>
+#include <aws/servicediscovery/model/NamespaceAlreadyExists.h>
+#include <aws/servicediscovery/model/DuplicateRequest.h>
+#include <aws/servicediscovery/model/ServiceAlreadyExists.h>
+#include <aws/servicediscovery/model/TooManyTagsException.h>
+
+using namespace Aws::Client;
+using namespace Aws::Utils;
+using namespace Aws::ServiceDiscovery;
+using namespace Aws::ServiceDiscovery::Model;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+template<> AWS_SERVICEDISCOVERY_API NamespaceAlreadyExists ServiceDiscoveryError::GetModeledError()
+{
+  assert(this->GetErrorType() == ServiceDiscoveryErrors::NAMESPACE_ALREADY_EXISTS);
+  return NamespaceAlreadyExists(this->GetJsonPayload().View());
+}
+
+template<> AWS_SERVICEDISCOVERY_API DuplicateRequest ServiceDiscoveryError::GetModeledError()
+{
+  assert(this->GetErrorType() == ServiceDiscoveryErrors::DUPLICATE_REQUEST);
+  return DuplicateRequest(this->GetJsonPayload().View());
+}
+
+template<> AWS_SERVICEDISCOVERY_API ServiceAlreadyExists ServiceDiscoveryError::GetModeledError()
+{
+  assert(this->GetErrorType() == ServiceDiscoveryErrors::SERVICE_ALREADY_EXISTS);
+  return ServiceAlreadyExists(this->GetJsonPayload().View());
+}
+
+template<> AWS_SERVICEDISCOVERY_API TooManyTagsException ServiceDiscoveryError::GetModeledError()
+{
+  assert(this->GetErrorType() == ServiceDiscoveryErrors::TOO_MANY_TAGS);
+  return TooManyTagsException(this->GetJsonPayload().View());
+}
+
+namespace ServiceDiscoveryErrorMapper
+{
+
+static const int NAMESPACE_ALREADY_EXISTS_HASH = HashingUtils::HashString("NamespaceAlreadyExists");
+static const int NAMESPACE_NOT_FOUND_HASH = HashingUtils::HashString("NamespaceNotFound");
+static const int OPERATION_NOT_FOUND_HASH = HashingUtils::HashString("OperationNotFound");
+static const int RESOURCE_IN_USE_HASH = HashingUtils::HashString("ResourceInUse");
+static const int DUPLICATE_REQUEST_HASH = HashingUtils::HashString("DuplicateRequest");
+static const int SERVICE_ALREADY_EXISTS_HASH = HashingUtils::HashString("ServiceAlreadyExists");
+static const int INVALID_INPUT_HASH = HashingUtils::HashString("InvalidInput");
+static const int INSTANCE_NOT_FOUND_HASH = HashingUtils::HashString("InstanceNotFound");
+static const int TOO_MANY_TAGS_HASH = HashingUtils::HashString("TooManyTagsException");
+static const int REQUEST_LIMIT_EXCEEDED_HASH = HashingUtils::HashString("RequestLimitExceeded");
+static const int SERVICE_NOT_FOUND_HASH = HashingUtils::HashString("ServiceNotFound");
+static const int RESOURCE_LIMIT_EXCEEDED_HASH = HashingUtils::HashString("ResourceLimitExceeded");
+static const int CUSTOM_HEALTH_NOT_FOUND_HASH = HashingUtils::HashString("CustomHealthNotFound");
+
+
+AWSError<CoreErrors> GetErrorForName(const char* errorName)
+{
+  int hashCode = HashingUtils::HashString(errorName);
+
+  if (hashCode == NAMESPACE_ALREADY_EXISTS_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::NAMESPACE_ALREADY_EXISTS), false);
+  }
+  else if (hashCode == NAMESPACE_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::NAMESPACE_NOT_FOUND), false);
+  }
+  else if (hashCode == OPERATION_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::OPERATION_NOT_FOUND), false);
+  }
+  else if (hashCode == RESOURCE_IN_USE_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::RESOURCE_IN_USE), false);
+  }
+  else if (hashCode == DUPLICATE_REQUEST_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::DUPLICATE_REQUEST), false);
+  }
+  else if (hashCode == SERVICE_ALREADY_EXISTS_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::SERVICE_ALREADY_EXISTS), false);
+  }
+  else if (hashCode == INVALID_INPUT_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::INVALID_INPUT), false);
+  }
+  else if (hashCode == INSTANCE_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::INSTANCE_NOT_FOUND), false);
+  }
+  else if (hashCode == TOO_MANY_TAGS_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::TOO_MANY_TAGS), false);
+  }
+  else if (hashCode == REQUEST_LIMIT_EXCEEDED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::REQUEST_LIMIT_EXCEEDED), true);
+  }
+  else if (hashCode == SERVICE_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::SERVICE_NOT_FOUND), false);
+  }
+  else if (hashCode == RESOURCE_LIMIT_EXCEEDED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::RESOURCE_LIMIT_EXCEEDED), false);
+  }
+  else if (hashCode == CUSTOM_HEALTH_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ServiceDiscoveryErrors::CUSTOM_HEALTH_NOT_FOUND), false);
+  }
+  return AWSError<CoreErrors>(CoreErrors::UNKNOWN, false);
+}
+
+} // namespace ServiceDiscoveryErrorMapper
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CreateHttpNamespaceRequest.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CreateHttpNamespaceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+CreateHttpNamespaceRequest::CreateHttpNamespaceRequest() : 
+    m_nameHasBeenSet(false),
+    m_creatorRequestId(Aws::Utils::UUID::RandomUUID()),
+    m_creatorRequestIdHasBeenSet(true),
+    m_descriptionHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String CreateHttpNamespaceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   Array<JsonValue> tagsJsonList(m_tags.size());
+   for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+   {
+     tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
+   }
+   payload.WithArray("Tags", std::move(tagsJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection CreateHttpNamespaceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.CreateHttpNamespace"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CreateHttpNamespaceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CreateHttpNamespaceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateHttpNamespaceResult::CreateHttpNamespaceResult()
+{
+}
+
+CreateHttpNamespaceResult::CreateHttpNamespaceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+CreateHttpNamespaceResult& CreateHttpNamespaceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("OperationId"))
+  {
+    m_operationId = jsonValue.GetString("OperationId");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CreatePrivateDnsNamespaceRequest.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CreatePrivateDnsNamespaceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+CreatePrivateDnsNamespaceRequest::CreatePrivateDnsNamespaceRequest() : 
+    m_nameHasBeenSet(false),
+    m_creatorRequestId(Aws::Utils::UUID::RandomUUID()),
+    m_creatorRequestIdHasBeenSet(true),
+    m_descriptionHasBeenSet(false),
+    m_vpcHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String CreatePrivateDnsNamespaceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_vpcHasBeenSet)
+  {
+   payload.WithString("Vpc", m_vpc);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   Array<JsonValue> tagsJsonList(m_tags.size());
+   for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+   {
+     tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
+   }
+   payload.WithArray("Tags", std::move(tagsJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection CreatePrivateDnsNamespaceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.CreatePrivateDnsNamespace"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CreatePrivateDnsNamespaceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CreatePrivateDnsNamespaceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreatePrivateDnsNamespaceResult::CreatePrivateDnsNamespaceResult()
+{
+}
+
+CreatePrivateDnsNamespaceResult::CreatePrivateDnsNamespaceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+CreatePrivateDnsNamespaceResult& CreatePrivateDnsNamespaceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("OperationId"))
+  {
+    m_operationId = jsonValue.GetString("OperationId");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CreatePublicDnsNamespaceRequest.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CreatePublicDnsNamespaceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+CreatePublicDnsNamespaceRequest::CreatePublicDnsNamespaceRequest() : 
+    m_nameHasBeenSet(false),
+    m_creatorRequestId(Aws::Utils::UUID::RandomUUID()),
+    m_creatorRequestIdHasBeenSet(true),
+    m_descriptionHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String CreatePublicDnsNamespaceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   Array<JsonValue> tagsJsonList(m_tags.size());
+   for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+   {
+     tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
+   }
+   payload.WithArray("Tags", std::move(tagsJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection CreatePublicDnsNamespaceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.CreatePublicDnsNamespace"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CreatePublicDnsNamespaceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CreatePublicDnsNamespaceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreatePublicDnsNamespaceResult::CreatePublicDnsNamespaceResult()
+{
+}
+
+CreatePublicDnsNamespaceResult::CreatePublicDnsNamespaceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+CreatePublicDnsNamespaceResult& CreatePublicDnsNamespaceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("OperationId"))
+  {
+    m_operationId = jsonValue.GetString("OperationId");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CreateServiceRequest.cpp

@@ -0,0 +1,98 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CreateServiceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+CreateServiceRequest::CreateServiceRequest() : 
+    m_nameHasBeenSet(false),
+    m_namespaceIdHasBeenSet(false),
+    m_creatorRequestId(Aws::Utils::UUID::RandomUUID()),
+    m_creatorRequestIdHasBeenSet(true),
+    m_descriptionHasBeenSet(false),
+    m_dnsConfigHasBeenSet(false),
+    m_healthCheckConfigHasBeenSet(false),
+    m_healthCheckCustomConfigHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String CreateServiceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_namespaceIdHasBeenSet)
+  {
+   payload.WithString("NamespaceId", m_namespaceId);
+
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_dnsConfigHasBeenSet)
+  {
+   payload.WithObject("DnsConfig", m_dnsConfig.Jsonize());
+
+  }
+
+  if(m_healthCheckConfigHasBeenSet)
+  {
+   payload.WithObject("HealthCheckConfig", m_healthCheckConfig.Jsonize());
+
+  }
+
+  if(m_healthCheckCustomConfigHasBeenSet)
+  {
+   payload.WithObject("HealthCheckCustomConfig", m_healthCheckCustomConfig.Jsonize());
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   Array<JsonValue> tagsJsonList(m_tags.size());
+   for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+   {
+     tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
+   }
+   payload.WithArray("Tags", std::move(tagsJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection CreateServiceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.CreateService"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CreateServiceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CreateServiceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateServiceResult::CreateServiceResult()
+{
+}
+
+CreateServiceResult::CreateServiceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+CreateServiceResult& CreateServiceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Service"))
+  {
+    m_service = jsonValue.GetObject("Service");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/CustomHealthStatus.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/CustomHealthStatus.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace CustomHealthStatusMapper
+      {
+
+        static const int HEALTHY_HASH = HashingUtils::HashString("HEALTHY");
+        static const int UNHEALTHY_HASH = HashingUtils::HashString("UNHEALTHY");
+
+
+        CustomHealthStatus GetCustomHealthStatusForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == HEALTHY_HASH)
+          {
+            return CustomHealthStatus::HEALTHY;
+          }
+          else if (hashCode == UNHEALTHY_HASH)
+          {
+            return CustomHealthStatus::UNHEALTHY;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<CustomHealthStatus>(hashCode);
+          }
+
+          return CustomHealthStatus::NOT_SET;
+        }
+
+        Aws::String GetNameForCustomHealthStatus(CustomHealthStatus enumValue)
+        {
+          switch(enumValue)
+          {
+          case CustomHealthStatus::HEALTHY:
+            return "HEALTHY";
+          case CustomHealthStatus::UNHEALTHY:
+            return "UNHEALTHY";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace CustomHealthStatusMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DeleteNamespaceRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DeleteNamespaceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DeleteNamespaceRequest::DeleteNamespaceRequest() : 
+    m_idHasBeenSet(false)
+{
+}
+
+Aws::String DeleteNamespaceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection DeleteNamespaceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.DeleteNamespace"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DeleteNamespaceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DeleteNamespaceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeleteNamespaceResult::DeleteNamespaceResult()
+{
+}
+
+DeleteNamespaceResult::DeleteNamespaceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+DeleteNamespaceResult& DeleteNamespaceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("OperationId"))
+  {
+    m_operationId = jsonValue.GetString("OperationId");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DeleteServiceRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DeleteServiceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DeleteServiceRequest::DeleteServiceRequest() : 
+    m_idHasBeenSet(false)
+{
+}
+
+Aws::String DeleteServiceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection DeleteServiceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.DeleteService"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DeleteServiceResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DeleteServiceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeleteServiceResult::DeleteServiceResult()
+{
+}
+
+DeleteServiceResult::DeleteServiceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+DeleteServiceResult& DeleteServiceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DeregisterInstanceRequest.cpp

@@ -0,0 +1,50 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DeregisterInstanceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DeregisterInstanceRequest::DeregisterInstanceRequest() : 
+    m_serviceIdHasBeenSet(false),
+    m_instanceIdHasBeenSet(false)
+{
+}
+
+Aws::String DeregisterInstanceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_serviceIdHasBeenSet)
+  {
+   payload.WithString("ServiceId", m_serviceId);
+
+  }
+
+  if(m_instanceIdHasBeenSet)
+  {
+   payload.WithString("InstanceId", m_instanceId);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection DeregisterInstanceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.DeregisterInstance"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DeregisterInstanceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DeregisterInstanceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeregisterInstanceResult::DeregisterInstanceResult()
+{
+}
+
+DeregisterInstanceResult::DeregisterInstanceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+DeregisterInstanceResult& DeregisterInstanceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("OperationId"))
+  {
+    m_operationId = jsonValue.GetString("OperationId");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DiscoverInstancesRequest.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DiscoverInstancesRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DiscoverInstancesRequest::DiscoverInstancesRequest() : 
+    m_namespaceNameHasBeenSet(false),
+    m_serviceNameHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_queryParametersHasBeenSet(false),
+    m_healthStatus(HealthStatusFilter::NOT_SET),
+    m_healthStatusHasBeenSet(false)
+{
+}
+
+Aws::String DiscoverInstancesRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_namespaceNameHasBeenSet)
+  {
+   payload.WithString("NamespaceName", m_namespaceName);
+
+  }
+
+  if(m_serviceNameHasBeenSet)
+  {
+   payload.WithString("ServiceName", m_serviceName);
+
+  }
+
+  if(m_maxResultsHasBeenSet)
+  {
+   payload.WithInteger("MaxResults", m_maxResults);
+
+  }
+
+  if(m_queryParametersHasBeenSet)
+  {
+   JsonValue queryParametersJsonMap;
+   for(auto& queryParametersItem : m_queryParameters)
+   {
+     queryParametersJsonMap.WithString(queryParametersItem.first, queryParametersItem.second);
+   }
+   payload.WithObject("QueryParameters", std::move(queryParametersJsonMap));
+
+  }
+
+  if(m_healthStatusHasBeenSet)
+  {
+   payload.WithString("HealthStatus", HealthStatusFilterMapper::GetNameForHealthStatusFilter(m_healthStatus));
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection DiscoverInstancesRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.DiscoverInstances"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DiscoverInstancesResult.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DiscoverInstancesResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DiscoverInstancesResult::DiscoverInstancesResult()
+{
+}
+
+DiscoverInstancesResult::DiscoverInstancesResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+DiscoverInstancesResult& DiscoverInstancesResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Instances"))
+  {
+    Array<JsonView> instancesJsonList = jsonValue.GetArray("Instances");
+    for(unsigned instancesIndex = 0; instancesIndex < instancesJsonList.GetLength(); ++instancesIndex)
+    {
+      m_instances.push_back(instancesJsonList[instancesIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DnsConfig.cpp

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DnsConfig.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+DnsConfig::DnsConfig() : 
+    m_routingPolicy(RoutingPolicy::NOT_SET),
+    m_routingPolicyHasBeenSet(false),
+    m_dnsRecordsHasBeenSet(false)
+{
+}
+
+DnsConfig::DnsConfig(JsonView jsonValue) : 
+    m_routingPolicy(RoutingPolicy::NOT_SET),
+    m_routingPolicyHasBeenSet(false),
+    m_dnsRecordsHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+DnsConfig& DnsConfig::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("RoutingPolicy"))
+  {
+    m_routingPolicy = RoutingPolicyMapper::GetRoutingPolicyForName(jsonValue.GetString("RoutingPolicy"));
+
+    m_routingPolicyHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("DnsRecords"))
+  {
+    Array<JsonView> dnsRecordsJsonList = jsonValue.GetArray("DnsRecords");
+    for(unsigned dnsRecordsIndex = 0; dnsRecordsIndex < dnsRecordsJsonList.GetLength(); ++dnsRecordsIndex)
+    {
+      m_dnsRecords.push_back(dnsRecordsJsonList[dnsRecordsIndex].AsObject());
+    }
+    m_dnsRecordsHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue DnsConfig::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_routingPolicyHasBeenSet)
+  {
+   payload.WithString("RoutingPolicy", RoutingPolicyMapper::GetNameForRoutingPolicy(m_routingPolicy));
+  }
+
+  if(m_dnsRecordsHasBeenSet)
+  {
+   Array<JsonValue> dnsRecordsJsonList(m_dnsRecords.size());
+   for(unsigned dnsRecordsIndex = 0; dnsRecordsIndex < dnsRecordsJsonList.GetLength(); ++dnsRecordsIndex)
+   {
+     dnsRecordsJsonList[dnsRecordsIndex].AsObject(m_dnsRecords[dnsRecordsIndex].Jsonize());
+   }
+   payload.WithArray("DnsRecords", std::move(dnsRecordsJsonList));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DnsConfigChange.cpp

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DnsConfigChange.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+DnsConfigChange::DnsConfigChange() : 
+    m_dnsRecordsHasBeenSet(false)
+{
+}
+
+DnsConfigChange::DnsConfigChange(JsonView jsonValue) : 
+    m_dnsRecordsHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+DnsConfigChange& DnsConfigChange::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("DnsRecords"))
+  {
+    Array<JsonView> dnsRecordsJsonList = jsonValue.GetArray("DnsRecords");
+    for(unsigned dnsRecordsIndex = 0; dnsRecordsIndex < dnsRecordsJsonList.GetLength(); ++dnsRecordsIndex)
+    {
+      m_dnsRecords.push_back(dnsRecordsJsonList[dnsRecordsIndex].AsObject());
+    }
+    m_dnsRecordsHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue DnsConfigChange::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_dnsRecordsHasBeenSet)
+  {
+   Array<JsonValue> dnsRecordsJsonList(m_dnsRecords.size());
+   for(unsigned dnsRecordsIndex = 0; dnsRecordsIndex < dnsRecordsJsonList.GetLength(); ++dnsRecordsIndex)
+   {
+     dnsRecordsJsonList[dnsRecordsIndex].AsObject(m_dnsRecords[dnsRecordsIndex].Jsonize());
+   }
+   payload.WithArray("DnsRecords", std::move(dnsRecordsJsonList));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DnsProperties.cpp

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DnsProperties.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+DnsProperties::DnsProperties() : 
+    m_hostedZoneIdHasBeenSet(false)
+{
+}
+
+DnsProperties::DnsProperties(JsonView jsonValue) : 
+    m_hostedZoneIdHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+DnsProperties& DnsProperties::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("HostedZoneId"))
+  {
+    m_hostedZoneId = jsonValue.GetString("HostedZoneId");
+
+    m_hostedZoneIdHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue DnsProperties::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_hostedZoneIdHasBeenSet)
+  {
+   payload.WithString("HostedZoneId", m_hostedZoneId);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DnsRecord.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DnsRecord.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+DnsRecord::DnsRecord() : 
+    m_type(RecordType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_tTL(0),
+    m_tTLHasBeenSet(false)
+{
+}
+
+DnsRecord::DnsRecord(JsonView jsonValue) : 
+    m_type(RecordType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_tTL(0),
+    m_tTLHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+DnsRecord& DnsRecord::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Type"))
+  {
+    m_type = RecordTypeMapper::GetRecordTypeForName(jsonValue.GetString("Type"));
+
+    m_typeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("TTL"))
+  {
+    m_tTL = jsonValue.GetInt64("TTL");
+
+    m_tTLHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue DnsRecord::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("Type", RecordTypeMapper::GetNameForRecordType(m_type));
+  }
+
+  if(m_tTLHasBeenSet)
+  {
+   payload.WithInt64("TTL", m_tTL);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/DuplicateRequest.cpp

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/DuplicateRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+DuplicateRequest::DuplicateRequest() : 
+    m_messageHasBeenSet(false),
+    m_duplicateOperationIdHasBeenSet(false)
+{
+}
+
+DuplicateRequest::DuplicateRequest(JsonView jsonValue) : 
+    m_messageHasBeenSet(false),
+    m_duplicateOperationIdHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+DuplicateRequest& DuplicateRequest::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Message"))
+  {
+    m_message = jsonValue.GetString("Message");
+
+    m_messageHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("DuplicateOperationId"))
+  {
+    m_duplicateOperationId = jsonValue.GetString("DuplicateOperationId");
+
+    m_duplicateOperationIdHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue DuplicateRequest::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_messageHasBeenSet)
+  {
+   payload.WithString("Message", m_message);
+
+  }
+
+  if(m_duplicateOperationIdHasBeenSet)
+  {
+   payload.WithString("DuplicateOperationId", m_duplicateOperationId);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/FilterCondition.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/FilterCondition.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace FilterConditionMapper
+      {
+
+        static const int EQ_HASH = HashingUtils::HashString("EQ");
+        static const int IN_HASH = HashingUtils::HashString("IN");
+        static const int BETWEEN_HASH = HashingUtils::HashString("BETWEEN");
+
+
+        FilterCondition GetFilterConditionForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == EQ_HASH)
+          {
+            return FilterCondition::EQ;
+          }
+          else if (hashCode == IN_HASH)
+          {
+            return FilterCondition::IN;
+          }
+          else if (hashCode == BETWEEN_HASH)
+          {
+            return FilterCondition::BETWEEN;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<FilterCondition>(hashCode);
+          }
+
+          return FilterCondition::NOT_SET;
+        }
+
+        Aws::String GetNameForFilterCondition(FilterCondition enumValue)
+        {
+          switch(enumValue)
+          {
+          case FilterCondition::EQ:
+            return "EQ";
+          case FilterCondition::IN:
+            return "IN";
+          case FilterCondition::BETWEEN:
+            return "BETWEEN";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace FilterConditionMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetInstanceRequest.cpp

@@ -0,0 +1,50 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetInstanceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetInstanceRequest::GetInstanceRequest() : 
+    m_serviceIdHasBeenSet(false),
+    m_instanceIdHasBeenSet(false)
+{
+}
+
+Aws::String GetInstanceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_serviceIdHasBeenSet)
+  {
+   payload.WithString("ServiceId", m_serviceId);
+
+  }
+
+  if(m_instanceIdHasBeenSet)
+  {
+   payload.WithString("InstanceId", m_instanceId);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection GetInstanceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.GetInstance"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetInstanceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetInstanceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetInstanceResult::GetInstanceResult()
+{
+}
+
+GetInstanceResult::GetInstanceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetInstanceResult& GetInstanceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Instance"))
+  {
+    m_instance = jsonValue.GetObject("Instance");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetInstancesHealthStatusRequest.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetInstancesHealthStatusRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetInstancesHealthStatusRequest::GetInstancesHealthStatusRequest() : 
+    m_serviceIdHasBeenSet(false),
+    m_instancesHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_nextTokenHasBeenSet(false)
+{
+}
+
+Aws::String GetInstancesHealthStatusRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_serviceIdHasBeenSet)
+  {
+   payload.WithString("ServiceId", m_serviceId);
+
+  }
+
+  if(m_instancesHasBeenSet)
+  {
+   Array<JsonValue> instancesJsonList(m_instances.size());
+   for(unsigned instancesIndex = 0; instancesIndex < instancesJsonList.GetLength(); ++instancesIndex)
+   {
+     instancesJsonList[instancesIndex].AsString(m_instances[instancesIndex]);
+   }
+   payload.WithArray("Instances", std::move(instancesJsonList));
+
+  }
+
+  if(m_maxResultsHasBeenSet)
+  {
+   payload.WithInteger("MaxResults", m_maxResults);
+
+  }
+
+  if(m_nextTokenHasBeenSet)
+  {
+   payload.WithString("NextToken", m_nextToken);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection GetInstancesHealthStatusRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.GetInstancesHealthStatus"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetInstancesHealthStatusResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetInstancesHealthStatusResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetInstancesHealthStatusResult::GetInstancesHealthStatusResult()
+{
+}
+
+GetInstancesHealthStatusResult::GetInstancesHealthStatusResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetInstancesHealthStatusResult& GetInstancesHealthStatusResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Status"))
+  {
+    Aws::Map<Aws::String, JsonView> statusJsonMap = jsonValue.GetObject("Status").GetAllObjects();
+    for(auto& statusItem : statusJsonMap)
+    {
+      m_status[statusItem.first] = HealthStatusMapper::GetHealthStatusForName(statusItem.second.AsString());
+    }
+  }
+
+  if(jsonValue.ValueExists("NextToken"))
+  {
+    m_nextToken = jsonValue.GetString("NextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetNamespaceRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetNamespaceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetNamespaceRequest::GetNamespaceRequest() : 
+    m_idHasBeenSet(false)
+{
+}
+
+Aws::String GetNamespaceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection GetNamespaceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.GetNamespace"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetNamespaceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetNamespaceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetNamespaceResult::GetNamespaceResult()
+{
+}
+
+GetNamespaceResult::GetNamespaceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetNamespaceResult& GetNamespaceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Namespace"))
+  {
+    m_namespace = jsonValue.GetObject("Namespace");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetOperationRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetOperationRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetOperationRequest::GetOperationRequest() : 
+    m_operationIdHasBeenSet(false)
+{
+}
+
+Aws::String GetOperationRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_operationIdHasBeenSet)
+  {
+   payload.WithString("OperationId", m_operationId);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection GetOperationRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.GetOperation"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetOperationResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetOperationResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetOperationResult::GetOperationResult()
+{
+}
+
+GetOperationResult::GetOperationResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetOperationResult& GetOperationResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Operation"))
+  {
+    m_operation = jsonValue.GetObject("Operation");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetServiceRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetServiceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetServiceRequest::GetServiceRequest() : 
+    m_idHasBeenSet(false)
+{
+}
+
+Aws::String GetServiceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection GetServiceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.GetService"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/GetServiceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/GetServiceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetServiceResult::GetServiceResult()
+{
+}
+
+GetServiceResult::GetServiceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetServiceResult& GetServiceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Service"))
+  {
+    m_service = jsonValue.GetObject("Service");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/HealthCheckConfig.cpp

@@ -0,0 +1,92 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/HealthCheckConfig.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+HealthCheckConfig::HealthCheckConfig() : 
+    m_type(HealthCheckType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_resourcePathHasBeenSet(false),
+    m_failureThreshold(0),
+    m_failureThresholdHasBeenSet(false)
+{
+}
+
+HealthCheckConfig::HealthCheckConfig(JsonView jsonValue) : 
+    m_type(HealthCheckType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_resourcePathHasBeenSet(false),
+    m_failureThreshold(0),
+    m_failureThresholdHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+HealthCheckConfig& HealthCheckConfig::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Type"))
+  {
+    m_type = HealthCheckTypeMapper::GetHealthCheckTypeForName(jsonValue.GetString("Type"));
+
+    m_typeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ResourcePath"))
+  {
+    m_resourcePath = jsonValue.GetString("ResourcePath");
+
+    m_resourcePathHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("FailureThreshold"))
+  {
+    m_failureThreshold = jsonValue.GetInteger("FailureThreshold");
+
+    m_failureThresholdHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue HealthCheckConfig::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("Type", HealthCheckTypeMapper::GetNameForHealthCheckType(m_type));
+  }
+
+  if(m_resourcePathHasBeenSet)
+  {
+   payload.WithString("ResourcePath", m_resourcePath);
+
+  }
+
+  if(m_failureThresholdHasBeenSet)
+  {
+   payload.WithInteger("FailureThreshold", m_failureThreshold);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/HealthCheckCustomConfig.cpp

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/HealthCheckCustomConfig.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+HealthCheckCustomConfig::HealthCheckCustomConfig() : 
+    m_failureThreshold(0),
+    m_failureThresholdHasBeenSet(false)
+{
+}
+
+HealthCheckCustomConfig::HealthCheckCustomConfig(JsonView jsonValue) : 
+    m_failureThreshold(0),
+    m_failureThresholdHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+HealthCheckCustomConfig& HealthCheckCustomConfig::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("FailureThreshold"))
+  {
+    m_failureThreshold = jsonValue.GetInteger("FailureThreshold");
+
+    m_failureThresholdHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue HealthCheckCustomConfig::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_failureThresholdHasBeenSet)
+  {
+   payload.WithInteger("FailureThreshold", m_failureThreshold);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/HealthCheckType.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/HealthCheckType.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace HealthCheckTypeMapper
+      {
+
+        static const int HTTP_HASH = HashingUtils::HashString("HTTP");
+        static const int HTTPS_HASH = HashingUtils::HashString("HTTPS");
+        static const int TCP_HASH = HashingUtils::HashString("TCP");
+
+
+        HealthCheckType GetHealthCheckTypeForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == HTTP_HASH)
+          {
+            return HealthCheckType::HTTP;
+          }
+          else if (hashCode == HTTPS_HASH)
+          {
+            return HealthCheckType::HTTPS;
+          }
+          else if (hashCode == TCP_HASH)
+          {
+            return HealthCheckType::TCP;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<HealthCheckType>(hashCode);
+          }
+
+          return HealthCheckType::NOT_SET;
+        }
+
+        Aws::String GetNameForHealthCheckType(HealthCheckType enumValue)
+        {
+          switch(enumValue)
+          {
+          case HealthCheckType::HTTP:
+            return "HTTP";
+          case HealthCheckType::HTTPS:
+            return "HTTPS";
+          case HealthCheckType::TCP:
+            return "TCP";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace HealthCheckTypeMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/HealthStatus.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/HealthStatus.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace HealthStatusMapper
+      {
+
+        static const int HEALTHY_HASH = HashingUtils::HashString("HEALTHY");
+        static const int UNHEALTHY_HASH = HashingUtils::HashString("UNHEALTHY");
+        static const int UNKNOWN_HASH = HashingUtils::HashString("UNKNOWN");
+
+
+        HealthStatus GetHealthStatusForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == HEALTHY_HASH)
+          {
+            return HealthStatus::HEALTHY;
+          }
+          else if (hashCode == UNHEALTHY_HASH)
+          {
+            return HealthStatus::UNHEALTHY;
+          }
+          else if (hashCode == UNKNOWN_HASH)
+          {
+            return HealthStatus::UNKNOWN;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<HealthStatus>(hashCode);
+          }
+
+          return HealthStatus::NOT_SET;
+        }
+
+        Aws::String GetNameForHealthStatus(HealthStatus enumValue)
+        {
+          switch(enumValue)
+          {
+          case HealthStatus::HEALTHY:
+            return "HEALTHY";
+          case HealthStatus::UNHEALTHY:
+            return "UNHEALTHY";
+          case HealthStatus::UNKNOWN:
+            return "UNKNOWN";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace HealthStatusMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/HealthStatusFilter.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/HealthStatusFilter.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace HealthStatusFilterMapper
+      {
+
+        static const int HEALTHY_HASH = HashingUtils::HashString("HEALTHY");
+        static const int UNHEALTHY_HASH = HashingUtils::HashString("UNHEALTHY");
+        static const int ALL_HASH = HashingUtils::HashString("ALL");
+
+
+        HealthStatusFilter GetHealthStatusFilterForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == HEALTHY_HASH)
+          {
+            return HealthStatusFilter::HEALTHY;
+          }
+          else if (hashCode == UNHEALTHY_HASH)
+          {
+            return HealthStatusFilter::UNHEALTHY;
+          }
+          else if (hashCode == ALL_HASH)
+          {
+            return HealthStatusFilter::ALL;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<HealthStatusFilter>(hashCode);
+          }
+
+          return HealthStatusFilter::NOT_SET;
+        }
+
+        Aws::String GetNameForHealthStatusFilter(HealthStatusFilter enumValue)
+        {
+          switch(enumValue)
+          {
+          case HealthStatusFilter::HEALTHY:
+            return "HEALTHY";
+          case HealthStatusFilter::UNHEALTHY:
+            return "UNHEALTHY";
+          case HealthStatusFilter::ALL:
+            return "ALL";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace HealthStatusFilterMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/HttpInstanceSummary.cpp

@@ -0,0 +1,128 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/HttpInstanceSummary.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+HttpInstanceSummary::HttpInstanceSummary() : 
+    m_instanceIdHasBeenSet(false),
+    m_namespaceNameHasBeenSet(false),
+    m_serviceNameHasBeenSet(false),
+    m_healthStatus(HealthStatus::NOT_SET),
+    m_healthStatusHasBeenSet(false),
+    m_attributesHasBeenSet(false)
+{
+}
+
+HttpInstanceSummary::HttpInstanceSummary(JsonView jsonValue) : 
+    m_instanceIdHasBeenSet(false),
+    m_namespaceNameHasBeenSet(false),
+    m_serviceNameHasBeenSet(false),
+    m_healthStatus(HealthStatus::NOT_SET),
+    m_healthStatusHasBeenSet(false),
+    m_attributesHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+HttpInstanceSummary& HttpInstanceSummary::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("InstanceId"))
+  {
+    m_instanceId = jsonValue.GetString("InstanceId");
+
+    m_instanceIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("NamespaceName"))
+  {
+    m_namespaceName = jsonValue.GetString("NamespaceName");
+
+    m_namespaceNameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ServiceName"))
+  {
+    m_serviceName = jsonValue.GetString("ServiceName");
+
+    m_serviceNameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HealthStatus"))
+  {
+    m_healthStatus = HealthStatusMapper::GetHealthStatusForName(jsonValue.GetString("HealthStatus"));
+
+    m_healthStatusHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Attributes"))
+  {
+    Aws::Map<Aws::String, JsonView> attributesJsonMap = jsonValue.GetObject("Attributes").GetAllObjects();
+    for(auto& attributesItem : attributesJsonMap)
+    {
+      m_attributes[attributesItem.first] = attributesItem.second.AsString();
+    }
+    m_attributesHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue HttpInstanceSummary::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_instanceIdHasBeenSet)
+  {
+   payload.WithString("InstanceId", m_instanceId);
+
+  }
+
+  if(m_namespaceNameHasBeenSet)
+  {
+   payload.WithString("NamespaceName", m_namespaceName);
+
+  }
+
+  if(m_serviceNameHasBeenSet)
+  {
+   payload.WithString("ServiceName", m_serviceName);
+
+  }
+
+  if(m_healthStatusHasBeenSet)
+  {
+   payload.WithString("HealthStatus", HealthStatusMapper::GetNameForHealthStatus(m_healthStatus));
+  }
+
+  if(m_attributesHasBeenSet)
+  {
+   JsonValue attributesJsonMap;
+   for(auto& attributesItem : m_attributes)
+   {
+     attributesJsonMap.WithString(attributesItem.first, attributesItem.second);
+   }
+   payload.WithObject("Attributes", std::move(attributesJsonMap));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/HttpProperties.cpp

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/HttpProperties.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+HttpProperties::HttpProperties() : 
+    m_httpNameHasBeenSet(false)
+{
+}
+
+HttpProperties::HttpProperties(JsonView jsonValue) : 
+    m_httpNameHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+HttpProperties& HttpProperties::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("HttpName"))
+  {
+    m_httpName = jsonValue.GetString("HttpName");
+
+    m_httpNameHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue HttpProperties::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_httpNameHasBeenSet)
+  {
+   payload.WithString("HttpName", m_httpName);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/Instance.cpp

@@ -0,0 +1,97 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/Instance.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+Instance::Instance() : 
+    m_idHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false),
+    m_attributesHasBeenSet(false)
+{
+}
+
+Instance::Instance(JsonView jsonValue) : 
+    m_idHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false),
+    m_attributesHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Instance& Instance::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Id"))
+  {
+    m_id = jsonValue.GetString("Id");
+
+    m_idHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreatorRequestId"))
+  {
+    m_creatorRequestId = jsonValue.GetString("CreatorRequestId");
+
+    m_creatorRequestIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Attributes"))
+  {
+    Aws::Map<Aws::String, JsonView> attributesJsonMap = jsonValue.GetObject("Attributes").GetAllObjects();
+    for(auto& attributesItem : attributesJsonMap)
+    {
+      m_attributes[attributesItem.first] = attributesItem.second.AsString();
+    }
+    m_attributesHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Instance::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  if(m_attributesHasBeenSet)
+  {
+   JsonValue attributesJsonMap;
+   for(auto& attributesItem : m_attributes)
+   {
+     attributesJsonMap.WithString(attributesItem.first, attributesItem.second);
+   }
+   payload.WithObject("Attributes", std::move(attributesJsonMap));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/InstanceSummary.cpp

@@ -0,0 +1,82 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/InstanceSummary.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+InstanceSummary::InstanceSummary() : 
+    m_idHasBeenSet(false),
+    m_attributesHasBeenSet(false)
+{
+}
+
+InstanceSummary::InstanceSummary(JsonView jsonValue) : 
+    m_idHasBeenSet(false),
+    m_attributesHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+InstanceSummary& InstanceSummary::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Id"))
+  {
+    m_id = jsonValue.GetString("Id");
+
+    m_idHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Attributes"))
+  {
+    Aws::Map<Aws::String, JsonView> attributesJsonMap = jsonValue.GetObject("Attributes").GetAllObjects();
+    for(auto& attributesItem : attributesJsonMap)
+    {
+      m_attributes[attributesItem.first] = attributesItem.second.AsString();
+    }
+    m_attributesHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue InstanceSummary::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_attributesHasBeenSet)
+  {
+   JsonValue attributesJsonMap;
+   for(auto& attributesItem : m_attributes)
+   {
+     attributesJsonMap.WithString(attributesItem.first, attributesItem.second);
+   }
+   payload.WithObject("Attributes", std::move(attributesJsonMap));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListInstancesRequest.cpp

@@ -0,0 +1,58 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListInstancesRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListInstancesRequest::ListInstancesRequest() : 
+    m_serviceIdHasBeenSet(false),
+    m_nextTokenHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false)
+{
+}
+
+Aws::String ListInstancesRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_serviceIdHasBeenSet)
+  {
+   payload.WithString("ServiceId", m_serviceId);
+
+  }
+
+  if(m_nextTokenHasBeenSet)
+  {
+   payload.WithString("NextToken", m_nextToken);
+
+  }
+
+  if(m_maxResultsHasBeenSet)
+  {
+   payload.WithInteger("MaxResults", m_maxResults);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ListInstancesRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.ListInstances"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListInstancesResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListInstancesResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListInstancesResult::ListInstancesResult()
+{
+}
+
+ListInstancesResult::ListInstancesResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListInstancesResult& ListInstancesResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Instances"))
+  {
+    Array<JsonView> instancesJsonList = jsonValue.GetArray("Instances");
+    for(unsigned instancesIndex = 0; instancesIndex < instancesJsonList.GetLength(); ++instancesIndex)
+    {
+      m_instances.push_back(instancesJsonList[instancesIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("NextToken"))
+  {
+    m_nextToken = jsonValue.GetString("NextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListNamespacesRequest.cpp

@@ -0,0 +1,63 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListNamespacesRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListNamespacesRequest::ListNamespacesRequest() : 
+    m_nextTokenHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_filtersHasBeenSet(false)
+{
+}
+
+Aws::String ListNamespacesRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nextTokenHasBeenSet)
+  {
+   payload.WithString("NextToken", m_nextToken);
+
+  }
+
+  if(m_maxResultsHasBeenSet)
+  {
+   payload.WithInteger("MaxResults", m_maxResults);
+
+  }
+
+  if(m_filtersHasBeenSet)
+  {
+   Array<JsonValue> filtersJsonList(m_filters.size());
+   for(unsigned filtersIndex = 0; filtersIndex < filtersJsonList.GetLength(); ++filtersIndex)
+   {
+     filtersJsonList[filtersIndex].AsObject(m_filters[filtersIndex].Jsonize());
+   }
+   payload.WithArray("Filters", std::move(filtersJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ListNamespacesRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.ListNamespaces"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListNamespacesResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListNamespacesResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListNamespacesResult::ListNamespacesResult()
+{
+}
+
+ListNamespacesResult::ListNamespacesResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListNamespacesResult& ListNamespacesResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Namespaces"))
+  {
+    Array<JsonView> namespacesJsonList = jsonValue.GetArray("Namespaces");
+    for(unsigned namespacesIndex = 0; namespacesIndex < namespacesJsonList.GetLength(); ++namespacesIndex)
+    {
+      m_namespaces.push_back(namespacesJsonList[namespacesIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("NextToken"))
+  {
+    m_nextToken = jsonValue.GetString("NextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListOperationsRequest.cpp

@@ -0,0 +1,63 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListOperationsRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListOperationsRequest::ListOperationsRequest() : 
+    m_nextTokenHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_filtersHasBeenSet(false)
+{
+}
+
+Aws::String ListOperationsRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nextTokenHasBeenSet)
+  {
+   payload.WithString("NextToken", m_nextToken);
+
+  }
+
+  if(m_maxResultsHasBeenSet)
+  {
+   payload.WithInteger("MaxResults", m_maxResults);
+
+  }
+
+  if(m_filtersHasBeenSet)
+  {
+   Array<JsonValue> filtersJsonList(m_filters.size());
+   for(unsigned filtersIndex = 0; filtersIndex < filtersJsonList.GetLength(); ++filtersIndex)
+   {
+     filtersJsonList[filtersIndex].AsObject(m_filters[filtersIndex].Jsonize());
+   }
+   payload.WithArray("Filters", std::move(filtersJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ListOperationsRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.ListOperations"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListOperationsResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListOperationsResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListOperationsResult::ListOperationsResult()
+{
+}
+
+ListOperationsResult::ListOperationsResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListOperationsResult& ListOperationsResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Operations"))
+  {
+    Array<JsonView> operationsJsonList = jsonValue.GetArray("Operations");
+    for(unsigned operationsIndex = 0; operationsIndex < operationsJsonList.GetLength(); ++operationsIndex)
+    {
+      m_operations.push_back(operationsJsonList[operationsIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("NextToken"))
+  {
+    m_nextToken = jsonValue.GetString("NextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListServicesRequest.cpp

@@ -0,0 +1,63 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListServicesRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListServicesRequest::ListServicesRequest() : 
+    m_nextTokenHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_filtersHasBeenSet(false)
+{
+}
+
+Aws::String ListServicesRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nextTokenHasBeenSet)
+  {
+   payload.WithString("NextToken", m_nextToken);
+
+  }
+
+  if(m_maxResultsHasBeenSet)
+  {
+   payload.WithInteger("MaxResults", m_maxResults);
+
+  }
+
+  if(m_filtersHasBeenSet)
+  {
+   Array<JsonValue> filtersJsonList(m_filters.size());
+   for(unsigned filtersIndex = 0; filtersIndex < filtersJsonList.GetLength(); ++filtersIndex)
+   {
+     filtersJsonList[filtersIndex].AsObject(m_filters[filtersIndex].Jsonize());
+   }
+   payload.WithArray("Filters", std::move(filtersJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ListServicesRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.ListServices"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListServicesResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListServicesResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListServicesResult::ListServicesResult()
+{
+}
+
+ListServicesResult::ListServicesResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListServicesResult& ListServicesResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Services"))
+  {
+    Array<JsonView> servicesJsonList = jsonValue.GetArray("Services");
+    for(unsigned servicesIndex = 0; servicesIndex < servicesJsonList.GetLength(); ++servicesIndex)
+    {
+      m_services.push_back(servicesJsonList[servicesIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("NextToken"))
+  {
+    m_nextToken = jsonValue.GetString("NextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListTagsForResourceRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListTagsForResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListTagsForResourceRequest::ListTagsForResourceRequest() : 
+    m_resourceARNHasBeenSet(false)
+{
+}
+
+Aws::String ListTagsForResourceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_resourceARNHasBeenSet)
+  {
+   payload.WithString("ResourceARN", m_resourceARN);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ListTagsForResourceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.ListTagsForResource"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ListTagsForResourceResult.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ListTagsForResourceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListTagsForResourceResult::ListTagsForResourceResult()
+{
+}
+
+ListTagsForResourceResult::ListTagsForResourceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListTagsForResourceResult& ListTagsForResourceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Tags"))
+  {
+    Array<JsonView> tagsJsonList = jsonValue.GetArray("Tags");
+    for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+    {
+      m_tags.push_back(tagsJsonList[tagsIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/Namespace.cpp

@@ -0,0 +1,181 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/Namespace.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+Namespace::Namespace() : 
+    m_idHasBeenSet(false),
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_type(NamespaceType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_serviceCount(0),
+    m_serviceCountHasBeenSet(false),
+    m_propertiesHasBeenSet(false),
+    m_createDateHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false)
+{
+}
+
+Namespace::Namespace(JsonView jsonValue) : 
+    m_idHasBeenSet(false),
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_type(NamespaceType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_serviceCount(0),
+    m_serviceCountHasBeenSet(false),
+    m_propertiesHasBeenSet(false),
+    m_createDateHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Namespace& Namespace::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Id"))
+  {
+    m_id = jsonValue.GetString("Id");
+
+    m_idHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Arn"))
+  {
+    m_arn = jsonValue.GetString("Arn");
+
+    m_arnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = jsonValue.GetString("Name");
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Type"))
+  {
+    m_type = NamespaceTypeMapper::GetNamespaceTypeForName(jsonValue.GetString("Type"));
+
+    m_typeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Description"))
+  {
+    m_description = jsonValue.GetString("Description");
+
+    m_descriptionHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ServiceCount"))
+  {
+    m_serviceCount = jsonValue.GetInteger("ServiceCount");
+
+    m_serviceCountHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Properties"))
+  {
+    m_properties = jsonValue.GetObject("Properties");
+
+    m_propertiesHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreateDate"))
+  {
+    m_createDate = jsonValue.GetDouble("CreateDate");
+
+    m_createDateHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreatorRequestId"))
+  {
+    m_creatorRequestId = jsonValue.GetString("CreatorRequestId");
+
+    m_creatorRequestIdHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Namespace::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("Arn", m_arn);
+
+  }
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("Type", NamespaceTypeMapper::GetNameForNamespaceType(m_type));
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_serviceCountHasBeenSet)
+  {
+   payload.WithInteger("ServiceCount", m_serviceCount);
+
+  }
+
+  if(m_propertiesHasBeenSet)
+  {
+   payload.WithObject("Properties", m_properties.Jsonize());
+
+  }
+
+  if(m_createDateHasBeenSet)
+  {
+   payload.WithDouble("CreateDate", m_createDate.SecondsWithMSPrecision());
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/NamespaceAlreadyExists.cpp

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/NamespaceAlreadyExists.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+NamespaceAlreadyExists::NamespaceAlreadyExists() : 
+    m_messageHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false),
+    m_namespaceIdHasBeenSet(false)
+{
+}
+
+NamespaceAlreadyExists::NamespaceAlreadyExists(JsonView jsonValue) : 
+    m_messageHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false),
+    m_namespaceIdHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+NamespaceAlreadyExists& NamespaceAlreadyExists::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Message"))
+  {
+    m_message = jsonValue.GetString("Message");
+
+    m_messageHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreatorRequestId"))
+  {
+    m_creatorRequestId = jsonValue.GetString("CreatorRequestId");
+
+    m_creatorRequestIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("NamespaceId"))
+  {
+    m_namespaceId = jsonValue.GetString("NamespaceId");
+
+    m_namespaceIdHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue NamespaceAlreadyExists::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_messageHasBeenSet)
+  {
+   payload.WithString("Message", m_message);
+
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  if(m_namespaceIdHasBeenSet)
+  {
+   payload.WithString("NamespaceId", m_namespaceId);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/NamespaceFilter.cpp

@@ -0,0 +1,99 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/NamespaceFilter.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+NamespaceFilter::NamespaceFilter() : 
+    m_name(NamespaceFilterName::NOT_SET),
+    m_nameHasBeenSet(false),
+    m_valuesHasBeenSet(false),
+    m_condition(FilterCondition::NOT_SET),
+    m_conditionHasBeenSet(false)
+{
+}
+
+NamespaceFilter::NamespaceFilter(JsonView jsonValue) : 
+    m_name(NamespaceFilterName::NOT_SET),
+    m_nameHasBeenSet(false),
+    m_valuesHasBeenSet(false),
+    m_condition(FilterCondition::NOT_SET),
+    m_conditionHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+NamespaceFilter& NamespaceFilter::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = NamespaceFilterNameMapper::GetNamespaceFilterNameForName(jsonValue.GetString("Name"));
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Values"))
+  {
+    Array<JsonView> valuesJsonList = jsonValue.GetArray("Values");
+    for(unsigned valuesIndex = 0; valuesIndex < valuesJsonList.GetLength(); ++valuesIndex)
+    {
+      m_values.push_back(valuesJsonList[valuesIndex].AsString());
+    }
+    m_valuesHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Condition"))
+  {
+    m_condition = FilterConditionMapper::GetFilterConditionForName(jsonValue.GetString("Condition"));
+
+    m_conditionHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue NamespaceFilter::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", NamespaceFilterNameMapper::GetNameForNamespaceFilterName(m_name));
+  }
+
+  if(m_valuesHasBeenSet)
+  {
+   Array<JsonValue> valuesJsonList(m_values.size());
+   for(unsigned valuesIndex = 0; valuesIndex < valuesJsonList.GetLength(); ++valuesIndex)
+   {
+     valuesJsonList[valuesIndex].AsString(m_values[valuesIndex]);
+   }
+   payload.WithArray("Values", std::move(valuesJsonList));
+
+  }
+
+  if(m_conditionHasBeenSet)
+  {
+   payload.WithString("Condition", FilterConditionMapper::GetNameForFilterCondition(m_condition));
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/NamespaceFilterName.cpp

@@ -0,0 +1,63 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/NamespaceFilterName.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace NamespaceFilterNameMapper
+      {
+
+        static const int TYPE_HASH = HashingUtils::HashString("TYPE");
+
+
+        NamespaceFilterName GetNamespaceFilterNameForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == TYPE_HASH)
+          {
+            return NamespaceFilterName::TYPE;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<NamespaceFilterName>(hashCode);
+          }
+
+          return NamespaceFilterName::NOT_SET;
+        }
+
+        Aws::String GetNameForNamespaceFilterName(NamespaceFilterName enumValue)
+        {
+          switch(enumValue)
+          {
+          case NamespaceFilterName::TYPE:
+            return "TYPE";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace NamespaceFilterNameMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/NamespaceProperties.cpp

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/NamespaceProperties.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+NamespaceProperties::NamespaceProperties() : 
+    m_dnsPropertiesHasBeenSet(false),
+    m_httpPropertiesHasBeenSet(false)
+{
+}
+
+NamespaceProperties::NamespaceProperties(JsonView jsonValue) : 
+    m_dnsPropertiesHasBeenSet(false),
+    m_httpPropertiesHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+NamespaceProperties& NamespaceProperties::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("DnsProperties"))
+  {
+    m_dnsProperties = jsonValue.GetObject("DnsProperties");
+
+    m_dnsPropertiesHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HttpProperties"))
+  {
+    m_httpProperties = jsonValue.GetObject("HttpProperties");
+
+    m_httpPropertiesHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue NamespaceProperties::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_dnsPropertiesHasBeenSet)
+  {
+   payload.WithObject("DnsProperties", m_dnsProperties.Jsonize());
+
+  }
+
+  if(m_httpPropertiesHasBeenSet)
+  {
+   payload.WithObject("HttpProperties", m_httpProperties.Jsonize());
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/NamespaceSummary.cpp

@@ -0,0 +1,166 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/NamespaceSummary.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+NamespaceSummary::NamespaceSummary() : 
+    m_idHasBeenSet(false),
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_type(NamespaceType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_serviceCount(0),
+    m_serviceCountHasBeenSet(false),
+    m_propertiesHasBeenSet(false),
+    m_createDateHasBeenSet(false)
+{
+}
+
+NamespaceSummary::NamespaceSummary(JsonView jsonValue) : 
+    m_idHasBeenSet(false),
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_type(NamespaceType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_serviceCount(0),
+    m_serviceCountHasBeenSet(false),
+    m_propertiesHasBeenSet(false),
+    m_createDateHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+NamespaceSummary& NamespaceSummary::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Id"))
+  {
+    m_id = jsonValue.GetString("Id");
+
+    m_idHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Arn"))
+  {
+    m_arn = jsonValue.GetString("Arn");
+
+    m_arnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = jsonValue.GetString("Name");
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Type"))
+  {
+    m_type = NamespaceTypeMapper::GetNamespaceTypeForName(jsonValue.GetString("Type"));
+
+    m_typeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Description"))
+  {
+    m_description = jsonValue.GetString("Description");
+
+    m_descriptionHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ServiceCount"))
+  {
+    m_serviceCount = jsonValue.GetInteger("ServiceCount");
+
+    m_serviceCountHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Properties"))
+  {
+    m_properties = jsonValue.GetObject("Properties");
+
+    m_propertiesHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreateDate"))
+  {
+    m_createDate = jsonValue.GetDouble("CreateDate");
+
+    m_createDateHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue NamespaceSummary::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("Arn", m_arn);
+
+  }
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("Type", NamespaceTypeMapper::GetNameForNamespaceType(m_type));
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_serviceCountHasBeenSet)
+  {
+   payload.WithInteger("ServiceCount", m_serviceCount);
+
+  }
+
+  if(m_propertiesHasBeenSet)
+  {
+   payload.WithObject("Properties", m_properties.Jsonize());
+
+  }
+
+  if(m_createDateHasBeenSet)
+  {
+   payload.WithDouble("CreateDate", m_createDate.SecondsWithMSPrecision());
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/NamespaceType.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/NamespaceType.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace NamespaceTypeMapper
+      {
+
+        static const int DNS_PUBLIC_HASH = HashingUtils::HashString("DNS_PUBLIC");
+        static const int DNS_PRIVATE_HASH = HashingUtils::HashString("DNS_PRIVATE");
+        static const int HTTP_HASH = HashingUtils::HashString("HTTP");
+
+
+        NamespaceType GetNamespaceTypeForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == DNS_PUBLIC_HASH)
+          {
+            return NamespaceType::DNS_PUBLIC;
+          }
+          else if (hashCode == DNS_PRIVATE_HASH)
+          {
+            return NamespaceType::DNS_PRIVATE;
+          }
+          else if (hashCode == HTTP_HASH)
+          {
+            return NamespaceType::HTTP;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<NamespaceType>(hashCode);
+          }
+
+          return NamespaceType::NOT_SET;
+        }
+
+        Aws::String GetNameForNamespaceType(NamespaceType enumValue)
+        {
+          switch(enumValue)
+          {
+          case NamespaceType::DNS_PUBLIC:
+            return "DNS_PUBLIC";
+          case NamespaceType::DNS_PRIVATE:
+            return "DNS_PRIVATE";
+          case NamespaceType::HTTP:
+            return "HTTP";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace NamespaceTypeMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/Operation.cpp

@@ -0,0 +1,172 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/Operation.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+Operation::Operation() : 
+    m_idHasBeenSet(false),
+    m_type(OperationType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_status(OperationStatus::NOT_SET),
+    m_statusHasBeenSet(false),
+    m_errorMessageHasBeenSet(false),
+    m_errorCodeHasBeenSet(false),
+    m_createDateHasBeenSet(false),
+    m_updateDateHasBeenSet(false),
+    m_targetsHasBeenSet(false)
+{
+}
+
+Operation::Operation(JsonView jsonValue) : 
+    m_idHasBeenSet(false),
+    m_type(OperationType::NOT_SET),
+    m_typeHasBeenSet(false),
+    m_status(OperationStatus::NOT_SET),
+    m_statusHasBeenSet(false),
+    m_errorMessageHasBeenSet(false),
+    m_errorCodeHasBeenSet(false),
+    m_createDateHasBeenSet(false),
+    m_updateDateHasBeenSet(false),
+    m_targetsHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Operation& Operation::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Id"))
+  {
+    m_id = jsonValue.GetString("Id");
+
+    m_idHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Type"))
+  {
+    m_type = OperationTypeMapper::GetOperationTypeForName(jsonValue.GetString("Type"));
+
+    m_typeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Status"))
+  {
+    m_status = OperationStatusMapper::GetOperationStatusForName(jsonValue.GetString("Status"));
+
+    m_statusHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ErrorMessage"))
+  {
+    m_errorMessage = jsonValue.GetString("ErrorMessage");
+
+    m_errorMessageHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ErrorCode"))
+  {
+    m_errorCode = jsonValue.GetString("ErrorCode");
+
+    m_errorCodeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreateDate"))
+  {
+    m_createDate = jsonValue.GetDouble("CreateDate");
+
+    m_createDateHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("UpdateDate"))
+  {
+    m_updateDate = jsonValue.GetDouble("UpdateDate");
+
+    m_updateDateHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Targets"))
+  {
+    Aws::Map<Aws::String, JsonView> targetsJsonMap = jsonValue.GetObject("Targets").GetAllObjects();
+    for(auto& targetsItem : targetsJsonMap)
+    {
+      m_targets[OperationTargetTypeMapper::GetOperationTargetTypeForName(targetsItem.first)] = targetsItem.second.AsString();
+    }
+    m_targetsHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Operation::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("Type", OperationTypeMapper::GetNameForOperationType(m_type));
+  }
+
+  if(m_statusHasBeenSet)
+  {
+   payload.WithString("Status", OperationStatusMapper::GetNameForOperationStatus(m_status));
+  }
+
+  if(m_errorMessageHasBeenSet)
+  {
+   payload.WithString("ErrorMessage", m_errorMessage);
+
+  }
+
+  if(m_errorCodeHasBeenSet)
+  {
+   payload.WithString("ErrorCode", m_errorCode);
+
+  }
+
+  if(m_createDateHasBeenSet)
+  {
+   payload.WithDouble("CreateDate", m_createDate.SecondsWithMSPrecision());
+  }
+
+  if(m_updateDateHasBeenSet)
+  {
+   payload.WithDouble("UpdateDate", m_updateDate.SecondsWithMSPrecision());
+  }
+
+  if(m_targetsHasBeenSet)
+  {
+   JsonValue targetsJsonMap;
+   for(auto& targetsItem : m_targets)
+   {
+     targetsJsonMap.WithString(OperationTargetTypeMapper::GetNameForOperationTargetType(targetsItem.first), targetsItem.second);
+   }
+   payload.WithObject("Targets", std::move(targetsJsonMap));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/OperationFilter.cpp

@@ -0,0 +1,99 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/OperationFilter.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+OperationFilter::OperationFilter() : 
+    m_name(OperationFilterName::NOT_SET),
+    m_nameHasBeenSet(false),
+    m_valuesHasBeenSet(false),
+    m_condition(FilterCondition::NOT_SET),
+    m_conditionHasBeenSet(false)
+{
+}
+
+OperationFilter::OperationFilter(JsonView jsonValue) : 
+    m_name(OperationFilterName::NOT_SET),
+    m_nameHasBeenSet(false),
+    m_valuesHasBeenSet(false),
+    m_condition(FilterCondition::NOT_SET),
+    m_conditionHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+OperationFilter& OperationFilter::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = OperationFilterNameMapper::GetOperationFilterNameForName(jsonValue.GetString("Name"));
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Values"))
+  {
+    Array<JsonView> valuesJsonList = jsonValue.GetArray("Values");
+    for(unsigned valuesIndex = 0; valuesIndex < valuesJsonList.GetLength(); ++valuesIndex)
+    {
+      m_values.push_back(valuesJsonList[valuesIndex].AsString());
+    }
+    m_valuesHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Condition"))
+  {
+    m_condition = FilterConditionMapper::GetFilterConditionForName(jsonValue.GetString("Condition"));
+
+    m_conditionHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue OperationFilter::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", OperationFilterNameMapper::GetNameForOperationFilterName(m_name));
+  }
+
+  if(m_valuesHasBeenSet)
+  {
+   Array<JsonValue> valuesJsonList(m_values.size());
+   for(unsigned valuesIndex = 0; valuesIndex < valuesJsonList.GetLength(); ++valuesIndex)
+   {
+     valuesJsonList[valuesIndex].AsString(m_values[valuesIndex]);
+   }
+   payload.WithArray("Values", std::move(valuesJsonList));
+
+  }
+
+  if(m_conditionHasBeenSet)
+  {
+   payload.WithString("Condition", FilterConditionMapper::GetNameForFilterCondition(m_condition));
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/OperationFilterName.cpp

@@ -0,0 +1,91 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/OperationFilterName.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace OperationFilterNameMapper
+      {
+
+        static const int NAMESPACE_ID_HASH = HashingUtils::HashString("NAMESPACE_ID");
+        static const int SERVICE_ID_HASH = HashingUtils::HashString("SERVICE_ID");
+        static const int STATUS_HASH = HashingUtils::HashString("STATUS");
+        static const int TYPE_HASH = HashingUtils::HashString("TYPE");
+        static const int UPDATE_DATE_HASH = HashingUtils::HashString("UPDATE_DATE");
+
+
+        OperationFilterName GetOperationFilterNameForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == NAMESPACE_ID_HASH)
+          {
+            return OperationFilterName::NAMESPACE_ID;
+          }
+          else if (hashCode == SERVICE_ID_HASH)
+          {
+            return OperationFilterName::SERVICE_ID;
+          }
+          else if (hashCode == STATUS_HASH)
+          {
+            return OperationFilterName::STATUS;
+          }
+          else if (hashCode == TYPE_HASH)
+          {
+            return OperationFilterName::TYPE;
+          }
+          else if (hashCode == UPDATE_DATE_HASH)
+          {
+            return OperationFilterName::UPDATE_DATE;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<OperationFilterName>(hashCode);
+          }
+
+          return OperationFilterName::NOT_SET;
+        }
+
+        Aws::String GetNameForOperationFilterName(OperationFilterName enumValue)
+        {
+          switch(enumValue)
+          {
+          case OperationFilterName::NAMESPACE_ID:
+            return "NAMESPACE_ID";
+          case OperationFilterName::SERVICE_ID:
+            return "SERVICE_ID";
+          case OperationFilterName::STATUS:
+            return "STATUS";
+          case OperationFilterName::TYPE:
+            return "TYPE";
+          case OperationFilterName::UPDATE_DATE:
+            return "UPDATE_DATE";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace OperationFilterNameMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/OperationStatus.cpp

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/OperationStatus.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace OperationStatusMapper
+      {
+
+        static const int SUBMITTED_HASH = HashingUtils::HashString("SUBMITTED");
+        static const int PENDING_HASH = HashingUtils::HashString("PENDING");
+        static const int SUCCESS_HASH = HashingUtils::HashString("SUCCESS");
+        static const int FAIL_HASH = HashingUtils::HashString("FAIL");
+
+
+        OperationStatus GetOperationStatusForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == SUBMITTED_HASH)
+          {
+            return OperationStatus::SUBMITTED;
+          }
+          else if (hashCode == PENDING_HASH)
+          {
+            return OperationStatus::PENDING;
+          }
+          else if (hashCode == SUCCESS_HASH)
+          {
+            return OperationStatus::SUCCESS;
+          }
+          else if (hashCode == FAIL_HASH)
+          {
+            return OperationStatus::FAIL;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<OperationStatus>(hashCode);
+          }
+
+          return OperationStatus::NOT_SET;
+        }
+
+        Aws::String GetNameForOperationStatus(OperationStatus enumValue)
+        {
+          switch(enumValue)
+          {
+          case OperationStatus::SUBMITTED:
+            return "SUBMITTED";
+          case OperationStatus::PENDING:
+            return "PENDING";
+          case OperationStatus::SUCCESS:
+            return "SUCCESS";
+          case OperationStatus::FAIL:
+            return "FAIL";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace OperationStatusMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/OperationSummary.cpp

@@ -0,0 +1,75 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/OperationSummary.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+OperationSummary::OperationSummary() : 
+    m_idHasBeenSet(false),
+    m_status(OperationStatus::NOT_SET),
+    m_statusHasBeenSet(false)
+{
+}
+
+OperationSummary::OperationSummary(JsonView jsonValue) : 
+    m_idHasBeenSet(false),
+    m_status(OperationStatus::NOT_SET),
+    m_statusHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+OperationSummary& OperationSummary::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Id"))
+  {
+    m_id = jsonValue.GetString("Id");
+
+    m_idHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Status"))
+  {
+    m_status = OperationStatusMapper::GetOperationStatusForName(jsonValue.GetString("Status"));
+
+    m_statusHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue OperationSummary::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_statusHasBeenSet)
+  {
+   payload.WithString("Status", OperationStatusMapper::GetNameForOperationStatus(m_status));
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/OperationTargetType.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/OperationTargetType.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace OperationTargetTypeMapper
+      {
+
+        static const int NAMESPACE_HASH = HashingUtils::HashString("NAMESPACE");
+        static const int SERVICE_HASH = HashingUtils::HashString("SERVICE");
+        static const int INSTANCE_HASH = HashingUtils::HashString("INSTANCE");
+
+
+        OperationTargetType GetOperationTargetTypeForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == NAMESPACE_HASH)
+          {
+            return OperationTargetType::NAMESPACE;
+          }
+          else if (hashCode == SERVICE_HASH)
+          {
+            return OperationTargetType::SERVICE;
+          }
+          else if (hashCode == INSTANCE_HASH)
+          {
+            return OperationTargetType::INSTANCE;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<OperationTargetType>(hashCode);
+          }
+
+          return OperationTargetType::NOT_SET;
+        }
+
+        Aws::String GetNameForOperationTargetType(OperationTargetType enumValue)
+        {
+          switch(enumValue)
+          {
+          case OperationTargetType::NAMESPACE:
+            return "NAMESPACE";
+          case OperationTargetType::SERVICE:
+            return "SERVICE";
+          case OperationTargetType::INSTANCE:
+            return "INSTANCE";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace OperationTargetTypeMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/OperationType.cpp

@@ -0,0 +1,91 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/OperationType.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace OperationTypeMapper
+      {
+
+        static const int CREATE_NAMESPACE_HASH = HashingUtils::HashString("CREATE_NAMESPACE");
+        static const int DELETE_NAMESPACE_HASH = HashingUtils::HashString("DELETE_NAMESPACE");
+        static const int UPDATE_SERVICE_HASH = HashingUtils::HashString("UPDATE_SERVICE");
+        static const int REGISTER_INSTANCE_HASH = HashingUtils::HashString("REGISTER_INSTANCE");
+        static const int DEREGISTER_INSTANCE_HASH = HashingUtils::HashString("DEREGISTER_INSTANCE");
+
+
+        OperationType GetOperationTypeForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == CREATE_NAMESPACE_HASH)
+          {
+            return OperationType::CREATE_NAMESPACE;
+          }
+          else if (hashCode == DELETE_NAMESPACE_HASH)
+          {
+            return OperationType::DELETE_NAMESPACE;
+          }
+          else if (hashCode == UPDATE_SERVICE_HASH)
+          {
+            return OperationType::UPDATE_SERVICE;
+          }
+          else if (hashCode == REGISTER_INSTANCE_HASH)
+          {
+            return OperationType::REGISTER_INSTANCE;
+          }
+          else if (hashCode == DEREGISTER_INSTANCE_HASH)
+          {
+            return OperationType::DEREGISTER_INSTANCE;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<OperationType>(hashCode);
+          }
+
+          return OperationType::NOT_SET;
+        }
+
+        Aws::String GetNameForOperationType(OperationType enumValue)
+        {
+          switch(enumValue)
+          {
+          case OperationType::CREATE_NAMESPACE:
+            return "CREATE_NAMESPACE";
+          case OperationType::DELETE_NAMESPACE:
+            return "DELETE_NAMESPACE";
+          case OperationType::UPDATE_SERVICE:
+            return "UPDATE_SERVICE";
+          case OperationType::REGISTER_INSTANCE:
+            return "REGISTER_INSTANCE";
+          case OperationType::DEREGISTER_INSTANCE:
+            return "DEREGISTER_INSTANCE";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace OperationTypeMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/RecordType.cpp

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/RecordType.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace RecordTypeMapper
+      {
+
+        static const int SRV_HASH = HashingUtils::HashString("SRV");
+        static const int A_HASH = HashingUtils::HashString("A");
+        static const int AAAA_HASH = HashingUtils::HashString("AAAA");
+        static const int CNAME_HASH = HashingUtils::HashString("CNAME");
+
+
+        RecordType GetRecordTypeForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == SRV_HASH)
+          {
+            return RecordType::SRV;
+          }
+          else if (hashCode == A_HASH)
+          {
+            return RecordType::A;
+          }
+          else if (hashCode == AAAA_HASH)
+          {
+            return RecordType::AAAA;
+          }
+          else if (hashCode == CNAME_HASH)
+          {
+            return RecordType::CNAME;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<RecordType>(hashCode);
+          }
+
+          return RecordType::NOT_SET;
+        }
+
+        Aws::String GetNameForRecordType(RecordType enumValue)
+        {
+          switch(enumValue)
+          {
+          case RecordType::SRV:
+            return "SRV";
+          case RecordType::A:
+            return "A";
+          case RecordType::AAAA:
+            return "AAAA";
+          case RecordType::CNAME:
+            return "CNAME";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace RecordTypeMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/RegisterInstanceRequest.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/RegisterInstanceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+RegisterInstanceRequest::RegisterInstanceRequest() : 
+    m_serviceIdHasBeenSet(false),
+    m_instanceIdHasBeenSet(false),
+    m_creatorRequestId(Aws::Utils::UUID::RandomUUID()),
+    m_creatorRequestIdHasBeenSet(true),
+    m_attributesHasBeenSet(false)
+{
+}
+
+Aws::String RegisterInstanceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_serviceIdHasBeenSet)
+  {
+   payload.WithString("ServiceId", m_serviceId);
+
+  }
+
+  if(m_instanceIdHasBeenSet)
+  {
+   payload.WithString("InstanceId", m_instanceId);
+
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  if(m_attributesHasBeenSet)
+  {
+   JsonValue attributesJsonMap;
+   for(auto& attributesItem : m_attributes)
+   {
+     attributesJsonMap.WithString(attributesItem.first, attributesItem.second);
+   }
+   payload.WithObject("Attributes", std::move(attributesJsonMap));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection RegisterInstanceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.RegisterInstance"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/RegisterInstanceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/RegisterInstanceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+RegisterInstanceResult::RegisterInstanceResult()
+{
+}
+
+RegisterInstanceResult::RegisterInstanceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+RegisterInstanceResult& RegisterInstanceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("OperationId"))
+  {
+    m_operationId = jsonValue.GetString("OperationId");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/RoutingPolicy.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/RoutingPolicy.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace RoutingPolicyMapper
+      {
+
+        static const int MULTIVALUE_HASH = HashingUtils::HashString("MULTIVALUE");
+        static const int WEIGHTED_HASH = HashingUtils::HashString("WEIGHTED");
+
+
+        RoutingPolicy GetRoutingPolicyForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == MULTIVALUE_HASH)
+          {
+            return RoutingPolicy::MULTIVALUE;
+          }
+          else if (hashCode == WEIGHTED_HASH)
+          {
+            return RoutingPolicy::WEIGHTED;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<RoutingPolicy>(hashCode);
+          }
+
+          return RoutingPolicy::NOT_SET;
+        }
+
+        Aws::String GetNameForRoutingPolicy(RoutingPolicy enumValue)
+        {
+          switch(enumValue)
+          {
+          case RoutingPolicy::MULTIVALUE:
+            return "MULTIVALUE";
+          case RoutingPolicy::WEIGHTED:
+            return "WEIGHTED";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace RoutingPolicyMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/Service.cpp

@@ -0,0 +1,210 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/Service.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+Service::Service() : 
+    m_idHasBeenSet(false),
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_namespaceIdHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_instanceCount(0),
+    m_instanceCountHasBeenSet(false),
+    m_dnsConfigHasBeenSet(false),
+    m_healthCheckConfigHasBeenSet(false),
+    m_healthCheckCustomConfigHasBeenSet(false),
+    m_createDateHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false)
+{
+}
+
+Service::Service(JsonView jsonValue) : 
+    m_idHasBeenSet(false),
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_namespaceIdHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_instanceCount(0),
+    m_instanceCountHasBeenSet(false),
+    m_dnsConfigHasBeenSet(false),
+    m_healthCheckConfigHasBeenSet(false),
+    m_healthCheckCustomConfigHasBeenSet(false),
+    m_createDateHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Service& Service::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Id"))
+  {
+    m_id = jsonValue.GetString("Id");
+
+    m_idHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Arn"))
+  {
+    m_arn = jsonValue.GetString("Arn");
+
+    m_arnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = jsonValue.GetString("Name");
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("NamespaceId"))
+  {
+    m_namespaceId = jsonValue.GetString("NamespaceId");
+
+    m_namespaceIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Description"))
+  {
+    m_description = jsonValue.GetString("Description");
+
+    m_descriptionHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("InstanceCount"))
+  {
+    m_instanceCount = jsonValue.GetInteger("InstanceCount");
+
+    m_instanceCountHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("DnsConfig"))
+  {
+    m_dnsConfig = jsonValue.GetObject("DnsConfig");
+
+    m_dnsConfigHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HealthCheckConfig"))
+  {
+    m_healthCheckConfig = jsonValue.GetObject("HealthCheckConfig");
+
+    m_healthCheckConfigHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HealthCheckCustomConfig"))
+  {
+    m_healthCheckCustomConfig = jsonValue.GetObject("HealthCheckCustomConfig");
+
+    m_healthCheckCustomConfigHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreateDate"))
+  {
+    m_createDate = jsonValue.GetDouble("CreateDate");
+
+    m_createDateHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreatorRequestId"))
+  {
+    m_creatorRequestId = jsonValue.GetString("CreatorRequestId");
+
+    m_creatorRequestIdHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Service::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("Arn", m_arn);
+
+  }
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_namespaceIdHasBeenSet)
+  {
+   payload.WithString("NamespaceId", m_namespaceId);
+
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_instanceCountHasBeenSet)
+  {
+   payload.WithInteger("InstanceCount", m_instanceCount);
+
+  }
+
+  if(m_dnsConfigHasBeenSet)
+  {
+   payload.WithObject("DnsConfig", m_dnsConfig.Jsonize());
+
+  }
+
+  if(m_healthCheckConfigHasBeenSet)
+  {
+   payload.WithObject("HealthCheckConfig", m_healthCheckConfig.Jsonize());
+
+  }
+
+  if(m_healthCheckCustomConfigHasBeenSet)
+  {
+   payload.WithObject("HealthCheckCustomConfig", m_healthCheckCustomConfig.Jsonize());
+
+  }
+
+  if(m_createDateHasBeenSet)
+  {
+   payload.WithDouble("CreateDate", m_createDate.SecondsWithMSPrecision());
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ServiceAlreadyExists.cpp

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ServiceAlreadyExists.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+ServiceAlreadyExists::ServiceAlreadyExists() : 
+    m_messageHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false),
+    m_serviceIdHasBeenSet(false)
+{
+}
+
+ServiceAlreadyExists::ServiceAlreadyExists(JsonView jsonValue) : 
+    m_messageHasBeenSet(false),
+    m_creatorRequestIdHasBeenSet(false),
+    m_serviceIdHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+ServiceAlreadyExists& ServiceAlreadyExists::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Message"))
+  {
+    m_message = jsonValue.GetString("Message");
+
+    m_messageHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreatorRequestId"))
+  {
+    m_creatorRequestId = jsonValue.GetString("CreatorRequestId");
+
+    m_creatorRequestIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ServiceId"))
+  {
+    m_serviceId = jsonValue.GetString("ServiceId");
+
+    m_serviceIdHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue ServiceAlreadyExists::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_messageHasBeenSet)
+  {
+   payload.WithString("Message", m_message);
+
+  }
+
+  if(m_creatorRequestIdHasBeenSet)
+  {
+   payload.WithString("CreatorRequestId", m_creatorRequestId);
+
+  }
+
+  if(m_serviceIdHasBeenSet)
+  {
+   payload.WithString("ServiceId", m_serviceId);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ServiceChange.cpp

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ServiceChange.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+ServiceChange::ServiceChange() : 
+    m_descriptionHasBeenSet(false),
+    m_dnsConfigHasBeenSet(false),
+    m_healthCheckConfigHasBeenSet(false)
+{
+}
+
+ServiceChange::ServiceChange(JsonView jsonValue) : 
+    m_descriptionHasBeenSet(false),
+    m_dnsConfigHasBeenSet(false),
+    m_healthCheckConfigHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+ServiceChange& ServiceChange::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Description"))
+  {
+    m_description = jsonValue.GetString("Description");
+
+    m_descriptionHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("DnsConfig"))
+  {
+    m_dnsConfig = jsonValue.GetObject("DnsConfig");
+
+    m_dnsConfigHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HealthCheckConfig"))
+  {
+    m_healthCheckConfig = jsonValue.GetObject("HealthCheckConfig");
+
+    m_healthCheckConfigHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue ServiceChange::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_dnsConfigHasBeenSet)
+  {
+   payload.WithObject("DnsConfig", m_dnsConfig.Jsonize());
+
+  }
+
+  if(m_healthCheckConfigHasBeenSet)
+  {
+   payload.WithObject("HealthCheckConfig", m_healthCheckConfig.Jsonize());
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ServiceFilter.cpp

@@ -0,0 +1,99 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ServiceFilter.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+ServiceFilter::ServiceFilter() : 
+    m_name(ServiceFilterName::NOT_SET),
+    m_nameHasBeenSet(false),
+    m_valuesHasBeenSet(false),
+    m_condition(FilterCondition::NOT_SET),
+    m_conditionHasBeenSet(false)
+{
+}
+
+ServiceFilter::ServiceFilter(JsonView jsonValue) : 
+    m_name(ServiceFilterName::NOT_SET),
+    m_nameHasBeenSet(false),
+    m_valuesHasBeenSet(false),
+    m_condition(FilterCondition::NOT_SET),
+    m_conditionHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+ServiceFilter& ServiceFilter::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = ServiceFilterNameMapper::GetServiceFilterNameForName(jsonValue.GetString("Name"));
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Values"))
+  {
+    Array<JsonView> valuesJsonList = jsonValue.GetArray("Values");
+    for(unsigned valuesIndex = 0; valuesIndex < valuesJsonList.GetLength(); ++valuesIndex)
+    {
+      m_values.push_back(valuesJsonList[valuesIndex].AsString());
+    }
+    m_valuesHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Condition"))
+  {
+    m_condition = FilterConditionMapper::GetFilterConditionForName(jsonValue.GetString("Condition"));
+
+    m_conditionHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue ServiceFilter::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", ServiceFilterNameMapper::GetNameForServiceFilterName(m_name));
+  }
+
+  if(m_valuesHasBeenSet)
+  {
+   Array<JsonValue> valuesJsonList(m_values.size());
+   for(unsigned valuesIndex = 0; valuesIndex < valuesJsonList.GetLength(); ++valuesIndex)
+   {
+     valuesJsonList[valuesIndex].AsString(m_values[valuesIndex]);
+   }
+   payload.WithArray("Values", std::move(valuesJsonList));
+
+  }
+
+  if(m_conditionHasBeenSet)
+  {
+   payload.WithString("Condition", FilterConditionMapper::GetNameForFilterCondition(m_condition));
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ServiceFilterName.cpp

@@ -0,0 +1,63 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ServiceFilterName.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace ServiceDiscovery
+  {
+    namespace Model
+    {
+      namespace ServiceFilterNameMapper
+      {
+
+        static const int NAMESPACE_ID_HASH = HashingUtils::HashString("NAMESPACE_ID");
+
+
+        ServiceFilterName GetServiceFilterNameForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == NAMESPACE_ID_HASH)
+          {
+            return ServiceFilterName::NAMESPACE_ID;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<ServiceFilterName>(hashCode);
+          }
+
+          return ServiceFilterName::NOT_SET;
+        }
+
+        Aws::String GetNameForServiceFilterName(ServiceFilterName enumValue)
+        {
+          switch(enumValue)
+          {
+          case ServiceFilterName::NAMESPACE_ID:
+            return "NAMESPACE_ID";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace ServiceFilterNameMapper
+    } // namespace Model
+  } // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/ServiceSummary.cpp

@@ -0,0 +1,180 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/ServiceSummary.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+ServiceSummary::ServiceSummary() : 
+    m_idHasBeenSet(false),
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_instanceCount(0),
+    m_instanceCountHasBeenSet(false),
+    m_dnsConfigHasBeenSet(false),
+    m_healthCheckConfigHasBeenSet(false),
+    m_healthCheckCustomConfigHasBeenSet(false),
+    m_createDateHasBeenSet(false)
+{
+}
+
+ServiceSummary::ServiceSummary(JsonView jsonValue) : 
+    m_idHasBeenSet(false),
+    m_arnHasBeenSet(false),
+    m_nameHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_instanceCount(0),
+    m_instanceCountHasBeenSet(false),
+    m_dnsConfigHasBeenSet(false),
+    m_healthCheckConfigHasBeenSet(false),
+    m_healthCheckCustomConfigHasBeenSet(false),
+    m_createDateHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+ServiceSummary& ServiceSummary::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Id"))
+  {
+    m_id = jsonValue.GetString("Id");
+
+    m_idHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Arn"))
+  {
+    m_arn = jsonValue.GetString("Arn");
+
+    m_arnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = jsonValue.GetString("Name");
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Description"))
+  {
+    m_description = jsonValue.GetString("Description");
+
+    m_descriptionHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("InstanceCount"))
+  {
+    m_instanceCount = jsonValue.GetInteger("InstanceCount");
+
+    m_instanceCountHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("DnsConfig"))
+  {
+    m_dnsConfig = jsonValue.GetObject("DnsConfig");
+
+    m_dnsConfigHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HealthCheckConfig"))
+  {
+    m_healthCheckConfig = jsonValue.GetObject("HealthCheckConfig");
+
+    m_healthCheckConfigHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HealthCheckCustomConfig"))
+  {
+    m_healthCheckCustomConfig = jsonValue.GetObject("HealthCheckCustomConfig");
+
+    m_healthCheckCustomConfigHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CreateDate"))
+  {
+    m_createDate = jsonValue.GetDouble("CreateDate");
+
+    m_createDateHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue ServiceSummary::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("Arn", m_arn);
+
+  }
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+   payload.WithString("Description", m_description);
+
+  }
+
+  if(m_instanceCountHasBeenSet)
+  {
+   payload.WithInteger("InstanceCount", m_instanceCount);
+
+  }
+
+  if(m_dnsConfigHasBeenSet)
+  {
+   payload.WithObject("DnsConfig", m_dnsConfig.Jsonize());
+
+  }
+
+  if(m_healthCheckConfigHasBeenSet)
+  {
+   payload.WithObject("HealthCheckConfig", m_healthCheckConfig.Jsonize());
+
+  }
+
+  if(m_healthCheckCustomConfigHasBeenSet)
+  {
+   payload.WithObject("HealthCheckCustomConfig", m_healthCheckCustomConfig.Jsonize());
+
+  }
+
+  if(m_createDateHasBeenSet)
+  {
+   payload.WithDouble("CreateDate", m_createDate.SecondsWithMSPrecision());
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/Tag.cpp

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/Tag.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+Tag::Tag() : 
+    m_keyHasBeenSet(false),
+    m_valueHasBeenSet(false)
+{
+}
+
+Tag::Tag(JsonView jsonValue) : 
+    m_keyHasBeenSet(false),
+    m_valueHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Tag& Tag::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Key"))
+  {
+    m_key = jsonValue.GetString("Key");
+
+    m_keyHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Value"))
+  {
+    m_value = jsonValue.GetString("Value");
+
+    m_valueHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Tag::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_keyHasBeenSet)
+  {
+   payload.WithString("Key", m_key);
+
+  }
+
+  if(m_valueHasBeenSet)
+  {
+   payload.WithString("Value", m_value);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/TagResourceRequest.cpp

@@ -0,0 +1,55 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/TagResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+TagResourceRequest::TagResourceRequest() : 
+    m_resourceARNHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String TagResourceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_resourceARNHasBeenSet)
+  {
+   payload.WithString("ResourceARN", m_resourceARN);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   Array<JsonValue> tagsJsonList(m_tags.size());
+   for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+   {
+     tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
+   }
+   payload.WithArray("Tags", std::move(tagsJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection TagResourceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.TagResource"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/TagResourceResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/TagResourceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+TagResourceResult::TagResourceResult()
+{
+}
+
+TagResourceResult::TagResourceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+TagResourceResult& TagResourceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/TooManyTagsException.cpp

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/TooManyTagsException.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ServiceDiscovery
+{
+namespace Model
+{
+
+TooManyTagsException::TooManyTagsException() : 
+    m_messageHasBeenSet(false),
+    m_resourceNameHasBeenSet(false)
+{
+}
+
+TooManyTagsException::TooManyTagsException(JsonView jsonValue) : 
+    m_messageHasBeenSet(false),
+    m_resourceNameHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+TooManyTagsException& TooManyTagsException::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Message"))
+  {
+    m_message = jsonValue.GetString("Message");
+
+    m_messageHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ResourceName"))
+  {
+    m_resourceName = jsonValue.GetString("ResourceName");
+
+    m_resourceNameHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue TooManyTagsException::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_messageHasBeenSet)
+  {
+   payload.WithString("Message", m_message);
+
+  }
+
+  if(m_resourceNameHasBeenSet)
+  {
+   payload.WithString("ResourceName", m_resourceName);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace ServiceDiscovery
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/UntagResourceRequest.cpp

@@ -0,0 +1,55 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/UntagResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+UntagResourceRequest::UntagResourceRequest() : 
+    m_resourceARNHasBeenSet(false),
+    m_tagKeysHasBeenSet(false)
+{
+}
+
+Aws::String UntagResourceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_resourceARNHasBeenSet)
+  {
+   payload.WithString("ResourceARN", m_resourceARN);
+
+  }
+
+  if(m_tagKeysHasBeenSet)
+  {
+   Array<JsonValue> tagKeysJsonList(m_tagKeys.size());
+   for(unsigned tagKeysIndex = 0; tagKeysIndex < tagKeysJsonList.GetLength(); ++tagKeysIndex)
+   {
+     tagKeysJsonList[tagKeysIndex].AsString(m_tagKeys[tagKeysIndex]);
+   }
+   payload.WithArray("TagKeys", std::move(tagKeysJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection UntagResourceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.UntagResource"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/UntagResourceResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/UntagResourceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+UntagResourceResult::UntagResourceResult()
+{
+}
+
+UntagResourceResult::UntagResourceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+UntagResourceResult& UntagResourceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/UpdateInstanceCustomHealthStatusRequest.cpp

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/UpdateInstanceCustomHealthStatusRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+UpdateInstanceCustomHealthStatusRequest::UpdateInstanceCustomHealthStatusRequest() : 
+    m_serviceIdHasBeenSet(false),
+    m_instanceIdHasBeenSet(false),
+    m_status(CustomHealthStatus::NOT_SET),
+    m_statusHasBeenSet(false)
+{
+}
+
+Aws::String UpdateInstanceCustomHealthStatusRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_serviceIdHasBeenSet)
+  {
+   payload.WithString("ServiceId", m_serviceId);
+
+  }
+
+  if(m_instanceIdHasBeenSet)
+  {
+   payload.WithString("InstanceId", m_instanceId);
+
+  }
+
+  if(m_statusHasBeenSet)
+  {
+   payload.WithString("Status", CustomHealthStatusMapper::GetNameForCustomHealthStatus(m_status));
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection UpdateInstanceCustomHealthStatusRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.UpdateInstanceCustomHealthStatus"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/UpdateServiceRequest.cpp

@@ -0,0 +1,50 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/UpdateServiceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+UpdateServiceRequest::UpdateServiceRequest() : 
+    m_idHasBeenSet(false),
+    m_serviceHasBeenSet(false)
+{
+}
+
+Aws::String UpdateServiceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_idHasBeenSet)
+  {
+   payload.WithString("Id", m_id);
+
+  }
+
+  if(m_serviceHasBeenSet)
+  {
+   payload.WithObject("Service", m_service.Jsonize());
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection UpdateServiceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "Route53AutoNaming_v20170314.UpdateService"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-servicediscovery/source/model/UpdateServiceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/servicediscovery/model/UpdateServiceResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::ServiceDiscovery::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+UpdateServiceResult::UpdateServiceResult()
+{
+}
+
+UpdateServiceResult::UpdateServiceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+UpdateServiceResult& UpdateServiceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("OperationId"))
+  {
+    m_operationId = jsonValue.GetString("OperationId");
+
+  }
+
+
+
+  return *this;
+}