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

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/IoT1ClickDevicesServiceClient.cpp

@@ -0,0 +1,554 @@
+/**
+ * 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/iot1click-devices/IoT1ClickDevicesServiceClient.h>
+#include <aws/iot1click-devices/IoT1ClickDevicesServiceEndpoint.h>
+#include <aws/iot1click-devices/IoT1ClickDevicesServiceErrorMarshaller.h>
+#include <aws/iot1click-devices/model/ClaimDevicesByClaimCodeRequest.h>
+#include <aws/iot1click-devices/model/DescribeDeviceRequest.h>
+#include <aws/iot1click-devices/model/FinalizeDeviceClaimRequest.h>
+#include <aws/iot1click-devices/model/GetDeviceMethodsRequest.h>
+#include <aws/iot1click-devices/model/InitiateDeviceClaimRequest.h>
+#include <aws/iot1click-devices/model/InvokeDeviceMethodRequest.h>
+#include <aws/iot1click-devices/model/ListDeviceEventsRequest.h>
+#include <aws/iot1click-devices/model/ListDevicesRequest.h>
+#include <aws/iot1click-devices/model/ListTagsForResourceRequest.h>
+#include <aws/iot1click-devices/model/TagResourceRequest.h>
+#include <aws/iot1click-devices/model/UnclaimDeviceRequest.h>
+#include <aws/iot1click-devices/model/UntagResourceRequest.h>
+#include <aws/iot1click-devices/model/UpdateDeviceStateRequest.h>
+
+using namespace Aws;
+using namespace Aws::Auth;
+using namespace Aws::Client;
+using namespace Aws::IoT1ClickDevicesService;
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Http;
+using namespace Aws::Utils::Json;
+
+static const char* SERVICE_NAME = "iot1click";
+static const char* ALLOCATION_TAG = "IoT1ClickDevicesServiceClient";
+
+
+IoT1ClickDevicesServiceClient::IoT1ClickDevicesServiceClient(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<IoT1ClickDevicesServiceErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+IoT1ClickDevicesServiceClient::IoT1ClickDevicesServiceClient(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<IoT1ClickDevicesServiceErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+IoT1ClickDevicesServiceClient::IoT1ClickDevicesServiceClient(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<IoT1ClickDevicesServiceErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+IoT1ClickDevicesServiceClient::~IoT1ClickDevicesServiceClient()
+{
+}
+
+void IoT1ClickDevicesServiceClient::init(const ClientConfiguration& config)
+{
+  SetServiceClientName("IoT 1Click Devices Service");
+  m_configScheme = SchemeMapper::ToString(config.scheme);
+  if (config.endpointOverride.empty())
+  {
+      m_uri = m_configScheme + "://" + IoT1ClickDevicesServiceEndpoint::ForRegion(config.region, config.useDualStack);
+  }
+  else
+  {
+      OverrideEndpoint(config.endpointOverride);
+  }
+}
+
+void IoT1ClickDevicesServiceClient::OverrideEndpoint(const Aws::String& endpoint)
+{
+  if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
+  {
+      m_uri = endpoint;
+  }
+  else
+  {
+      m_uri = m_configScheme + "://" + endpoint;
+  }
+}
+
+ClaimDevicesByClaimCodeOutcome IoT1ClickDevicesServiceClient::ClaimDevicesByClaimCode(const ClaimDevicesByClaimCodeRequest& request) const
+{
+  if (!request.ClaimCodeHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ClaimDevicesByClaimCode", "Required field: ClaimCode, is not set");
+    return ClaimDevicesByClaimCodeOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ClaimCode]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/claims/";
+  ss << request.GetClaimCode();
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ClaimDevicesByClaimCodeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
+}
+
+ClaimDevicesByClaimCodeOutcomeCallable IoT1ClickDevicesServiceClient::ClaimDevicesByClaimCodeCallable(const ClaimDevicesByClaimCodeRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ClaimDevicesByClaimCodeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ClaimDevicesByClaimCode(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::ClaimDevicesByClaimCodeAsync(const ClaimDevicesByClaimCodeRequest& request, const ClaimDevicesByClaimCodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ClaimDevicesByClaimCodeAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::ClaimDevicesByClaimCodeAsyncHelper(const ClaimDevicesByClaimCodeRequest& request, const ClaimDevicesByClaimCodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ClaimDevicesByClaimCode(request), context);
+}
+
+DescribeDeviceOutcome IoT1ClickDevicesServiceClient::DescribeDevice(const DescribeDeviceRequest& request) const
+{
+  if (!request.DeviceIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("DescribeDevice", "Required field: DeviceId, is not set");
+    return DescribeDeviceOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices/";
+  ss << request.GetDeviceId();
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DescribeDeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
+}
+
+DescribeDeviceOutcomeCallable IoT1ClickDevicesServiceClient::DescribeDeviceCallable(const DescribeDeviceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DescribeDeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDevice(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::DescribeDeviceAsync(const DescribeDeviceRequest& request, const DescribeDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DescribeDeviceAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::DescribeDeviceAsyncHelper(const DescribeDeviceRequest& request, const DescribeDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DescribeDevice(request), context);
+}
+
+FinalizeDeviceClaimOutcome IoT1ClickDevicesServiceClient::FinalizeDeviceClaim(const FinalizeDeviceClaimRequest& request) const
+{
+  if (!request.DeviceIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("FinalizeDeviceClaim", "Required field: DeviceId, is not set");
+    return FinalizeDeviceClaimOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices/";
+  ss << request.GetDeviceId();
+  ss << "/finalize-claim";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return FinalizeDeviceClaimOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
+}
+
+FinalizeDeviceClaimOutcomeCallable IoT1ClickDevicesServiceClient::FinalizeDeviceClaimCallable(const FinalizeDeviceClaimRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< FinalizeDeviceClaimOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->FinalizeDeviceClaim(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::FinalizeDeviceClaimAsync(const FinalizeDeviceClaimRequest& request, const FinalizeDeviceClaimResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->FinalizeDeviceClaimAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::FinalizeDeviceClaimAsyncHelper(const FinalizeDeviceClaimRequest& request, const FinalizeDeviceClaimResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, FinalizeDeviceClaim(request), context);
+}
+
+GetDeviceMethodsOutcome IoT1ClickDevicesServiceClient::GetDeviceMethods(const GetDeviceMethodsRequest& request) const
+{
+  if (!request.DeviceIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("GetDeviceMethods", "Required field: DeviceId, is not set");
+    return GetDeviceMethodsOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices/";
+  ss << request.GetDeviceId();
+  ss << "/methods";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetDeviceMethodsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetDeviceMethodsOutcomeCallable IoT1ClickDevicesServiceClient::GetDeviceMethodsCallable(const GetDeviceMethodsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetDeviceMethodsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetDeviceMethods(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::GetDeviceMethodsAsync(const GetDeviceMethodsRequest& request, const GetDeviceMethodsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetDeviceMethodsAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::GetDeviceMethodsAsyncHelper(const GetDeviceMethodsRequest& request, const GetDeviceMethodsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetDeviceMethods(request), context);
+}
+
+InitiateDeviceClaimOutcome IoT1ClickDevicesServiceClient::InitiateDeviceClaim(const InitiateDeviceClaimRequest& request) const
+{
+  if (!request.DeviceIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("InitiateDeviceClaim", "Required field: DeviceId, is not set");
+    return InitiateDeviceClaimOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices/";
+  ss << request.GetDeviceId();
+  ss << "/initiate-claim";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return InitiateDeviceClaimOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
+}
+
+InitiateDeviceClaimOutcomeCallable IoT1ClickDevicesServiceClient::InitiateDeviceClaimCallable(const InitiateDeviceClaimRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< InitiateDeviceClaimOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->InitiateDeviceClaim(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::InitiateDeviceClaimAsync(const InitiateDeviceClaimRequest& request, const InitiateDeviceClaimResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->InitiateDeviceClaimAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::InitiateDeviceClaimAsyncHelper(const InitiateDeviceClaimRequest& request, const InitiateDeviceClaimResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, InitiateDeviceClaim(request), context);
+}
+
+InvokeDeviceMethodOutcome IoT1ClickDevicesServiceClient::InvokeDeviceMethod(const InvokeDeviceMethodRequest& request) const
+{
+  if (!request.DeviceIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("InvokeDeviceMethod", "Required field: DeviceId, is not set");
+    return InvokeDeviceMethodOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices/";
+  ss << request.GetDeviceId();
+  ss << "/methods";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return InvokeDeviceMethodOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+InvokeDeviceMethodOutcomeCallable IoT1ClickDevicesServiceClient::InvokeDeviceMethodCallable(const InvokeDeviceMethodRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< InvokeDeviceMethodOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->InvokeDeviceMethod(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::InvokeDeviceMethodAsync(const InvokeDeviceMethodRequest& request, const InvokeDeviceMethodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->InvokeDeviceMethodAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::InvokeDeviceMethodAsyncHelper(const InvokeDeviceMethodRequest& request, const InvokeDeviceMethodResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, InvokeDeviceMethod(request), context);
+}
+
+ListDeviceEventsOutcome IoT1ClickDevicesServiceClient::ListDeviceEvents(const ListDeviceEventsRequest& request) const
+{
+  if (!request.DeviceIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListDeviceEvents", "Required field: DeviceId, is not set");
+    return ListDeviceEventsOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
+  }
+  if (!request.FromTimeStampHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListDeviceEvents", "Required field: FromTimeStamp, is not set");
+    return ListDeviceEventsOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FromTimeStamp]", false));
+  }
+  if (!request.ToTimeStampHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListDeviceEvents", "Required field: ToTimeStamp, is not set");
+    return ListDeviceEventsOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ToTimeStamp]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices/";
+  ss << request.GetDeviceId();
+  ss << "/events";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListDeviceEventsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListDeviceEventsOutcomeCallable IoT1ClickDevicesServiceClient::ListDeviceEventsCallable(const ListDeviceEventsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListDeviceEventsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDeviceEvents(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::ListDeviceEventsAsync(const ListDeviceEventsRequest& request, const ListDeviceEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListDeviceEventsAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::ListDeviceEventsAsyncHelper(const ListDeviceEventsRequest& request, const ListDeviceEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListDeviceEvents(request), context);
+}
+
+ListDevicesOutcome IoT1ClickDevicesServiceClient::ListDevices(const ListDevicesRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListDevicesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListDevicesOutcomeCallable IoT1ClickDevicesServiceClient::ListDevicesCallable(const ListDevicesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListDevicesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDevices(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::ListDevicesAsync(const ListDevicesRequest& request, const ListDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListDevicesAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::ListDevicesAsyncHelper(const ListDevicesRequest& request, const ListDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListDevices(request), context);
+}
+
+ListTagsForResourceOutcome IoT1ClickDevicesServiceClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
+{
+  if (!request.ResourceArnHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceArn, is not set");
+    return ListTagsForResourceOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/tags/";
+  ss << request.GetResourceArn();
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListTagsForResourceOutcomeCallable IoT1ClickDevicesServiceClient::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 IoT1ClickDevicesServiceClient::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 IoT1ClickDevicesServiceClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListTagsForResource(request), context);
+}
+
+TagResourceOutcome IoT1ClickDevicesServiceClient::TagResource(const TagResourceRequest& request) const
+{
+  if (!request.ResourceArnHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("TagResource", "Required field: ResourceArn, is not set");
+    return TagResourceOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/tags/";
+  ss << request.GetResourceArn();
+  uri.SetPath(uri.GetPath() + ss.str());
+  return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+TagResourceOutcomeCallable IoT1ClickDevicesServiceClient::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 IoT1ClickDevicesServiceClient::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 IoT1ClickDevicesServiceClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, TagResource(request), context);
+}
+
+UnclaimDeviceOutcome IoT1ClickDevicesServiceClient::UnclaimDevice(const UnclaimDeviceRequest& request) const
+{
+  if (!request.DeviceIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UnclaimDevice", "Required field: DeviceId, is not set");
+    return UnclaimDeviceOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices/";
+  ss << request.GetDeviceId();
+  ss << "/unclaim";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UnclaimDeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
+}
+
+UnclaimDeviceOutcomeCallable IoT1ClickDevicesServiceClient::UnclaimDeviceCallable(const UnclaimDeviceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< UnclaimDeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UnclaimDevice(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::UnclaimDeviceAsync(const UnclaimDeviceRequest& request, const UnclaimDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->UnclaimDeviceAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::UnclaimDeviceAsyncHelper(const UnclaimDeviceRequest& request, const UnclaimDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UnclaimDevice(request), context);
+}
+
+UntagResourceOutcome IoT1ClickDevicesServiceClient::UntagResource(const UntagResourceRequest& request) const
+{
+  if (!request.ResourceArnHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UntagResource", "Required field: ResourceArn, is not set");
+    return UntagResourceOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
+  }
+  if (!request.TagKeysHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UntagResource", "Required field: TagKeys, is not set");
+    return UntagResourceOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TagKeys]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/tags/";
+  ss << request.GetResourceArn();
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
+}
+
+UntagResourceOutcomeCallable IoT1ClickDevicesServiceClient::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 IoT1ClickDevicesServiceClient::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 IoT1ClickDevicesServiceClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UntagResource(request), context);
+}
+
+UpdateDeviceStateOutcome IoT1ClickDevicesServiceClient::UpdateDeviceState(const UpdateDeviceStateRequest& request) const
+{
+  if (!request.DeviceIdHasBeenSet())
+  {
+    AWS_LOGSTREAM_ERROR("UpdateDeviceState", "Required field: DeviceId, is not set");
+    return UpdateDeviceStateOutcome(Aws::Client::AWSError<IoT1ClickDevicesServiceErrors>(IoT1ClickDevicesServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
+  }
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/devices/";
+  ss << request.GetDeviceId();
+  ss << "/state";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UpdateDeviceStateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
+}
+
+UpdateDeviceStateOutcomeCallable IoT1ClickDevicesServiceClient::UpdateDeviceStateCallable(const UpdateDeviceStateRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< UpdateDeviceStateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateDeviceState(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void IoT1ClickDevicesServiceClient::UpdateDeviceStateAsync(const UpdateDeviceStateRequest& request, const UpdateDeviceStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->UpdateDeviceStateAsyncHelper( request, handler, context ); } );
+}
+
+void IoT1ClickDevicesServiceClient::UpdateDeviceStateAsyncHelper(const UpdateDeviceStateRequest& request, const UpdateDeviceStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UpdateDeviceState(request), context);
+}
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/IoT1ClickDevicesServiceEndpoint.cpp

@@ -0,0 +1,64 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/IoT1ClickDevicesServiceEndpoint.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/HashingUtils.h>
+
+using namespace Aws;
+using namespace Aws::IoT1ClickDevicesService;
+
+namespace Aws
+{
+namespace IoT1ClickDevicesService
+{
+namespace IoT1ClickDevicesServiceEndpoint
+{
+  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 << "devices.iot1click" << ".";
+
+    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 IoT1ClickDevicesServiceEndpoint
+} // namespace IoT1ClickDevicesService
+} // namespace Aws
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/IoT1ClickDevicesServiceErrorMarshaller.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/iot1click-devices/IoT1ClickDevicesServiceErrorMarshaller.h>
+#include <aws/iot1click-devices/IoT1ClickDevicesServiceErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::IoT1ClickDevicesService;
+
+AWSError<CoreErrors> IoT1ClickDevicesServiceErrorMarshaller::FindErrorByName(const char* errorName) const
+{
+  AWSError<CoreErrors> error = IoT1ClickDevicesServiceErrorMapper::GetErrorForName(errorName);
+  if(error.GetErrorType() != CoreErrors::UNKNOWN)
+  {
+    return error;
+  }
+
+  return AWSErrorMarshaller::FindErrorByName(errorName);
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/IoT1ClickDevicesServiceErrors.cpp

@@ -0,0 +1,107 @@
+/**
+ * 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/iot1click-devices/IoT1ClickDevicesServiceErrors.h>
+#include <aws/iot1click-devices/model/ResourceNotFoundException.h>
+#include <aws/iot1click-devices/model/ForbiddenException.h>
+#include <aws/iot1click-devices/model/PreconditionFailedException.h>
+#include <aws/iot1click-devices/model/ResourceConflictException.h>
+#include <aws/iot1click-devices/model/RangeNotSatisfiableException.h>
+#include <aws/iot1click-devices/model/InvalidRequestException.h>
+#include <aws/iot1click-devices/model/InternalFailureException.h>
+
+using namespace Aws::Client;
+using namespace Aws::Utils;
+using namespace Aws::IoT1ClickDevicesService;
+using namespace Aws::IoT1ClickDevicesService::Model;
+
+namespace Aws
+{
+namespace IoT1ClickDevicesService
+{
+template<> AWS_IOT1CLICKDEVICESSERVICE_API ResourceNotFoundException IoT1ClickDevicesServiceError::GetModeledError()
+{
+  assert(this->GetErrorType() == IoT1ClickDevicesServiceErrors::RESOURCE_NOT_FOUND);
+  return ResourceNotFoundException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IOT1CLICKDEVICESSERVICE_API ForbiddenException IoT1ClickDevicesServiceError::GetModeledError()
+{
+  assert(this->GetErrorType() == IoT1ClickDevicesServiceErrors::FORBIDDEN);
+  return ForbiddenException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IOT1CLICKDEVICESSERVICE_API PreconditionFailedException IoT1ClickDevicesServiceError::GetModeledError()
+{
+  assert(this->GetErrorType() == IoT1ClickDevicesServiceErrors::PRECONDITION_FAILED);
+  return PreconditionFailedException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IOT1CLICKDEVICESSERVICE_API ResourceConflictException IoT1ClickDevicesServiceError::GetModeledError()
+{
+  assert(this->GetErrorType() == IoT1ClickDevicesServiceErrors::RESOURCE_CONFLICT);
+  return ResourceConflictException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IOT1CLICKDEVICESSERVICE_API RangeNotSatisfiableException IoT1ClickDevicesServiceError::GetModeledError()
+{
+  assert(this->GetErrorType() == IoT1ClickDevicesServiceErrors::RANGE_NOT_SATISFIABLE);
+  return RangeNotSatisfiableException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IOT1CLICKDEVICESSERVICE_API InvalidRequestException IoT1ClickDevicesServiceError::GetModeledError()
+{
+  assert(this->GetErrorType() == IoT1ClickDevicesServiceErrors::INVALID_REQUEST);
+  return InvalidRequestException(this->GetJsonPayload().View());
+}
+
+template<> AWS_IOT1CLICKDEVICESSERVICE_API InternalFailureException IoT1ClickDevicesServiceError::GetModeledError()
+{
+  assert(this->GetErrorType() == IoT1ClickDevicesServiceErrors::INTERNAL_FAILURE);
+  return InternalFailureException(this->GetJsonPayload().View());
+}
+
+namespace IoT1ClickDevicesServiceErrorMapper
+{
+
+static const int FORBIDDEN_HASH = HashingUtils::HashString("ForbiddenException");
+static const int PRECONDITION_FAILED_HASH = HashingUtils::HashString("PreconditionFailedException");
+static const int RESOURCE_CONFLICT_HASH = HashingUtils::HashString("ResourceConflictException");
+static const int RANGE_NOT_SATISFIABLE_HASH = HashingUtils::HashString("RangeNotSatisfiableException");
+static const int INVALID_REQUEST_HASH = HashingUtils::HashString("InvalidRequestException");
+
+
+AWSError<CoreErrors> GetErrorForName(const char* errorName)
+{
+  int hashCode = HashingUtils::HashString(errorName);
+
+  if (hashCode == FORBIDDEN_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IoT1ClickDevicesServiceErrors::FORBIDDEN), false);
+  }
+  else if (hashCode == PRECONDITION_FAILED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IoT1ClickDevicesServiceErrors::PRECONDITION_FAILED), false);
+  }
+  else if (hashCode == RESOURCE_CONFLICT_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IoT1ClickDevicesServiceErrors::RESOURCE_CONFLICT), false);
+  }
+  else if (hashCode == RANGE_NOT_SATISFIABLE_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IoT1ClickDevicesServiceErrors::RANGE_NOT_SATISFIABLE), false);
+  }
+  else if (hashCode == INVALID_REQUEST_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(IoT1ClickDevicesServiceErrors::INVALID_REQUEST), false);
+  }
+  return AWSError<CoreErrors>(CoreErrors::UNKNOWN, false);
+}
+
+} // namespace IoT1ClickDevicesServiceErrorMapper
+} // namespace IoT1ClickDevicesService
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/Attributes.cpp

@@ -0,0 +1,45 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/Attributes.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IoT1ClickDevicesService
+{
+namespace Model
+{
+
+Attributes::Attributes()
+{
+}
+
+Attributes::Attributes(JsonView jsonValue)
+{
+  *this = jsonValue;
+}
+
+Attributes& Attributes::operator =(JsonView jsonValue)
+{
+  AWS_UNREFERENCED_PARAM(jsonValue);
+  return *this;
+}
+
+JsonValue Attributes::Jsonize() const
+{
+  JsonValue payload;
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IoT1ClickDevicesService
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ClaimDevicesByClaimCodeRequest.cpp

@@ -0,0 +1,27 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/ClaimDevicesByClaimCodeRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ClaimDevicesByClaimCodeRequest::ClaimDevicesByClaimCodeRequest() : 
+    m_claimCodeHasBeenSet(false)
+{
+}
+
+Aws::String ClaimDevicesByClaimCodeRequest::SerializePayload() const
+{
+  return {};
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ClaimDevicesByClaimCodeResult.cpp

@@ -0,0 +1,48 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/ClaimDevicesByClaimCodeResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ClaimDevicesByClaimCodeResult::ClaimDevicesByClaimCodeResult() : 
+    m_total(0)
+{
+}
+
+ClaimDevicesByClaimCodeResult::ClaimDevicesByClaimCodeResult(const Aws::AmazonWebServiceResult<JsonValue>& result) : 
+    m_total(0)
+{
+  *this = result;
+}
+
+ClaimDevicesByClaimCodeResult& ClaimDevicesByClaimCodeResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("claimCode"))
+  {
+    m_claimCode = jsonValue.GetString("claimCode");
+
+  }
+
+  if(jsonValue.ValueExists("total"))
+  {
+    m_total = jsonValue.GetInteger("total");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/DescribeDeviceRequest.cpp

@@ -0,0 +1,27 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/DescribeDeviceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DescribeDeviceRequest::DescribeDeviceRequest() : 
+    m_deviceIdHasBeenSet(false)
+{
+}
+
+Aws::String DescribeDeviceRequest::SerializePayload() const
+{
+  return {};
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/DescribeDeviceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/DescribeDeviceResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DescribeDeviceResult::DescribeDeviceResult()
+{
+}
+
+DescribeDeviceResult::DescribeDeviceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+DescribeDeviceResult& DescribeDeviceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("deviceDescription"))
+  {
+    m_deviceDescription = jsonValue.GetObject("deviceDescription");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/Device.cpp

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/Device.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IoT1ClickDevicesService
+{
+namespace Model
+{
+
+Device::Device() : 
+    m_attributesHasBeenSet(false),
+    m_deviceIdHasBeenSet(false),
+    m_typeHasBeenSet(false)
+{
+}
+
+Device::Device(JsonView jsonValue) : 
+    m_attributesHasBeenSet(false),
+    m_deviceIdHasBeenSet(false),
+    m_typeHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Device& Device::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("attributes"))
+  {
+    m_attributes = jsonValue.GetObject("attributes");
+
+    m_attributesHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("deviceId"))
+  {
+    m_deviceId = jsonValue.GetString("deviceId");
+
+    m_deviceIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("type"))
+  {
+    m_type = jsonValue.GetString("type");
+
+    m_typeHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Device::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_attributesHasBeenSet)
+  {
+   payload.WithObject("attributes", m_attributes.Jsonize());
+
+  }
+
+  if(m_deviceIdHasBeenSet)
+  {
+   payload.WithString("deviceId", m_deviceId);
+
+  }
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("type", m_type);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IoT1ClickDevicesService
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/DeviceDescription.cpp

@@ -0,0 +1,169 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/DeviceDescription.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IoT1ClickDevicesService
+{
+namespace Model
+{
+
+DeviceDescription::DeviceDescription() : 
+    m_arnHasBeenSet(false),
+    m_attributesHasBeenSet(false),
+    m_deviceIdHasBeenSet(false),
+    m_enabled(false),
+    m_enabledHasBeenSet(false),
+    m_remainingLife(0.0),
+    m_remainingLifeHasBeenSet(false),
+    m_typeHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+DeviceDescription::DeviceDescription(JsonView jsonValue) : 
+    m_arnHasBeenSet(false),
+    m_attributesHasBeenSet(false),
+    m_deviceIdHasBeenSet(false),
+    m_enabled(false),
+    m_enabledHasBeenSet(false),
+    m_remainingLife(0.0),
+    m_remainingLifeHasBeenSet(false),
+    m_typeHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+DeviceDescription& DeviceDescription::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("arn"))
+  {
+    m_arn = jsonValue.GetString("arn");
+
+    m_arnHasBeenSet = 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;
+  }
+
+  if(jsonValue.ValueExists("deviceId"))
+  {
+    m_deviceId = jsonValue.GetString("deviceId");
+
+    m_deviceIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("enabled"))
+  {
+    m_enabled = jsonValue.GetBool("enabled");
+
+    m_enabledHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("remainingLife"))
+  {
+    m_remainingLife = jsonValue.GetDouble("remainingLife");
+
+    m_remainingLifeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("type"))
+  {
+    m_type = jsonValue.GetString("type");
+
+    m_typeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("tags"))
+  {
+    Aws::Map<Aws::String, JsonView> tagsJsonMap = jsonValue.GetObject("tags").GetAllObjects();
+    for(auto& tagsItem : tagsJsonMap)
+    {
+      m_tags[tagsItem.first] = tagsItem.second.AsString();
+    }
+    m_tagsHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue DeviceDescription::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_arnHasBeenSet)
+  {
+   payload.WithString("arn", m_arn);
+
+  }
+
+  if(m_attributesHasBeenSet)
+  {
+   JsonValue attributesJsonMap;
+   for(auto& attributesItem : m_attributes)
+   {
+     attributesJsonMap.WithString(attributesItem.first, attributesItem.second);
+   }
+   payload.WithObject("attributes", std::move(attributesJsonMap));
+
+  }
+
+  if(m_deviceIdHasBeenSet)
+  {
+   payload.WithString("deviceId", m_deviceId);
+
+  }
+
+  if(m_enabledHasBeenSet)
+  {
+   payload.WithBool("enabled", m_enabled);
+
+  }
+
+  if(m_remainingLifeHasBeenSet)
+  {
+   payload.WithDouble("remainingLife", m_remainingLife);
+
+  }
+
+  if(m_typeHasBeenSet)
+  {
+   payload.WithString("type", m_type);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   JsonValue tagsJsonMap;
+   for(auto& tagsItem : m_tags)
+   {
+     tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
+   }
+   payload.WithObject("tags", std::move(tagsJsonMap));
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IoT1ClickDevicesService
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/DeviceEvent.cpp

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/DeviceEvent.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IoT1ClickDevicesService
+{
+namespace Model
+{
+
+DeviceEvent::DeviceEvent() : 
+    m_deviceHasBeenSet(false),
+    m_stdEventHasBeenSet(false)
+{
+}
+
+DeviceEvent::DeviceEvent(JsonView jsonValue) : 
+    m_deviceHasBeenSet(false),
+    m_stdEventHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+DeviceEvent& DeviceEvent::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("device"))
+  {
+    m_device = jsonValue.GetObject("device");
+
+    m_deviceHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("stdEvent"))
+  {
+    m_stdEvent = jsonValue.GetString("stdEvent");
+
+    m_stdEventHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue DeviceEvent::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_deviceHasBeenSet)
+  {
+   payload.WithObject("device", m_device.Jsonize());
+
+  }
+
+  if(m_stdEventHasBeenSet)
+  {
+   payload.WithString("stdEvent", m_stdEvent);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IoT1ClickDevicesService
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/DeviceMethod.cpp

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/DeviceMethod.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace IoT1ClickDevicesService
+{
+namespace Model
+{
+
+DeviceMethod::DeviceMethod() : 
+    m_deviceTypeHasBeenSet(false),
+    m_methodNameHasBeenSet(false)
+{
+}
+
+DeviceMethod::DeviceMethod(JsonView jsonValue) : 
+    m_deviceTypeHasBeenSet(false),
+    m_methodNameHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+DeviceMethod& DeviceMethod::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("deviceType"))
+  {
+    m_deviceType = jsonValue.GetString("deviceType");
+
+    m_deviceTypeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("methodName"))
+  {
+    m_methodName = jsonValue.GetString("methodName");
+
+    m_methodNameHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue DeviceMethod::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_deviceTypeHasBeenSet)
+  {
+   payload.WithString("deviceType", m_deviceType);
+
+  }
+
+  if(m_methodNameHasBeenSet)
+  {
+   payload.WithString("methodName", m_methodName);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace IoT1ClickDevicesService
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/FinalizeDeviceClaimRequest.cpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/FinalizeDeviceClaimRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+FinalizeDeviceClaimRequest::FinalizeDeviceClaimRequest() : 
+    m_deviceIdHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String FinalizeDeviceClaimRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_tagsHasBeenSet)
+  {
+   JsonValue tagsJsonMap;
+   for(auto& tagsItem : m_tags)
+   {
+     tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
+   }
+   payload.WithObject("tags", std::move(tagsJsonMap));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/FinalizeDeviceClaimResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/FinalizeDeviceClaimResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+FinalizeDeviceClaimResult::FinalizeDeviceClaimResult()
+{
+}
+
+FinalizeDeviceClaimResult::FinalizeDeviceClaimResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+FinalizeDeviceClaimResult& FinalizeDeviceClaimResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("state"))
+  {
+    m_state = jsonValue.GetString("state");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ForbiddenException.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/GetDeviceMethodsRequest.cpp

@@ -0,0 +1,27 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/GetDeviceMethodsRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetDeviceMethodsRequest::GetDeviceMethodsRequest() : 
+    m_deviceIdHasBeenSet(false)
+{
+}
+
+Aws::String GetDeviceMethodsRequest::SerializePayload() const
+{
+  return {};
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/GetDeviceMethodsResult.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/GetDeviceMethodsResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetDeviceMethodsResult::GetDeviceMethodsResult()
+{
+}
+
+GetDeviceMethodsResult::GetDeviceMethodsResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetDeviceMethodsResult& GetDeviceMethodsResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("deviceMethods"))
+  {
+    Array<JsonView> deviceMethodsJsonList = jsonValue.GetArray("deviceMethods");
+    for(unsigned deviceMethodsIndex = 0; deviceMethodsIndex < deviceMethodsJsonList.GetLength(); ++deviceMethodsIndex)
+    {
+      m_deviceMethods.push_back(deviceMethodsJsonList[deviceMethodsIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/InitiateDeviceClaimRequest.cpp

@@ -0,0 +1,27 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/InitiateDeviceClaimRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+InitiateDeviceClaimRequest::InitiateDeviceClaimRequest() : 
+    m_deviceIdHasBeenSet(false)
+{
+}
+
+Aws::String InitiateDeviceClaimRequest::SerializePayload() const
+{
+  return {};
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/InitiateDeviceClaimResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/InitiateDeviceClaimResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+InitiateDeviceClaimResult::InitiateDeviceClaimResult()
+{
+}
+
+InitiateDeviceClaimResult::InitiateDeviceClaimResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+InitiateDeviceClaimResult& InitiateDeviceClaimResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("state"))
+  {
+    m_state = jsonValue.GetString("state");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/InternalFailureException.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/InvalidRequestException.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/InvokeDeviceMethodRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/InvokeDeviceMethodRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+InvokeDeviceMethodRequest::InvokeDeviceMethodRequest() : 
+    m_deviceIdHasBeenSet(false),
+    m_deviceMethodHasBeenSet(false),
+    m_deviceMethodParametersHasBeenSet(false)
+{
+}
+
+Aws::String InvokeDeviceMethodRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_deviceMethodHasBeenSet)
+  {
+   payload.WithObject("deviceMethod", m_deviceMethod.Jsonize());
+
+  }
+
+  if(m_deviceMethodParametersHasBeenSet)
+  {
+   payload.WithString("deviceMethodParameters", m_deviceMethodParameters);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/InvokeDeviceMethodResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/InvokeDeviceMethodResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+InvokeDeviceMethodResult::InvokeDeviceMethodResult()
+{
+}
+
+InvokeDeviceMethodResult::InvokeDeviceMethodResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+InvokeDeviceMethodResult& InvokeDeviceMethodResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("deviceMethodResponse"))
+  {
+    m_deviceMethodResponse = jsonValue.GetString("deviceMethodResponse");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ListDeviceEventsRequest.cpp

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/ListDeviceEventsRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/http/URI.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws::Http;
+
+ListDeviceEventsRequest::ListDeviceEventsRequest() : 
+    m_deviceIdHasBeenSet(false),
+    m_fromTimeStampHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_nextTokenHasBeenSet(false),
+    m_toTimeStampHasBeenSet(false)
+{
+}
+
+Aws::String ListDeviceEventsRequest::SerializePayload() const
+{
+  return {};
+}
+
+void ListDeviceEventsRequest::AddQueryStringParameters(URI& uri) const
+{
+    Aws::StringStream ss;
+    if(m_fromTimeStampHasBeenSet)
+    {
+      ss << m_fromTimeStamp.ToGmtString(DateFormat::RFC822);
+      uri.AddQueryStringParameter("fromTimeStamp", ss.str());
+      ss.str("");
+    }
+
+    if(m_maxResultsHasBeenSet)
+    {
+      ss << m_maxResults;
+      uri.AddQueryStringParameter("maxResults", ss.str());
+      ss.str("");
+    }
+
+    if(m_nextTokenHasBeenSet)
+    {
+      ss << m_nextToken;
+      uri.AddQueryStringParameter("nextToken", ss.str());
+      ss.str("");
+    }
+
+    if(m_toTimeStampHasBeenSet)
+    {
+      ss << m_toTimeStamp.ToGmtString(DateFormat::RFC822);
+      uri.AddQueryStringParameter("toTimeStamp", ss.str());
+      ss.str("");
+    }
+
+}
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ListDeviceEventsResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/ListDeviceEventsResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListDeviceEventsResult::ListDeviceEventsResult()
+{
+}
+
+ListDeviceEventsResult::ListDeviceEventsResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListDeviceEventsResult& ListDeviceEventsResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("events"))
+  {
+    Array<JsonView> eventsJsonList = jsonValue.GetArray("events");
+    for(unsigned eventsIndex = 0; eventsIndex < eventsJsonList.GetLength(); ++eventsIndex)
+    {
+      m_events.push_back(eventsJsonList[eventsIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("nextToken"))
+  {
+    m_nextToken = jsonValue.GetString("nextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ListDevicesRequest.cpp

@@ -0,0 +1,58 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/ListDevicesRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/http/URI.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws::Http;
+
+ListDevicesRequest::ListDevicesRequest() : 
+    m_deviceTypeHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_nextTokenHasBeenSet(false)
+{
+}
+
+Aws::String ListDevicesRequest::SerializePayload() const
+{
+  return {};
+}
+
+void ListDevicesRequest::AddQueryStringParameters(URI& uri) const
+{
+    Aws::StringStream ss;
+    if(m_deviceTypeHasBeenSet)
+    {
+      ss << m_deviceType;
+      uri.AddQueryStringParameter("deviceType", ss.str());
+      ss.str("");
+    }
+
+    if(m_maxResultsHasBeenSet)
+    {
+      ss << m_maxResults;
+      uri.AddQueryStringParameter("maxResults", ss.str());
+      ss.str("");
+    }
+
+    if(m_nextTokenHasBeenSet)
+    {
+      ss << m_nextToken;
+      uri.AddQueryStringParameter("nextToken", ss.str());
+      ss.str("");
+    }
+
+}
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ListDevicesResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/ListDevicesResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListDevicesResult::ListDevicesResult()
+{
+}
+
+ListDevicesResult::ListDevicesResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListDevicesResult& ListDevicesResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("devices"))
+  {
+    Array<JsonView> devicesJsonList = jsonValue.GetArray("devices");
+    for(unsigned devicesIndex = 0; devicesIndex < devicesJsonList.GetLength(); ++devicesIndex)
+    {
+      m_devices.push_back(devicesJsonList[devicesIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("nextToken"))
+  {
+    m_nextToken = jsonValue.GetString("nextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ListTagsForResourceRequest.cpp

@@ -0,0 +1,27 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/ListTagsForResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListTagsForResourceRequest::ListTagsForResourceRequest() : 
+    m_resourceArnHasBeenSet(false)
+{
+}
+
+Aws::String ListTagsForResourceRequest::SerializePayload() const
+{
+  return {};
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/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/iot1click-devices/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::IoT1ClickDevicesService::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"))
+  {
+    Aws::Map<Aws::String, JsonView> tagsJsonMap = jsonValue.GetObject("tags").GetAllObjects();
+    for(auto& tagsItem : tagsJsonMap)
+    {
+      m_tags[tagsItem.first] = tagsItem.second.AsString();
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/PreconditionFailedException.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/RangeNotSatisfiableException.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ResourceConflictException.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/ResourceNotFoundException.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/TagResourceRequest.cpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/TagResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::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_tagsHasBeenSet)
+  {
+   JsonValue tagsJsonMap;
+   for(auto& tagsItem : m_tags)
+   {
+     tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
+   }
+   payload.WithObject("tags", std::move(tagsJsonMap));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/UnclaimDeviceRequest.cpp

@@ -0,0 +1,27 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/UnclaimDeviceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+UnclaimDeviceRequest::UnclaimDeviceRequest() : 
+    m_deviceIdHasBeenSet(false)
+{
+}
+
+Aws::String UnclaimDeviceRequest::SerializePayload() const
+{
+  return {};
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/UnclaimDeviceResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/UnclaimDeviceResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+UnclaimDeviceResult::UnclaimDeviceResult()
+{
+}
+
+UnclaimDeviceResult::UnclaimDeviceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+UnclaimDeviceResult& UnclaimDeviceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("state"))
+  {
+    m_state = jsonValue.GetString("state");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/UntagResourceRequest.cpp

@@ -0,0 +1,45 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/UntagResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/http/URI.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws::Http;
+
+UntagResourceRequest::UntagResourceRequest() : 
+    m_resourceArnHasBeenSet(false),
+    m_tagKeysHasBeenSet(false)
+{
+}
+
+Aws::String UntagResourceRequest::SerializePayload() const
+{
+  return {};
+}
+
+void UntagResourceRequest::AddQueryStringParameters(URI& uri) const
+{
+    Aws::StringStream ss;
+    if(m_tagKeysHasBeenSet)
+    {
+      for(const auto& item : m_tagKeys)
+      {
+        ss << item;
+        uri.AddQueryStringParameter("tagKeys", ss.str());
+        ss.str("");
+      }
+    }
+
+}
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/UpdateDeviceStateRequest.cpp

@@ -0,0 +1,37 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/UpdateDeviceStateRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+UpdateDeviceStateRequest::UpdateDeviceStateRequest() : 
+    m_deviceIdHasBeenSet(false),
+    m_enabled(false),
+    m_enabledHasBeenSet(false)
+{
+}
+
+Aws::String UpdateDeviceStateRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_enabledHasBeenSet)
+  {
+   payload.WithBool("enabled", m_enabled);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-iot1click-devices/source/model/UpdateDeviceStateResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/iot1click-devices/model/UpdateDeviceStateResult.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::IoT1ClickDevicesService::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+UpdateDeviceStateResult::UpdateDeviceStateResult()
+{
+}
+
+UpdateDeviceStateResult::UpdateDeviceStateResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+UpdateDeviceStateResult& UpdateDeviceStateResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}