1 /**
2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 * SPDX-License-Identifier: Apache-2.0.
4 */
5
6 #include <aws/core/utils/Outcome.h>
7 #include <aws/core/auth/AWSAuthSigner.h>
8 #include <aws/core/client/CoreErrors.h>
9 #include <aws/core/client/RetryStrategy.h>
10 #include <aws/core/http/HttpClient.h>
11 #include <aws/core/http/HttpResponse.h>
12 #include <aws/core/http/HttpClientFactory.h>
13 #include <aws/core/auth/AWSCredentialsProviderChain.h>
14 #include <aws/core/utils/json/JsonSerializer.h>
15 #include <aws/core/utils/memory/stl/AWSStringStream.h>
16 #include <aws/core/utils/threading/Executor.h>
17 #include <aws/core/utils/DNS.h>
18 #include <aws/core/utils/logging/LogMacros.h>
19
20 #include <aws/appsync/AppSyncClient.h>
21 #include <aws/appsync/AppSyncEndpoint.h>
22 #include <aws/appsync/AppSyncErrorMarshaller.h>
23 #include <aws/appsync/model/CreateApiCacheRequest.h>
24 #include <aws/appsync/model/CreateApiKeyRequest.h>
25 #include <aws/appsync/model/CreateDataSourceRequest.h>
26 #include <aws/appsync/model/CreateFunctionRequest.h>
27 #include <aws/appsync/model/CreateGraphqlApiRequest.h>
28 #include <aws/appsync/model/CreateResolverRequest.h>
29 #include <aws/appsync/model/CreateTypeRequest.h>
30 #include <aws/appsync/model/DeleteApiCacheRequest.h>
31 #include <aws/appsync/model/DeleteApiKeyRequest.h>
32 #include <aws/appsync/model/DeleteDataSourceRequest.h>
33 #include <aws/appsync/model/DeleteFunctionRequest.h>
34 #include <aws/appsync/model/DeleteGraphqlApiRequest.h>
35 #include <aws/appsync/model/DeleteResolverRequest.h>
36 #include <aws/appsync/model/DeleteTypeRequest.h>
37 #include <aws/appsync/model/FlushApiCacheRequest.h>
38 #include <aws/appsync/model/GetApiCacheRequest.h>
39 #include <aws/appsync/model/GetDataSourceRequest.h>
40 #include <aws/appsync/model/GetFunctionRequest.h>
41 #include <aws/appsync/model/GetGraphqlApiRequest.h>
42 #include <aws/appsync/model/GetIntrospectionSchemaRequest.h>
43 #include <aws/appsync/model/GetResolverRequest.h>
44 #include <aws/appsync/model/GetSchemaCreationStatusRequest.h>
45 #include <aws/appsync/model/GetTypeRequest.h>
46 #include <aws/appsync/model/ListApiKeysRequest.h>
47 #include <aws/appsync/model/ListDataSourcesRequest.h>
48 #include <aws/appsync/model/ListFunctionsRequest.h>
49 #include <aws/appsync/model/ListGraphqlApisRequest.h>
50 #include <aws/appsync/model/ListResolversRequest.h>
51 #include <aws/appsync/model/ListResolversByFunctionRequest.h>
52 #include <aws/appsync/model/ListTagsForResourceRequest.h>
53 #include <aws/appsync/model/ListTypesRequest.h>
54 #include <aws/appsync/model/StartSchemaCreationRequest.h>
55 #include <aws/appsync/model/TagResourceRequest.h>
56 #include <aws/appsync/model/UntagResourceRequest.h>
57 #include <aws/appsync/model/UpdateApiCacheRequest.h>
58 #include <aws/appsync/model/UpdateApiKeyRequest.h>
59 #include <aws/appsync/model/UpdateDataSourceRequest.h>
60 #include <aws/appsync/model/UpdateFunctionRequest.h>
61 #include <aws/appsync/model/UpdateGraphqlApiRequest.h>
62 #include <aws/appsync/model/UpdateResolverRequest.h>
63 #include <aws/appsync/model/UpdateTypeRequest.h>
64
65 using namespace Aws;
66 using namespace Aws::Auth;
67 using namespace Aws::Client;
68 using namespace Aws::AppSync;
69 using namespace Aws::AppSync::Model;
70 using namespace Aws::Http;
71 using namespace Aws::Utils::Json;
72
73 static const char* SERVICE_NAME = "appsync";
74 static const char* ALLOCATION_TAG = "AppSyncClient";
75
76
AppSyncClient(const Client::ClientConfiguration & clientConfiguration)77 AppSyncClient::AppSyncClient(const Client::ClientConfiguration& clientConfiguration) :
78 BASECLASS(clientConfiguration,
79 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
80 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
81 Aws::MakeShared<AppSyncErrorMarshaller>(ALLOCATION_TAG)),
82 m_executor(clientConfiguration.executor)
83 {
84 init(clientConfiguration);
85 }
86
AppSyncClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)87 AppSyncClient::AppSyncClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
88 BASECLASS(clientConfiguration,
89 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
90 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
91 Aws::MakeShared<AppSyncErrorMarshaller>(ALLOCATION_TAG)),
92 m_executor(clientConfiguration.executor)
93 {
94 init(clientConfiguration);
95 }
96
AppSyncClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)97 AppSyncClient::AppSyncClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
98 const Client::ClientConfiguration& clientConfiguration) :
99 BASECLASS(clientConfiguration,
100 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
101 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
102 Aws::MakeShared<AppSyncErrorMarshaller>(ALLOCATION_TAG)),
103 m_executor(clientConfiguration.executor)
104 {
105 init(clientConfiguration);
106 }
107
~AppSyncClient()108 AppSyncClient::~AppSyncClient()
109 {
110 }
111
init(const Client::ClientConfiguration & config)112 void AppSyncClient::init(const Client::ClientConfiguration& config)
113 {
114 SetServiceClientName("AppSync");
115 m_configScheme = SchemeMapper::ToString(config.scheme);
116 if (config.endpointOverride.empty())
117 {
118 m_uri = m_configScheme + "://" + AppSyncEndpoint::ForRegion(config.region, config.useDualStack);
119 }
120 else
121 {
122 OverrideEndpoint(config.endpointOverride);
123 }
124 }
125
OverrideEndpoint(const Aws::String & endpoint)126 void AppSyncClient::OverrideEndpoint(const Aws::String& endpoint)
127 {
128 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
129 {
130 m_uri = endpoint;
131 }
132 else
133 {
134 m_uri = m_configScheme + "://" + endpoint;
135 }
136 }
137
CreateApiCache(const CreateApiCacheRequest & request) const138 CreateApiCacheOutcome AppSyncClient::CreateApiCache(const CreateApiCacheRequest& request) const
139 {
140 if (!request.ApiIdHasBeenSet())
141 {
142 AWS_LOGSTREAM_ERROR("CreateApiCache", "Required field: ApiId, is not set");
143 return CreateApiCacheOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
144 }
145 Aws::Http::URI uri = m_uri;
146 uri.AddPathSegments("/v1/apis/");
147 uri.AddPathSegment(request.GetApiId());
148 uri.AddPathSegments("/ApiCaches");
149 return CreateApiCacheOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
150 }
151
CreateApiCacheCallable(const CreateApiCacheRequest & request) const152 CreateApiCacheOutcomeCallable AppSyncClient::CreateApiCacheCallable(const CreateApiCacheRequest& request) const
153 {
154 auto task = Aws::MakeShared< std::packaged_task< CreateApiCacheOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateApiCache(request); } );
155 auto packagedFunction = [task]() { (*task)(); };
156 m_executor->Submit(packagedFunction);
157 return task->get_future();
158 }
159
CreateApiCacheAsync(const CreateApiCacheRequest & request,const CreateApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const160 void AppSyncClient::CreateApiCacheAsync(const CreateApiCacheRequest& request, const CreateApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
161 {
162 m_executor->Submit( [this, request, handler, context](){ this->CreateApiCacheAsyncHelper( request, handler, context ); } );
163 }
164
CreateApiCacheAsyncHelper(const CreateApiCacheRequest & request,const CreateApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const165 void AppSyncClient::CreateApiCacheAsyncHelper(const CreateApiCacheRequest& request, const CreateApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
166 {
167 handler(this, request, CreateApiCache(request), context);
168 }
169
CreateApiKey(const CreateApiKeyRequest & request) const170 CreateApiKeyOutcome AppSyncClient::CreateApiKey(const CreateApiKeyRequest& request) const
171 {
172 if (!request.ApiIdHasBeenSet())
173 {
174 AWS_LOGSTREAM_ERROR("CreateApiKey", "Required field: ApiId, is not set");
175 return CreateApiKeyOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
176 }
177 Aws::Http::URI uri = m_uri;
178 uri.AddPathSegments("/v1/apis/");
179 uri.AddPathSegment(request.GetApiId());
180 uri.AddPathSegments("/apikeys");
181 return CreateApiKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
182 }
183
CreateApiKeyCallable(const CreateApiKeyRequest & request) const184 CreateApiKeyOutcomeCallable AppSyncClient::CreateApiKeyCallable(const CreateApiKeyRequest& request) const
185 {
186 auto task = Aws::MakeShared< std::packaged_task< CreateApiKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateApiKey(request); } );
187 auto packagedFunction = [task]() { (*task)(); };
188 m_executor->Submit(packagedFunction);
189 return task->get_future();
190 }
191
CreateApiKeyAsync(const CreateApiKeyRequest & request,const CreateApiKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const192 void AppSyncClient::CreateApiKeyAsync(const CreateApiKeyRequest& request, const CreateApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
193 {
194 m_executor->Submit( [this, request, handler, context](){ this->CreateApiKeyAsyncHelper( request, handler, context ); } );
195 }
196
CreateApiKeyAsyncHelper(const CreateApiKeyRequest & request,const CreateApiKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const197 void AppSyncClient::CreateApiKeyAsyncHelper(const CreateApiKeyRequest& request, const CreateApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
198 {
199 handler(this, request, CreateApiKey(request), context);
200 }
201
CreateDataSource(const CreateDataSourceRequest & request) const202 CreateDataSourceOutcome AppSyncClient::CreateDataSource(const CreateDataSourceRequest& request) const
203 {
204 if (!request.ApiIdHasBeenSet())
205 {
206 AWS_LOGSTREAM_ERROR("CreateDataSource", "Required field: ApiId, is not set");
207 return CreateDataSourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
208 }
209 Aws::Http::URI uri = m_uri;
210 uri.AddPathSegments("/v1/apis/");
211 uri.AddPathSegment(request.GetApiId());
212 uri.AddPathSegments("/datasources");
213 return CreateDataSourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
214 }
215
CreateDataSourceCallable(const CreateDataSourceRequest & request) const216 CreateDataSourceOutcomeCallable AppSyncClient::CreateDataSourceCallable(const CreateDataSourceRequest& request) const
217 {
218 auto task = Aws::MakeShared< std::packaged_task< CreateDataSourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateDataSource(request); } );
219 auto packagedFunction = [task]() { (*task)(); };
220 m_executor->Submit(packagedFunction);
221 return task->get_future();
222 }
223
CreateDataSourceAsync(const CreateDataSourceRequest & request,const CreateDataSourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const224 void AppSyncClient::CreateDataSourceAsync(const CreateDataSourceRequest& request, const CreateDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
225 {
226 m_executor->Submit( [this, request, handler, context](){ this->CreateDataSourceAsyncHelper( request, handler, context ); } );
227 }
228
CreateDataSourceAsyncHelper(const CreateDataSourceRequest & request,const CreateDataSourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const229 void AppSyncClient::CreateDataSourceAsyncHelper(const CreateDataSourceRequest& request, const CreateDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
230 {
231 handler(this, request, CreateDataSource(request), context);
232 }
233
CreateFunction(const CreateFunctionRequest & request) const234 CreateFunctionOutcome AppSyncClient::CreateFunction(const CreateFunctionRequest& request) const
235 {
236 if (!request.ApiIdHasBeenSet())
237 {
238 AWS_LOGSTREAM_ERROR("CreateFunction", "Required field: ApiId, is not set");
239 return CreateFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
240 }
241 Aws::Http::URI uri = m_uri;
242 uri.AddPathSegments("/v1/apis/");
243 uri.AddPathSegment(request.GetApiId());
244 uri.AddPathSegments("/functions");
245 return CreateFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
246 }
247
CreateFunctionCallable(const CreateFunctionRequest & request) const248 CreateFunctionOutcomeCallable AppSyncClient::CreateFunctionCallable(const CreateFunctionRequest& request) const
249 {
250 auto task = Aws::MakeShared< std::packaged_task< CreateFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateFunction(request); } );
251 auto packagedFunction = [task]() { (*task)(); };
252 m_executor->Submit(packagedFunction);
253 return task->get_future();
254 }
255
CreateFunctionAsync(const CreateFunctionRequest & request,const CreateFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const256 void AppSyncClient::CreateFunctionAsync(const CreateFunctionRequest& request, const CreateFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
257 {
258 m_executor->Submit( [this, request, handler, context](){ this->CreateFunctionAsyncHelper( request, handler, context ); } );
259 }
260
CreateFunctionAsyncHelper(const CreateFunctionRequest & request,const CreateFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const261 void AppSyncClient::CreateFunctionAsyncHelper(const CreateFunctionRequest& request, const CreateFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
262 {
263 handler(this, request, CreateFunction(request), context);
264 }
265
CreateGraphqlApi(const CreateGraphqlApiRequest & request) const266 CreateGraphqlApiOutcome AppSyncClient::CreateGraphqlApi(const CreateGraphqlApiRequest& request) const
267 {
268 Aws::Http::URI uri = m_uri;
269 uri.AddPathSegments("/v1/apis");
270 return CreateGraphqlApiOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
271 }
272
CreateGraphqlApiCallable(const CreateGraphqlApiRequest & request) const273 CreateGraphqlApiOutcomeCallable AppSyncClient::CreateGraphqlApiCallable(const CreateGraphqlApiRequest& request) const
274 {
275 auto task = Aws::MakeShared< std::packaged_task< CreateGraphqlApiOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateGraphqlApi(request); } );
276 auto packagedFunction = [task]() { (*task)(); };
277 m_executor->Submit(packagedFunction);
278 return task->get_future();
279 }
280
CreateGraphqlApiAsync(const CreateGraphqlApiRequest & request,const CreateGraphqlApiResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const281 void AppSyncClient::CreateGraphqlApiAsync(const CreateGraphqlApiRequest& request, const CreateGraphqlApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
282 {
283 m_executor->Submit( [this, request, handler, context](){ this->CreateGraphqlApiAsyncHelper( request, handler, context ); } );
284 }
285
CreateGraphqlApiAsyncHelper(const CreateGraphqlApiRequest & request,const CreateGraphqlApiResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const286 void AppSyncClient::CreateGraphqlApiAsyncHelper(const CreateGraphqlApiRequest& request, const CreateGraphqlApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
287 {
288 handler(this, request, CreateGraphqlApi(request), context);
289 }
290
CreateResolver(const CreateResolverRequest & request) const291 CreateResolverOutcome AppSyncClient::CreateResolver(const CreateResolverRequest& request) const
292 {
293 if (!request.ApiIdHasBeenSet())
294 {
295 AWS_LOGSTREAM_ERROR("CreateResolver", "Required field: ApiId, is not set");
296 return CreateResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
297 }
298 if (!request.TypeNameHasBeenSet())
299 {
300 AWS_LOGSTREAM_ERROR("CreateResolver", "Required field: TypeName, is not set");
301 return CreateResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TypeName]", false));
302 }
303 Aws::Http::URI uri = m_uri;
304 uri.AddPathSegments("/v1/apis/");
305 uri.AddPathSegment(request.GetApiId());
306 uri.AddPathSegments("/types/");
307 uri.AddPathSegment(request.GetTypeName());
308 uri.AddPathSegments("/resolvers");
309 return CreateResolverOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
310 }
311
CreateResolverCallable(const CreateResolverRequest & request) const312 CreateResolverOutcomeCallable AppSyncClient::CreateResolverCallable(const CreateResolverRequest& request) const
313 {
314 auto task = Aws::MakeShared< std::packaged_task< CreateResolverOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateResolver(request); } );
315 auto packagedFunction = [task]() { (*task)(); };
316 m_executor->Submit(packagedFunction);
317 return task->get_future();
318 }
319
CreateResolverAsync(const CreateResolverRequest & request,const CreateResolverResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const320 void AppSyncClient::CreateResolverAsync(const CreateResolverRequest& request, const CreateResolverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
321 {
322 m_executor->Submit( [this, request, handler, context](){ this->CreateResolverAsyncHelper( request, handler, context ); } );
323 }
324
CreateResolverAsyncHelper(const CreateResolverRequest & request,const CreateResolverResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const325 void AppSyncClient::CreateResolverAsyncHelper(const CreateResolverRequest& request, const CreateResolverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
326 {
327 handler(this, request, CreateResolver(request), context);
328 }
329
CreateType(const CreateTypeRequest & request) const330 CreateTypeOutcome AppSyncClient::CreateType(const CreateTypeRequest& request) const
331 {
332 if (!request.ApiIdHasBeenSet())
333 {
334 AWS_LOGSTREAM_ERROR("CreateType", "Required field: ApiId, is not set");
335 return CreateTypeOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
336 }
337 Aws::Http::URI uri = m_uri;
338 uri.AddPathSegments("/v1/apis/");
339 uri.AddPathSegment(request.GetApiId());
340 uri.AddPathSegments("/types");
341 return CreateTypeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
342 }
343
CreateTypeCallable(const CreateTypeRequest & request) const344 CreateTypeOutcomeCallable AppSyncClient::CreateTypeCallable(const CreateTypeRequest& request) const
345 {
346 auto task = Aws::MakeShared< std::packaged_task< CreateTypeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateType(request); } );
347 auto packagedFunction = [task]() { (*task)(); };
348 m_executor->Submit(packagedFunction);
349 return task->get_future();
350 }
351
CreateTypeAsync(const CreateTypeRequest & request,const CreateTypeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const352 void AppSyncClient::CreateTypeAsync(const CreateTypeRequest& request, const CreateTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
353 {
354 m_executor->Submit( [this, request, handler, context](){ this->CreateTypeAsyncHelper( request, handler, context ); } );
355 }
356
CreateTypeAsyncHelper(const CreateTypeRequest & request,const CreateTypeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const357 void AppSyncClient::CreateTypeAsyncHelper(const CreateTypeRequest& request, const CreateTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
358 {
359 handler(this, request, CreateType(request), context);
360 }
361
DeleteApiCache(const DeleteApiCacheRequest & request) const362 DeleteApiCacheOutcome AppSyncClient::DeleteApiCache(const DeleteApiCacheRequest& request) const
363 {
364 if (!request.ApiIdHasBeenSet())
365 {
366 AWS_LOGSTREAM_ERROR("DeleteApiCache", "Required field: ApiId, is not set");
367 return DeleteApiCacheOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
368 }
369 Aws::Http::URI uri = m_uri;
370 uri.AddPathSegments("/v1/apis/");
371 uri.AddPathSegment(request.GetApiId());
372 uri.AddPathSegments("/ApiCaches");
373 return DeleteApiCacheOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
374 }
375
DeleteApiCacheCallable(const DeleteApiCacheRequest & request) const376 DeleteApiCacheOutcomeCallable AppSyncClient::DeleteApiCacheCallable(const DeleteApiCacheRequest& request) const
377 {
378 auto task = Aws::MakeShared< std::packaged_task< DeleteApiCacheOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteApiCache(request); } );
379 auto packagedFunction = [task]() { (*task)(); };
380 m_executor->Submit(packagedFunction);
381 return task->get_future();
382 }
383
DeleteApiCacheAsync(const DeleteApiCacheRequest & request,const DeleteApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const384 void AppSyncClient::DeleteApiCacheAsync(const DeleteApiCacheRequest& request, const DeleteApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
385 {
386 m_executor->Submit( [this, request, handler, context](){ this->DeleteApiCacheAsyncHelper( request, handler, context ); } );
387 }
388
DeleteApiCacheAsyncHelper(const DeleteApiCacheRequest & request,const DeleteApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const389 void AppSyncClient::DeleteApiCacheAsyncHelper(const DeleteApiCacheRequest& request, const DeleteApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
390 {
391 handler(this, request, DeleteApiCache(request), context);
392 }
393
DeleteApiKey(const DeleteApiKeyRequest & request) const394 DeleteApiKeyOutcome AppSyncClient::DeleteApiKey(const DeleteApiKeyRequest& request) const
395 {
396 if (!request.ApiIdHasBeenSet())
397 {
398 AWS_LOGSTREAM_ERROR("DeleteApiKey", "Required field: ApiId, is not set");
399 return DeleteApiKeyOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
400 }
401 if (!request.IdHasBeenSet())
402 {
403 AWS_LOGSTREAM_ERROR("DeleteApiKey", "Required field: Id, is not set");
404 return DeleteApiKeyOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
405 }
406 Aws::Http::URI uri = m_uri;
407 uri.AddPathSegments("/v1/apis/");
408 uri.AddPathSegment(request.GetApiId());
409 uri.AddPathSegments("/apikeys/");
410 uri.AddPathSegment(request.GetId());
411 return DeleteApiKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
412 }
413
DeleteApiKeyCallable(const DeleteApiKeyRequest & request) const414 DeleteApiKeyOutcomeCallable AppSyncClient::DeleteApiKeyCallable(const DeleteApiKeyRequest& request) const
415 {
416 auto task = Aws::MakeShared< std::packaged_task< DeleteApiKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteApiKey(request); } );
417 auto packagedFunction = [task]() { (*task)(); };
418 m_executor->Submit(packagedFunction);
419 return task->get_future();
420 }
421
DeleteApiKeyAsync(const DeleteApiKeyRequest & request,const DeleteApiKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const422 void AppSyncClient::DeleteApiKeyAsync(const DeleteApiKeyRequest& request, const DeleteApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
423 {
424 m_executor->Submit( [this, request, handler, context](){ this->DeleteApiKeyAsyncHelper( request, handler, context ); } );
425 }
426
DeleteApiKeyAsyncHelper(const DeleteApiKeyRequest & request,const DeleteApiKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const427 void AppSyncClient::DeleteApiKeyAsyncHelper(const DeleteApiKeyRequest& request, const DeleteApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
428 {
429 handler(this, request, DeleteApiKey(request), context);
430 }
431
DeleteDataSource(const DeleteDataSourceRequest & request) const432 DeleteDataSourceOutcome AppSyncClient::DeleteDataSource(const DeleteDataSourceRequest& request) const
433 {
434 if (!request.ApiIdHasBeenSet())
435 {
436 AWS_LOGSTREAM_ERROR("DeleteDataSource", "Required field: ApiId, is not set");
437 return DeleteDataSourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
438 }
439 if (!request.NameHasBeenSet())
440 {
441 AWS_LOGSTREAM_ERROR("DeleteDataSource", "Required field: Name, is not set");
442 return DeleteDataSourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Name]", false));
443 }
444 Aws::Http::URI uri = m_uri;
445 uri.AddPathSegments("/v1/apis/");
446 uri.AddPathSegment(request.GetApiId());
447 uri.AddPathSegments("/datasources/");
448 uri.AddPathSegment(request.GetName());
449 return DeleteDataSourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
450 }
451
DeleteDataSourceCallable(const DeleteDataSourceRequest & request) const452 DeleteDataSourceOutcomeCallable AppSyncClient::DeleteDataSourceCallable(const DeleteDataSourceRequest& request) const
453 {
454 auto task = Aws::MakeShared< std::packaged_task< DeleteDataSourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteDataSource(request); } );
455 auto packagedFunction = [task]() { (*task)(); };
456 m_executor->Submit(packagedFunction);
457 return task->get_future();
458 }
459
DeleteDataSourceAsync(const DeleteDataSourceRequest & request,const DeleteDataSourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const460 void AppSyncClient::DeleteDataSourceAsync(const DeleteDataSourceRequest& request, const DeleteDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
461 {
462 m_executor->Submit( [this, request, handler, context](){ this->DeleteDataSourceAsyncHelper( request, handler, context ); } );
463 }
464
DeleteDataSourceAsyncHelper(const DeleteDataSourceRequest & request,const DeleteDataSourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const465 void AppSyncClient::DeleteDataSourceAsyncHelper(const DeleteDataSourceRequest& request, const DeleteDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
466 {
467 handler(this, request, DeleteDataSource(request), context);
468 }
469
DeleteFunction(const DeleteFunctionRequest & request) const470 DeleteFunctionOutcome AppSyncClient::DeleteFunction(const DeleteFunctionRequest& request) const
471 {
472 if (!request.ApiIdHasBeenSet())
473 {
474 AWS_LOGSTREAM_ERROR("DeleteFunction", "Required field: ApiId, is not set");
475 return DeleteFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
476 }
477 if (!request.FunctionIdHasBeenSet())
478 {
479 AWS_LOGSTREAM_ERROR("DeleteFunction", "Required field: FunctionId, is not set");
480 return DeleteFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionId]", false));
481 }
482 Aws::Http::URI uri = m_uri;
483 uri.AddPathSegments("/v1/apis/");
484 uri.AddPathSegment(request.GetApiId());
485 uri.AddPathSegments("/functions/");
486 uri.AddPathSegment(request.GetFunctionId());
487 return DeleteFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
488 }
489
DeleteFunctionCallable(const DeleteFunctionRequest & request) const490 DeleteFunctionOutcomeCallable AppSyncClient::DeleteFunctionCallable(const DeleteFunctionRequest& request) const
491 {
492 auto task = Aws::MakeShared< std::packaged_task< DeleteFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteFunction(request); } );
493 auto packagedFunction = [task]() { (*task)(); };
494 m_executor->Submit(packagedFunction);
495 return task->get_future();
496 }
497
DeleteFunctionAsync(const DeleteFunctionRequest & request,const DeleteFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const498 void AppSyncClient::DeleteFunctionAsync(const DeleteFunctionRequest& request, const DeleteFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
499 {
500 m_executor->Submit( [this, request, handler, context](){ this->DeleteFunctionAsyncHelper( request, handler, context ); } );
501 }
502
DeleteFunctionAsyncHelper(const DeleteFunctionRequest & request,const DeleteFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const503 void AppSyncClient::DeleteFunctionAsyncHelper(const DeleteFunctionRequest& request, const DeleteFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
504 {
505 handler(this, request, DeleteFunction(request), context);
506 }
507
DeleteGraphqlApi(const DeleteGraphqlApiRequest & request) const508 DeleteGraphqlApiOutcome AppSyncClient::DeleteGraphqlApi(const DeleteGraphqlApiRequest& request) const
509 {
510 if (!request.ApiIdHasBeenSet())
511 {
512 AWS_LOGSTREAM_ERROR("DeleteGraphqlApi", "Required field: ApiId, is not set");
513 return DeleteGraphqlApiOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
514 }
515 Aws::Http::URI uri = m_uri;
516 uri.AddPathSegments("/v1/apis/");
517 uri.AddPathSegment(request.GetApiId());
518 return DeleteGraphqlApiOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
519 }
520
DeleteGraphqlApiCallable(const DeleteGraphqlApiRequest & request) const521 DeleteGraphqlApiOutcomeCallable AppSyncClient::DeleteGraphqlApiCallable(const DeleteGraphqlApiRequest& request) const
522 {
523 auto task = Aws::MakeShared< std::packaged_task< DeleteGraphqlApiOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteGraphqlApi(request); } );
524 auto packagedFunction = [task]() { (*task)(); };
525 m_executor->Submit(packagedFunction);
526 return task->get_future();
527 }
528
DeleteGraphqlApiAsync(const DeleteGraphqlApiRequest & request,const DeleteGraphqlApiResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const529 void AppSyncClient::DeleteGraphqlApiAsync(const DeleteGraphqlApiRequest& request, const DeleteGraphqlApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
530 {
531 m_executor->Submit( [this, request, handler, context](){ this->DeleteGraphqlApiAsyncHelper( request, handler, context ); } );
532 }
533
DeleteGraphqlApiAsyncHelper(const DeleteGraphqlApiRequest & request,const DeleteGraphqlApiResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const534 void AppSyncClient::DeleteGraphqlApiAsyncHelper(const DeleteGraphqlApiRequest& request, const DeleteGraphqlApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
535 {
536 handler(this, request, DeleteGraphqlApi(request), context);
537 }
538
DeleteResolver(const DeleteResolverRequest & request) const539 DeleteResolverOutcome AppSyncClient::DeleteResolver(const DeleteResolverRequest& request) const
540 {
541 if (!request.ApiIdHasBeenSet())
542 {
543 AWS_LOGSTREAM_ERROR("DeleteResolver", "Required field: ApiId, is not set");
544 return DeleteResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
545 }
546 if (!request.TypeNameHasBeenSet())
547 {
548 AWS_LOGSTREAM_ERROR("DeleteResolver", "Required field: TypeName, is not set");
549 return DeleteResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TypeName]", false));
550 }
551 if (!request.FieldNameHasBeenSet())
552 {
553 AWS_LOGSTREAM_ERROR("DeleteResolver", "Required field: FieldName, is not set");
554 return DeleteResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FieldName]", false));
555 }
556 Aws::Http::URI uri = m_uri;
557 uri.AddPathSegments("/v1/apis/");
558 uri.AddPathSegment(request.GetApiId());
559 uri.AddPathSegments("/types/");
560 uri.AddPathSegment(request.GetTypeName());
561 uri.AddPathSegments("/resolvers/");
562 uri.AddPathSegment(request.GetFieldName());
563 return DeleteResolverOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
564 }
565
DeleteResolverCallable(const DeleteResolverRequest & request) const566 DeleteResolverOutcomeCallable AppSyncClient::DeleteResolverCallable(const DeleteResolverRequest& request) const
567 {
568 auto task = Aws::MakeShared< std::packaged_task< DeleteResolverOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteResolver(request); } );
569 auto packagedFunction = [task]() { (*task)(); };
570 m_executor->Submit(packagedFunction);
571 return task->get_future();
572 }
573
DeleteResolverAsync(const DeleteResolverRequest & request,const DeleteResolverResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const574 void AppSyncClient::DeleteResolverAsync(const DeleteResolverRequest& request, const DeleteResolverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
575 {
576 m_executor->Submit( [this, request, handler, context](){ this->DeleteResolverAsyncHelper( request, handler, context ); } );
577 }
578
DeleteResolverAsyncHelper(const DeleteResolverRequest & request,const DeleteResolverResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const579 void AppSyncClient::DeleteResolverAsyncHelper(const DeleteResolverRequest& request, const DeleteResolverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
580 {
581 handler(this, request, DeleteResolver(request), context);
582 }
583
DeleteType(const DeleteTypeRequest & request) const584 DeleteTypeOutcome AppSyncClient::DeleteType(const DeleteTypeRequest& request) const
585 {
586 if (!request.ApiIdHasBeenSet())
587 {
588 AWS_LOGSTREAM_ERROR("DeleteType", "Required field: ApiId, is not set");
589 return DeleteTypeOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
590 }
591 if (!request.TypeNameHasBeenSet())
592 {
593 AWS_LOGSTREAM_ERROR("DeleteType", "Required field: TypeName, is not set");
594 return DeleteTypeOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TypeName]", false));
595 }
596 Aws::Http::URI uri = m_uri;
597 uri.AddPathSegments("/v1/apis/");
598 uri.AddPathSegment(request.GetApiId());
599 uri.AddPathSegments("/types/");
600 uri.AddPathSegment(request.GetTypeName());
601 return DeleteTypeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
602 }
603
DeleteTypeCallable(const DeleteTypeRequest & request) const604 DeleteTypeOutcomeCallable AppSyncClient::DeleteTypeCallable(const DeleteTypeRequest& request) const
605 {
606 auto task = Aws::MakeShared< std::packaged_task< DeleteTypeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteType(request); } );
607 auto packagedFunction = [task]() { (*task)(); };
608 m_executor->Submit(packagedFunction);
609 return task->get_future();
610 }
611
DeleteTypeAsync(const DeleteTypeRequest & request,const DeleteTypeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const612 void AppSyncClient::DeleteTypeAsync(const DeleteTypeRequest& request, const DeleteTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
613 {
614 m_executor->Submit( [this, request, handler, context](){ this->DeleteTypeAsyncHelper( request, handler, context ); } );
615 }
616
DeleteTypeAsyncHelper(const DeleteTypeRequest & request,const DeleteTypeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const617 void AppSyncClient::DeleteTypeAsyncHelper(const DeleteTypeRequest& request, const DeleteTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
618 {
619 handler(this, request, DeleteType(request), context);
620 }
621
FlushApiCache(const FlushApiCacheRequest & request) const622 FlushApiCacheOutcome AppSyncClient::FlushApiCache(const FlushApiCacheRequest& request) const
623 {
624 if (!request.ApiIdHasBeenSet())
625 {
626 AWS_LOGSTREAM_ERROR("FlushApiCache", "Required field: ApiId, is not set");
627 return FlushApiCacheOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
628 }
629 Aws::Http::URI uri = m_uri;
630 uri.AddPathSegments("/v1/apis/");
631 uri.AddPathSegment(request.GetApiId());
632 uri.AddPathSegments("/FlushCache");
633 return FlushApiCacheOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
634 }
635
FlushApiCacheCallable(const FlushApiCacheRequest & request) const636 FlushApiCacheOutcomeCallable AppSyncClient::FlushApiCacheCallable(const FlushApiCacheRequest& request) const
637 {
638 auto task = Aws::MakeShared< std::packaged_task< FlushApiCacheOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->FlushApiCache(request); } );
639 auto packagedFunction = [task]() { (*task)(); };
640 m_executor->Submit(packagedFunction);
641 return task->get_future();
642 }
643
FlushApiCacheAsync(const FlushApiCacheRequest & request,const FlushApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const644 void AppSyncClient::FlushApiCacheAsync(const FlushApiCacheRequest& request, const FlushApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
645 {
646 m_executor->Submit( [this, request, handler, context](){ this->FlushApiCacheAsyncHelper( request, handler, context ); } );
647 }
648
FlushApiCacheAsyncHelper(const FlushApiCacheRequest & request,const FlushApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const649 void AppSyncClient::FlushApiCacheAsyncHelper(const FlushApiCacheRequest& request, const FlushApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
650 {
651 handler(this, request, FlushApiCache(request), context);
652 }
653
GetApiCache(const GetApiCacheRequest & request) const654 GetApiCacheOutcome AppSyncClient::GetApiCache(const GetApiCacheRequest& request) const
655 {
656 if (!request.ApiIdHasBeenSet())
657 {
658 AWS_LOGSTREAM_ERROR("GetApiCache", "Required field: ApiId, is not set");
659 return GetApiCacheOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
660 }
661 Aws::Http::URI uri = m_uri;
662 uri.AddPathSegments("/v1/apis/");
663 uri.AddPathSegment(request.GetApiId());
664 uri.AddPathSegments("/ApiCaches");
665 return GetApiCacheOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
666 }
667
GetApiCacheCallable(const GetApiCacheRequest & request) const668 GetApiCacheOutcomeCallable AppSyncClient::GetApiCacheCallable(const GetApiCacheRequest& request) const
669 {
670 auto task = Aws::MakeShared< std::packaged_task< GetApiCacheOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetApiCache(request); } );
671 auto packagedFunction = [task]() { (*task)(); };
672 m_executor->Submit(packagedFunction);
673 return task->get_future();
674 }
675
GetApiCacheAsync(const GetApiCacheRequest & request,const GetApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const676 void AppSyncClient::GetApiCacheAsync(const GetApiCacheRequest& request, const GetApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
677 {
678 m_executor->Submit( [this, request, handler, context](){ this->GetApiCacheAsyncHelper( request, handler, context ); } );
679 }
680
GetApiCacheAsyncHelper(const GetApiCacheRequest & request,const GetApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const681 void AppSyncClient::GetApiCacheAsyncHelper(const GetApiCacheRequest& request, const GetApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
682 {
683 handler(this, request, GetApiCache(request), context);
684 }
685
GetDataSource(const GetDataSourceRequest & request) const686 GetDataSourceOutcome AppSyncClient::GetDataSource(const GetDataSourceRequest& request) const
687 {
688 if (!request.ApiIdHasBeenSet())
689 {
690 AWS_LOGSTREAM_ERROR("GetDataSource", "Required field: ApiId, is not set");
691 return GetDataSourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
692 }
693 if (!request.NameHasBeenSet())
694 {
695 AWS_LOGSTREAM_ERROR("GetDataSource", "Required field: Name, is not set");
696 return GetDataSourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Name]", false));
697 }
698 Aws::Http::URI uri = m_uri;
699 uri.AddPathSegments("/v1/apis/");
700 uri.AddPathSegment(request.GetApiId());
701 uri.AddPathSegments("/datasources/");
702 uri.AddPathSegment(request.GetName());
703 return GetDataSourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
704 }
705
GetDataSourceCallable(const GetDataSourceRequest & request) const706 GetDataSourceOutcomeCallable AppSyncClient::GetDataSourceCallable(const GetDataSourceRequest& request) const
707 {
708 auto task = Aws::MakeShared< std::packaged_task< GetDataSourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetDataSource(request); } );
709 auto packagedFunction = [task]() { (*task)(); };
710 m_executor->Submit(packagedFunction);
711 return task->get_future();
712 }
713
GetDataSourceAsync(const GetDataSourceRequest & request,const GetDataSourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const714 void AppSyncClient::GetDataSourceAsync(const GetDataSourceRequest& request, const GetDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
715 {
716 m_executor->Submit( [this, request, handler, context](){ this->GetDataSourceAsyncHelper( request, handler, context ); } );
717 }
718
GetDataSourceAsyncHelper(const GetDataSourceRequest & request,const GetDataSourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const719 void AppSyncClient::GetDataSourceAsyncHelper(const GetDataSourceRequest& request, const GetDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
720 {
721 handler(this, request, GetDataSource(request), context);
722 }
723
GetFunction(const GetFunctionRequest & request) const724 GetFunctionOutcome AppSyncClient::GetFunction(const GetFunctionRequest& request) const
725 {
726 if (!request.ApiIdHasBeenSet())
727 {
728 AWS_LOGSTREAM_ERROR("GetFunction", "Required field: ApiId, is not set");
729 return GetFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
730 }
731 if (!request.FunctionIdHasBeenSet())
732 {
733 AWS_LOGSTREAM_ERROR("GetFunction", "Required field: FunctionId, is not set");
734 return GetFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionId]", false));
735 }
736 Aws::Http::URI uri = m_uri;
737 uri.AddPathSegments("/v1/apis/");
738 uri.AddPathSegment(request.GetApiId());
739 uri.AddPathSegments("/functions/");
740 uri.AddPathSegment(request.GetFunctionId());
741 return GetFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
742 }
743
GetFunctionCallable(const GetFunctionRequest & request) const744 GetFunctionOutcomeCallable AppSyncClient::GetFunctionCallable(const GetFunctionRequest& request) const
745 {
746 auto task = Aws::MakeShared< std::packaged_task< GetFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFunction(request); } );
747 auto packagedFunction = [task]() { (*task)(); };
748 m_executor->Submit(packagedFunction);
749 return task->get_future();
750 }
751
GetFunctionAsync(const GetFunctionRequest & request,const GetFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const752 void AppSyncClient::GetFunctionAsync(const GetFunctionRequest& request, const GetFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
753 {
754 m_executor->Submit( [this, request, handler, context](){ this->GetFunctionAsyncHelper( request, handler, context ); } );
755 }
756
GetFunctionAsyncHelper(const GetFunctionRequest & request,const GetFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const757 void AppSyncClient::GetFunctionAsyncHelper(const GetFunctionRequest& request, const GetFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
758 {
759 handler(this, request, GetFunction(request), context);
760 }
761
GetGraphqlApi(const GetGraphqlApiRequest & request) const762 GetGraphqlApiOutcome AppSyncClient::GetGraphqlApi(const GetGraphqlApiRequest& request) const
763 {
764 if (!request.ApiIdHasBeenSet())
765 {
766 AWS_LOGSTREAM_ERROR("GetGraphqlApi", "Required field: ApiId, is not set");
767 return GetGraphqlApiOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
768 }
769 Aws::Http::URI uri = m_uri;
770 uri.AddPathSegments("/v1/apis/");
771 uri.AddPathSegment(request.GetApiId());
772 return GetGraphqlApiOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
773 }
774
GetGraphqlApiCallable(const GetGraphqlApiRequest & request) const775 GetGraphqlApiOutcomeCallable AppSyncClient::GetGraphqlApiCallable(const GetGraphqlApiRequest& request) const
776 {
777 auto task = Aws::MakeShared< std::packaged_task< GetGraphqlApiOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetGraphqlApi(request); } );
778 auto packagedFunction = [task]() { (*task)(); };
779 m_executor->Submit(packagedFunction);
780 return task->get_future();
781 }
782
GetGraphqlApiAsync(const GetGraphqlApiRequest & request,const GetGraphqlApiResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const783 void AppSyncClient::GetGraphqlApiAsync(const GetGraphqlApiRequest& request, const GetGraphqlApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
784 {
785 m_executor->Submit( [this, request, handler, context](){ this->GetGraphqlApiAsyncHelper( request, handler, context ); } );
786 }
787
GetGraphqlApiAsyncHelper(const GetGraphqlApiRequest & request,const GetGraphqlApiResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const788 void AppSyncClient::GetGraphqlApiAsyncHelper(const GetGraphqlApiRequest& request, const GetGraphqlApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
789 {
790 handler(this, request, GetGraphqlApi(request), context);
791 }
792
GetIntrospectionSchema(const GetIntrospectionSchemaRequest & request) const793 GetIntrospectionSchemaOutcome AppSyncClient::GetIntrospectionSchema(const GetIntrospectionSchemaRequest& request) const
794 {
795 if (!request.ApiIdHasBeenSet())
796 {
797 AWS_LOGSTREAM_ERROR("GetIntrospectionSchema", "Required field: ApiId, is not set");
798 return GetIntrospectionSchemaOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
799 }
800 if (!request.FormatHasBeenSet())
801 {
802 AWS_LOGSTREAM_ERROR("GetIntrospectionSchema", "Required field: Format, is not set");
803 return GetIntrospectionSchemaOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Format]", false));
804 }
805 Aws::Http::URI uri = m_uri;
806 uri.AddPathSegments("/v1/apis/");
807 uri.AddPathSegment(request.GetApiId());
808 uri.AddPathSegments("/schema");
809 return GetIntrospectionSchemaOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET));
810 }
811
GetIntrospectionSchemaCallable(const GetIntrospectionSchemaRequest & request) const812 GetIntrospectionSchemaOutcomeCallable AppSyncClient::GetIntrospectionSchemaCallable(const GetIntrospectionSchemaRequest& request) const
813 {
814 auto task = Aws::MakeShared< std::packaged_task< GetIntrospectionSchemaOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetIntrospectionSchema(request); } );
815 auto packagedFunction = [task]() { (*task)(); };
816 m_executor->Submit(packagedFunction);
817 return task->get_future();
818 }
819
GetIntrospectionSchemaAsync(const GetIntrospectionSchemaRequest & request,const GetIntrospectionSchemaResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const820 void AppSyncClient::GetIntrospectionSchemaAsync(const GetIntrospectionSchemaRequest& request, const GetIntrospectionSchemaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
821 {
822 m_executor->Submit( [this, request, handler, context](){ this->GetIntrospectionSchemaAsyncHelper( request, handler, context ); } );
823 }
824
GetIntrospectionSchemaAsyncHelper(const GetIntrospectionSchemaRequest & request,const GetIntrospectionSchemaResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const825 void AppSyncClient::GetIntrospectionSchemaAsyncHelper(const GetIntrospectionSchemaRequest& request, const GetIntrospectionSchemaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
826 {
827 handler(this, request, GetIntrospectionSchema(request), context);
828 }
829
GetResolver(const GetResolverRequest & request) const830 GetResolverOutcome AppSyncClient::GetResolver(const GetResolverRequest& request) const
831 {
832 if (!request.ApiIdHasBeenSet())
833 {
834 AWS_LOGSTREAM_ERROR("GetResolver", "Required field: ApiId, is not set");
835 return GetResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
836 }
837 if (!request.TypeNameHasBeenSet())
838 {
839 AWS_LOGSTREAM_ERROR("GetResolver", "Required field: TypeName, is not set");
840 return GetResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TypeName]", false));
841 }
842 if (!request.FieldNameHasBeenSet())
843 {
844 AWS_LOGSTREAM_ERROR("GetResolver", "Required field: FieldName, is not set");
845 return GetResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FieldName]", false));
846 }
847 Aws::Http::URI uri = m_uri;
848 uri.AddPathSegments("/v1/apis/");
849 uri.AddPathSegment(request.GetApiId());
850 uri.AddPathSegments("/types/");
851 uri.AddPathSegment(request.GetTypeName());
852 uri.AddPathSegments("/resolvers/");
853 uri.AddPathSegment(request.GetFieldName());
854 return GetResolverOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
855 }
856
GetResolverCallable(const GetResolverRequest & request) const857 GetResolverOutcomeCallable AppSyncClient::GetResolverCallable(const GetResolverRequest& request) const
858 {
859 auto task = Aws::MakeShared< std::packaged_task< GetResolverOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolver(request); } );
860 auto packagedFunction = [task]() { (*task)(); };
861 m_executor->Submit(packagedFunction);
862 return task->get_future();
863 }
864
GetResolverAsync(const GetResolverRequest & request,const GetResolverResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const865 void AppSyncClient::GetResolverAsync(const GetResolverRequest& request, const GetResolverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
866 {
867 m_executor->Submit( [this, request, handler, context](){ this->GetResolverAsyncHelper( request, handler, context ); } );
868 }
869
GetResolverAsyncHelper(const GetResolverRequest & request,const GetResolverResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const870 void AppSyncClient::GetResolverAsyncHelper(const GetResolverRequest& request, const GetResolverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
871 {
872 handler(this, request, GetResolver(request), context);
873 }
874
GetSchemaCreationStatus(const GetSchemaCreationStatusRequest & request) const875 GetSchemaCreationStatusOutcome AppSyncClient::GetSchemaCreationStatus(const GetSchemaCreationStatusRequest& request) const
876 {
877 if (!request.ApiIdHasBeenSet())
878 {
879 AWS_LOGSTREAM_ERROR("GetSchemaCreationStatus", "Required field: ApiId, is not set");
880 return GetSchemaCreationStatusOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
881 }
882 Aws::Http::URI uri = m_uri;
883 uri.AddPathSegments("/v1/apis/");
884 uri.AddPathSegment(request.GetApiId());
885 uri.AddPathSegments("/schemacreation");
886 return GetSchemaCreationStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
887 }
888
GetSchemaCreationStatusCallable(const GetSchemaCreationStatusRequest & request) const889 GetSchemaCreationStatusOutcomeCallable AppSyncClient::GetSchemaCreationStatusCallable(const GetSchemaCreationStatusRequest& request) const
890 {
891 auto task = Aws::MakeShared< std::packaged_task< GetSchemaCreationStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetSchemaCreationStatus(request); } );
892 auto packagedFunction = [task]() { (*task)(); };
893 m_executor->Submit(packagedFunction);
894 return task->get_future();
895 }
896
GetSchemaCreationStatusAsync(const GetSchemaCreationStatusRequest & request,const GetSchemaCreationStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const897 void AppSyncClient::GetSchemaCreationStatusAsync(const GetSchemaCreationStatusRequest& request, const GetSchemaCreationStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
898 {
899 m_executor->Submit( [this, request, handler, context](){ this->GetSchemaCreationStatusAsyncHelper( request, handler, context ); } );
900 }
901
GetSchemaCreationStatusAsyncHelper(const GetSchemaCreationStatusRequest & request,const GetSchemaCreationStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const902 void AppSyncClient::GetSchemaCreationStatusAsyncHelper(const GetSchemaCreationStatusRequest& request, const GetSchemaCreationStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
903 {
904 handler(this, request, GetSchemaCreationStatus(request), context);
905 }
906
GetType(const GetTypeRequest & request) const907 GetTypeOutcome AppSyncClient::GetType(const GetTypeRequest& request) const
908 {
909 if (!request.ApiIdHasBeenSet())
910 {
911 AWS_LOGSTREAM_ERROR("GetType", "Required field: ApiId, is not set");
912 return GetTypeOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
913 }
914 if (!request.TypeNameHasBeenSet())
915 {
916 AWS_LOGSTREAM_ERROR("GetType", "Required field: TypeName, is not set");
917 return GetTypeOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TypeName]", false));
918 }
919 if (!request.FormatHasBeenSet())
920 {
921 AWS_LOGSTREAM_ERROR("GetType", "Required field: Format, is not set");
922 return GetTypeOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Format]", false));
923 }
924 Aws::Http::URI uri = m_uri;
925 uri.AddPathSegments("/v1/apis/");
926 uri.AddPathSegment(request.GetApiId());
927 uri.AddPathSegments("/types/");
928 uri.AddPathSegment(request.GetTypeName());
929 return GetTypeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
930 }
931
GetTypeCallable(const GetTypeRequest & request) const932 GetTypeOutcomeCallable AppSyncClient::GetTypeCallable(const GetTypeRequest& request) const
933 {
934 auto task = Aws::MakeShared< std::packaged_task< GetTypeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetType(request); } );
935 auto packagedFunction = [task]() { (*task)(); };
936 m_executor->Submit(packagedFunction);
937 return task->get_future();
938 }
939
GetTypeAsync(const GetTypeRequest & request,const GetTypeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const940 void AppSyncClient::GetTypeAsync(const GetTypeRequest& request, const GetTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
941 {
942 m_executor->Submit( [this, request, handler, context](){ this->GetTypeAsyncHelper( request, handler, context ); } );
943 }
944
GetTypeAsyncHelper(const GetTypeRequest & request,const GetTypeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const945 void AppSyncClient::GetTypeAsyncHelper(const GetTypeRequest& request, const GetTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
946 {
947 handler(this, request, GetType(request), context);
948 }
949
ListApiKeys(const ListApiKeysRequest & request) const950 ListApiKeysOutcome AppSyncClient::ListApiKeys(const ListApiKeysRequest& request) const
951 {
952 if (!request.ApiIdHasBeenSet())
953 {
954 AWS_LOGSTREAM_ERROR("ListApiKeys", "Required field: ApiId, is not set");
955 return ListApiKeysOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
956 }
957 Aws::Http::URI uri = m_uri;
958 uri.AddPathSegments("/v1/apis/");
959 uri.AddPathSegment(request.GetApiId());
960 uri.AddPathSegments("/apikeys");
961 return ListApiKeysOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
962 }
963
ListApiKeysCallable(const ListApiKeysRequest & request) const964 ListApiKeysOutcomeCallable AppSyncClient::ListApiKeysCallable(const ListApiKeysRequest& request) const
965 {
966 auto task = Aws::MakeShared< std::packaged_task< ListApiKeysOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListApiKeys(request); } );
967 auto packagedFunction = [task]() { (*task)(); };
968 m_executor->Submit(packagedFunction);
969 return task->get_future();
970 }
971
ListApiKeysAsync(const ListApiKeysRequest & request,const ListApiKeysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const972 void AppSyncClient::ListApiKeysAsync(const ListApiKeysRequest& request, const ListApiKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
973 {
974 m_executor->Submit( [this, request, handler, context](){ this->ListApiKeysAsyncHelper( request, handler, context ); } );
975 }
976
ListApiKeysAsyncHelper(const ListApiKeysRequest & request,const ListApiKeysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const977 void AppSyncClient::ListApiKeysAsyncHelper(const ListApiKeysRequest& request, const ListApiKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
978 {
979 handler(this, request, ListApiKeys(request), context);
980 }
981
ListDataSources(const ListDataSourcesRequest & request) const982 ListDataSourcesOutcome AppSyncClient::ListDataSources(const ListDataSourcesRequest& request) const
983 {
984 if (!request.ApiIdHasBeenSet())
985 {
986 AWS_LOGSTREAM_ERROR("ListDataSources", "Required field: ApiId, is not set");
987 return ListDataSourcesOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
988 }
989 Aws::Http::URI uri = m_uri;
990 uri.AddPathSegments("/v1/apis/");
991 uri.AddPathSegment(request.GetApiId());
992 uri.AddPathSegments("/datasources");
993 return ListDataSourcesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
994 }
995
ListDataSourcesCallable(const ListDataSourcesRequest & request) const996 ListDataSourcesOutcomeCallable AppSyncClient::ListDataSourcesCallable(const ListDataSourcesRequest& request) const
997 {
998 auto task = Aws::MakeShared< std::packaged_task< ListDataSourcesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDataSources(request); } );
999 auto packagedFunction = [task]() { (*task)(); };
1000 m_executor->Submit(packagedFunction);
1001 return task->get_future();
1002 }
1003
ListDataSourcesAsync(const ListDataSourcesRequest & request,const ListDataSourcesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1004 void AppSyncClient::ListDataSourcesAsync(const ListDataSourcesRequest& request, const ListDataSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1005 {
1006 m_executor->Submit( [this, request, handler, context](){ this->ListDataSourcesAsyncHelper( request, handler, context ); } );
1007 }
1008
ListDataSourcesAsyncHelper(const ListDataSourcesRequest & request,const ListDataSourcesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1009 void AppSyncClient::ListDataSourcesAsyncHelper(const ListDataSourcesRequest& request, const ListDataSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1010 {
1011 handler(this, request, ListDataSources(request), context);
1012 }
1013
ListFunctions(const ListFunctionsRequest & request) const1014 ListFunctionsOutcome AppSyncClient::ListFunctions(const ListFunctionsRequest& request) const
1015 {
1016 if (!request.ApiIdHasBeenSet())
1017 {
1018 AWS_LOGSTREAM_ERROR("ListFunctions", "Required field: ApiId, is not set");
1019 return ListFunctionsOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1020 }
1021 Aws::Http::URI uri = m_uri;
1022 uri.AddPathSegments("/v1/apis/");
1023 uri.AddPathSegment(request.GetApiId());
1024 uri.AddPathSegments("/functions");
1025 return ListFunctionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1026 }
1027
ListFunctionsCallable(const ListFunctionsRequest & request) const1028 ListFunctionsOutcomeCallable AppSyncClient::ListFunctionsCallable(const ListFunctionsRequest& request) const
1029 {
1030 auto task = Aws::MakeShared< std::packaged_task< ListFunctionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFunctions(request); } );
1031 auto packagedFunction = [task]() { (*task)(); };
1032 m_executor->Submit(packagedFunction);
1033 return task->get_future();
1034 }
1035
ListFunctionsAsync(const ListFunctionsRequest & request,const ListFunctionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1036 void AppSyncClient::ListFunctionsAsync(const ListFunctionsRequest& request, const ListFunctionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1037 {
1038 m_executor->Submit( [this, request, handler, context](){ this->ListFunctionsAsyncHelper( request, handler, context ); } );
1039 }
1040
ListFunctionsAsyncHelper(const ListFunctionsRequest & request,const ListFunctionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1041 void AppSyncClient::ListFunctionsAsyncHelper(const ListFunctionsRequest& request, const ListFunctionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1042 {
1043 handler(this, request, ListFunctions(request), context);
1044 }
1045
ListGraphqlApis(const ListGraphqlApisRequest & request) const1046 ListGraphqlApisOutcome AppSyncClient::ListGraphqlApis(const ListGraphqlApisRequest& request) const
1047 {
1048 Aws::Http::URI uri = m_uri;
1049 uri.AddPathSegments("/v1/apis");
1050 return ListGraphqlApisOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1051 }
1052
ListGraphqlApisCallable(const ListGraphqlApisRequest & request) const1053 ListGraphqlApisOutcomeCallable AppSyncClient::ListGraphqlApisCallable(const ListGraphqlApisRequest& request) const
1054 {
1055 auto task = Aws::MakeShared< std::packaged_task< ListGraphqlApisOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListGraphqlApis(request); } );
1056 auto packagedFunction = [task]() { (*task)(); };
1057 m_executor->Submit(packagedFunction);
1058 return task->get_future();
1059 }
1060
ListGraphqlApisAsync(const ListGraphqlApisRequest & request,const ListGraphqlApisResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1061 void AppSyncClient::ListGraphqlApisAsync(const ListGraphqlApisRequest& request, const ListGraphqlApisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1062 {
1063 m_executor->Submit( [this, request, handler, context](){ this->ListGraphqlApisAsyncHelper( request, handler, context ); } );
1064 }
1065
ListGraphqlApisAsyncHelper(const ListGraphqlApisRequest & request,const ListGraphqlApisResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1066 void AppSyncClient::ListGraphqlApisAsyncHelper(const ListGraphqlApisRequest& request, const ListGraphqlApisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1067 {
1068 handler(this, request, ListGraphqlApis(request), context);
1069 }
1070
ListResolvers(const ListResolversRequest & request) const1071 ListResolversOutcome AppSyncClient::ListResolvers(const ListResolversRequest& request) const
1072 {
1073 if (!request.ApiIdHasBeenSet())
1074 {
1075 AWS_LOGSTREAM_ERROR("ListResolvers", "Required field: ApiId, is not set");
1076 return ListResolversOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1077 }
1078 if (!request.TypeNameHasBeenSet())
1079 {
1080 AWS_LOGSTREAM_ERROR("ListResolvers", "Required field: TypeName, is not set");
1081 return ListResolversOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TypeName]", false));
1082 }
1083 Aws::Http::URI uri = m_uri;
1084 uri.AddPathSegments("/v1/apis/");
1085 uri.AddPathSegment(request.GetApiId());
1086 uri.AddPathSegments("/types/");
1087 uri.AddPathSegment(request.GetTypeName());
1088 uri.AddPathSegments("/resolvers");
1089 return ListResolversOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1090 }
1091
ListResolversCallable(const ListResolversRequest & request) const1092 ListResolversOutcomeCallable AppSyncClient::ListResolversCallable(const ListResolversRequest& request) const
1093 {
1094 auto task = Aws::MakeShared< std::packaged_task< ListResolversOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolvers(request); } );
1095 auto packagedFunction = [task]() { (*task)(); };
1096 m_executor->Submit(packagedFunction);
1097 return task->get_future();
1098 }
1099
ListResolversAsync(const ListResolversRequest & request,const ListResolversResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1100 void AppSyncClient::ListResolversAsync(const ListResolversRequest& request, const ListResolversResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1101 {
1102 m_executor->Submit( [this, request, handler, context](){ this->ListResolversAsyncHelper( request, handler, context ); } );
1103 }
1104
ListResolversAsyncHelper(const ListResolversRequest & request,const ListResolversResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1105 void AppSyncClient::ListResolversAsyncHelper(const ListResolversRequest& request, const ListResolversResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1106 {
1107 handler(this, request, ListResolvers(request), context);
1108 }
1109
ListResolversByFunction(const ListResolversByFunctionRequest & request) const1110 ListResolversByFunctionOutcome AppSyncClient::ListResolversByFunction(const ListResolversByFunctionRequest& request) const
1111 {
1112 if (!request.ApiIdHasBeenSet())
1113 {
1114 AWS_LOGSTREAM_ERROR("ListResolversByFunction", "Required field: ApiId, is not set");
1115 return ListResolversByFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1116 }
1117 if (!request.FunctionIdHasBeenSet())
1118 {
1119 AWS_LOGSTREAM_ERROR("ListResolversByFunction", "Required field: FunctionId, is not set");
1120 return ListResolversByFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionId]", false));
1121 }
1122 Aws::Http::URI uri = m_uri;
1123 uri.AddPathSegments("/v1/apis/");
1124 uri.AddPathSegment(request.GetApiId());
1125 uri.AddPathSegments("/functions/");
1126 uri.AddPathSegment(request.GetFunctionId());
1127 uri.AddPathSegments("/resolvers");
1128 return ListResolversByFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1129 }
1130
ListResolversByFunctionCallable(const ListResolversByFunctionRequest & request) const1131 ListResolversByFunctionOutcomeCallable AppSyncClient::ListResolversByFunctionCallable(const ListResolversByFunctionRequest& request) const
1132 {
1133 auto task = Aws::MakeShared< std::packaged_task< ListResolversByFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolversByFunction(request); } );
1134 auto packagedFunction = [task]() { (*task)(); };
1135 m_executor->Submit(packagedFunction);
1136 return task->get_future();
1137 }
1138
ListResolversByFunctionAsync(const ListResolversByFunctionRequest & request,const ListResolversByFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1139 void AppSyncClient::ListResolversByFunctionAsync(const ListResolversByFunctionRequest& request, const ListResolversByFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1140 {
1141 m_executor->Submit( [this, request, handler, context](){ this->ListResolversByFunctionAsyncHelper( request, handler, context ); } );
1142 }
1143
ListResolversByFunctionAsyncHelper(const ListResolversByFunctionRequest & request,const ListResolversByFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1144 void AppSyncClient::ListResolversByFunctionAsyncHelper(const ListResolversByFunctionRequest& request, const ListResolversByFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1145 {
1146 handler(this, request, ListResolversByFunction(request), context);
1147 }
1148
ListTagsForResource(const ListTagsForResourceRequest & request) const1149 ListTagsForResourceOutcome AppSyncClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
1150 {
1151 if (!request.ResourceArnHasBeenSet())
1152 {
1153 AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceArn, is not set");
1154 return ListTagsForResourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1155 }
1156 Aws::Http::URI uri = m_uri;
1157 uri.AddPathSegments("/v1/tags/");
1158 uri.AddPathSegment(request.GetResourceArn());
1159 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1160 }
1161
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const1162 ListTagsForResourceOutcomeCallable AppSyncClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
1163 {
1164 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
1165 auto packagedFunction = [task]() { (*task)(); };
1166 m_executor->Submit(packagedFunction);
1167 return task->get_future();
1168 }
1169
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1170 void AppSyncClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1171 {
1172 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
1173 }
1174
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1175 void AppSyncClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1176 {
1177 handler(this, request, ListTagsForResource(request), context);
1178 }
1179
ListTypes(const ListTypesRequest & request) const1180 ListTypesOutcome AppSyncClient::ListTypes(const ListTypesRequest& request) const
1181 {
1182 if (!request.ApiIdHasBeenSet())
1183 {
1184 AWS_LOGSTREAM_ERROR("ListTypes", "Required field: ApiId, is not set");
1185 return ListTypesOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1186 }
1187 if (!request.FormatHasBeenSet())
1188 {
1189 AWS_LOGSTREAM_ERROR("ListTypes", "Required field: Format, is not set");
1190 return ListTypesOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Format]", false));
1191 }
1192 Aws::Http::URI uri = m_uri;
1193 uri.AddPathSegments("/v1/apis/");
1194 uri.AddPathSegment(request.GetApiId());
1195 uri.AddPathSegments("/types");
1196 return ListTypesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1197 }
1198
ListTypesCallable(const ListTypesRequest & request) const1199 ListTypesOutcomeCallable AppSyncClient::ListTypesCallable(const ListTypesRequest& request) const
1200 {
1201 auto task = Aws::MakeShared< std::packaged_task< ListTypesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTypes(request); } );
1202 auto packagedFunction = [task]() { (*task)(); };
1203 m_executor->Submit(packagedFunction);
1204 return task->get_future();
1205 }
1206
ListTypesAsync(const ListTypesRequest & request,const ListTypesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1207 void AppSyncClient::ListTypesAsync(const ListTypesRequest& request, const ListTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1208 {
1209 m_executor->Submit( [this, request, handler, context](){ this->ListTypesAsyncHelper( request, handler, context ); } );
1210 }
1211
ListTypesAsyncHelper(const ListTypesRequest & request,const ListTypesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1212 void AppSyncClient::ListTypesAsyncHelper(const ListTypesRequest& request, const ListTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1213 {
1214 handler(this, request, ListTypes(request), context);
1215 }
1216
StartSchemaCreation(const StartSchemaCreationRequest & request) const1217 StartSchemaCreationOutcome AppSyncClient::StartSchemaCreation(const StartSchemaCreationRequest& request) const
1218 {
1219 if (!request.ApiIdHasBeenSet())
1220 {
1221 AWS_LOGSTREAM_ERROR("StartSchemaCreation", "Required field: ApiId, is not set");
1222 return StartSchemaCreationOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1223 }
1224 Aws::Http::URI uri = m_uri;
1225 uri.AddPathSegments("/v1/apis/");
1226 uri.AddPathSegment(request.GetApiId());
1227 uri.AddPathSegments("/schemacreation");
1228 return StartSchemaCreationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1229 }
1230
StartSchemaCreationCallable(const StartSchemaCreationRequest & request) const1231 StartSchemaCreationOutcomeCallable AppSyncClient::StartSchemaCreationCallable(const StartSchemaCreationRequest& request) const
1232 {
1233 auto task = Aws::MakeShared< std::packaged_task< StartSchemaCreationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartSchemaCreation(request); } );
1234 auto packagedFunction = [task]() { (*task)(); };
1235 m_executor->Submit(packagedFunction);
1236 return task->get_future();
1237 }
1238
StartSchemaCreationAsync(const StartSchemaCreationRequest & request,const StartSchemaCreationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1239 void AppSyncClient::StartSchemaCreationAsync(const StartSchemaCreationRequest& request, const StartSchemaCreationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1240 {
1241 m_executor->Submit( [this, request, handler, context](){ this->StartSchemaCreationAsyncHelper( request, handler, context ); } );
1242 }
1243
StartSchemaCreationAsyncHelper(const StartSchemaCreationRequest & request,const StartSchemaCreationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1244 void AppSyncClient::StartSchemaCreationAsyncHelper(const StartSchemaCreationRequest& request, const StartSchemaCreationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1245 {
1246 handler(this, request, StartSchemaCreation(request), context);
1247 }
1248
TagResource(const TagResourceRequest & request) const1249 TagResourceOutcome AppSyncClient::TagResource(const TagResourceRequest& request) const
1250 {
1251 if (!request.ResourceArnHasBeenSet())
1252 {
1253 AWS_LOGSTREAM_ERROR("TagResource", "Required field: ResourceArn, is not set");
1254 return TagResourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1255 }
1256 Aws::Http::URI uri = m_uri;
1257 uri.AddPathSegments("/v1/tags/");
1258 uri.AddPathSegment(request.GetResourceArn());
1259 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1260 }
1261
TagResourceCallable(const TagResourceRequest & request) const1262 TagResourceOutcomeCallable AppSyncClient::TagResourceCallable(const TagResourceRequest& request) const
1263 {
1264 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
1265 auto packagedFunction = [task]() { (*task)(); };
1266 m_executor->Submit(packagedFunction);
1267 return task->get_future();
1268 }
1269
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1270 void AppSyncClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1271 {
1272 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
1273 }
1274
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1275 void AppSyncClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1276 {
1277 handler(this, request, TagResource(request), context);
1278 }
1279
UntagResource(const UntagResourceRequest & request) const1280 UntagResourceOutcome AppSyncClient::UntagResource(const UntagResourceRequest& request) const
1281 {
1282 if (!request.ResourceArnHasBeenSet())
1283 {
1284 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: ResourceArn, is not set");
1285 return UntagResourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1286 }
1287 if (!request.TagKeysHasBeenSet())
1288 {
1289 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: TagKeys, is not set");
1290 return UntagResourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TagKeys]", false));
1291 }
1292 Aws::Http::URI uri = m_uri;
1293 uri.AddPathSegments("/v1/tags/");
1294 uri.AddPathSegment(request.GetResourceArn());
1295 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1296 }
1297
UntagResourceCallable(const UntagResourceRequest & request) const1298 UntagResourceOutcomeCallable AppSyncClient::UntagResourceCallable(const UntagResourceRequest& request) const
1299 {
1300 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
1301 auto packagedFunction = [task]() { (*task)(); };
1302 m_executor->Submit(packagedFunction);
1303 return task->get_future();
1304 }
1305
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1306 void AppSyncClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1307 {
1308 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
1309 }
1310
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1311 void AppSyncClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1312 {
1313 handler(this, request, UntagResource(request), context);
1314 }
1315
UpdateApiCache(const UpdateApiCacheRequest & request) const1316 UpdateApiCacheOutcome AppSyncClient::UpdateApiCache(const UpdateApiCacheRequest& request) const
1317 {
1318 if (!request.ApiIdHasBeenSet())
1319 {
1320 AWS_LOGSTREAM_ERROR("UpdateApiCache", "Required field: ApiId, is not set");
1321 return UpdateApiCacheOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1322 }
1323 Aws::Http::URI uri = m_uri;
1324 uri.AddPathSegments("/v1/apis/");
1325 uri.AddPathSegment(request.GetApiId());
1326 uri.AddPathSegments("/ApiCaches/update");
1327 return UpdateApiCacheOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1328 }
1329
UpdateApiCacheCallable(const UpdateApiCacheRequest & request) const1330 UpdateApiCacheOutcomeCallable AppSyncClient::UpdateApiCacheCallable(const UpdateApiCacheRequest& request) const
1331 {
1332 auto task = Aws::MakeShared< std::packaged_task< UpdateApiCacheOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateApiCache(request); } );
1333 auto packagedFunction = [task]() { (*task)(); };
1334 m_executor->Submit(packagedFunction);
1335 return task->get_future();
1336 }
1337
UpdateApiCacheAsync(const UpdateApiCacheRequest & request,const UpdateApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1338 void AppSyncClient::UpdateApiCacheAsync(const UpdateApiCacheRequest& request, const UpdateApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1339 {
1340 m_executor->Submit( [this, request, handler, context](){ this->UpdateApiCacheAsyncHelper( request, handler, context ); } );
1341 }
1342
UpdateApiCacheAsyncHelper(const UpdateApiCacheRequest & request,const UpdateApiCacheResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1343 void AppSyncClient::UpdateApiCacheAsyncHelper(const UpdateApiCacheRequest& request, const UpdateApiCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1344 {
1345 handler(this, request, UpdateApiCache(request), context);
1346 }
1347
UpdateApiKey(const UpdateApiKeyRequest & request) const1348 UpdateApiKeyOutcome AppSyncClient::UpdateApiKey(const UpdateApiKeyRequest& request) const
1349 {
1350 if (!request.ApiIdHasBeenSet())
1351 {
1352 AWS_LOGSTREAM_ERROR("UpdateApiKey", "Required field: ApiId, is not set");
1353 return UpdateApiKeyOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1354 }
1355 if (!request.IdHasBeenSet())
1356 {
1357 AWS_LOGSTREAM_ERROR("UpdateApiKey", "Required field: Id, is not set");
1358 return UpdateApiKeyOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Id]", false));
1359 }
1360 Aws::Http::URI uri = m_uri;
1361 uri.AddPathSegments("/v1/apis/");
1362 uri.AddPathSegment(request.GetApiId());
1363 uri.AddPathSegments("/apikeys/");
1364 uri.AddPathSegment(request.GetId());
1365 return UpdateApiKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1366 }
1367
UpdateApiKeyCallable(const UpdateApiKeyRequest & request) const1368 UpdateApiKeyOutcomeCallable AppSyncClient::UpdateApiKeyCallable(const UpdateApiKeyRequest& request) const
1369 {
1370 auto task = Aws::MakeShared< std::packaged_task< UpdateApiKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateApiKey(request); } );
1371 auto packagedFunction = [task]() { (*task)(); };
1372 m_executor->Submit(packagedFunction);
1373 return task->get_future();
1374 }
1375
UpdateApiKeyAsync(const UpdateApiKeyRequest & request,const UpdateApiKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1376 void AppSyncClient::UpdateApiKeyAsync(const UpdateApiKeyRequest& request, const UpdateApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1377 {
1378 m_executor->Submit( [this, request, handler, context](){ this->UpdateApiKeyAsyncHelper( request, handler, context ); } );
1379 }
1380
UpdateApiKeyAsyncHelper(const UpdateApiKeyRequest & request,const UpdateApiKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1381 void AppSyncClient::UpdateApiKeyAsyncHelper(const UpdateApiKeyRequest& request, const UpdateApiKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1382 {
1383 handler(this, request, UpdateApiKey(request), context);
1384 }
1385
UpdateDataSource(const UpdateDataSourceRequest & request) const1386 UpdateDataSourceOutcome AppSyncClient::UpdateDataSource(const UpdateDataSourceRequest& request) const
1387 {
1388 if (!request.ApiIdHasBeenSet())
1389 {
1390 AWS_LOGSTREAM_ERROR("UpdateDataSource", "Required field: ApiId, is not set");
1391 return UpdateDataSourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1392 }
1393 if (!request.NameHasBeenSet())
1394 {
1395 AWS_LOGSTREAM_ERROR("UpdateDataSource", "Required field: Name, is not set");
1396 return UpdateDataSourceOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Name]", false));
1397 }
1398 Aws::Http::URI uri = m_uri;
1399 uri.AddPathSegments("/v1/apis/");
1400 uri.AddPathSegment(request.GetApiId());
1401 uri.AddPathSegments("/datasources/");
1402 uri.AddPathSegment(request.GetName());
1403 return UpdateDataSourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1404 }
1405
UpdateDataSourceCallable(const UpdateDataSourceRequest & request) const1406 UpdateDataSourceOutcomeCallable AppSyncClient::UpdateDataSourceCallable(const UpdateDataSourceRequest& request) const
1407 {
1408 auto task = Aws::MakeShared< std::packaged_task< UpdateDataSourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateDataSource(request); } );
1409 auto packagedFunction = [task]() { (*task)(); };
1410 m_executor->Submit(packagedFunction);
1411 return task->get_future();
1412 }
1413
UpdateDataSourceAsync(const UpdateDataSourceRequest & request,const UpdateDataSourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1414 void AppSyncClient::UpdateDataSourceAsync(const UpdateDataSourceRequest& request, const UpdateDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1415 {
1416 m_executor->Submit( [this, request, handler, context](){ this->UpdateDataSourceAsyncHelper( request, handler, context ); } );
1417 }
1418
UpdateDataSourceAsyncHelper(const UpdateDataSourceRequest & request,const UpdateDataSourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1419 void AppSyncClient::UpdateDataSourceAsyncHelper(const UpdateDataSourceRequest& request, const UpdateDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1420 {
1421 handler(this, request, UpdateDataSource(request), context);
1422 }
1423
UpdateFunction(const UpdateFunctionRequest & request) const1424 UpdateFunctionOutcome AppSyncClient::UpdateFunction(const UpdateFunctionRequest& request) const
1425 {
1426 if (!request.ApiIdHasBeenSet())
1427 {
1428 AWS_LOGSTREAM_ERROR("UpdateFunction", "Required field: ApiId, is not set");
1429 return UpdateFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1430 }
1431 if (!request.FunctionIdHasBeenSet())
1432 {
1433 AWS_LOGSTREAM_ERROR("UpdateFunction", "Required field: FunctionId, is not set");
1434 return UpdateFunctionOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionId]", false));
1435 }
1436 Aws::Http::URI uri = m_uri;
1437 uri.AddPathSegments("/v1/apis/");
1438 uri.AddPathSegment(request.GetApiId());
1439 uri.AddPathSegments("/functions/");
1440 uri.AddPathSegment(request.GetFunctionId());
1441 return UpdateFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1442 }
1443
UpdateFunctionCallable(const UpdateFunctionRequest & request) const1444 UpdateFunctionOutcomeCallable AppSyncClient::UpdateFunctionCallable(const UpdateFunctionRequest& request) const
1445 {
1446 auto task = Aws::MakeShared< std::packaged_task< UpdateFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateFunction(request); } );
1447 auto packagedFunction = [task]() { (*task)(); };
1448 m_executor->Submit(packagedFunction);
1449 return task->get_future();
1450 }
1451
UpdateFunctionAsync(const UpdateFunctionRequest & request,const UpdateFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1452 void AppSyncClient::UpdateFunctionAsync(const UpdateFunctionRequest& request, const UpdateFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1453 {
1454 m_executor->Submit( [this, request, handler, context](){ this->UpdateFunctionAsyncHelper( request, handler, context ); } );
1455 }
1456
UpdateFunctionAsyncHelper(const UpdateFunctionRequest & request,const UpdateFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1457 void AppSyncClient::UpdateFunctionAsyncHelper(const UpdateFunctionRequest& request, const UpdateFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1458 {
1459 handler(this, request, UpdateFunction(request), context);
1460 }
1461
UpdateGraphqlApi(const UpdateGraphqlApiRequest & request) const1462 UpdateGraphqlApiOutcome AppSyncClient::UpdateGraphqlApi(const UpdateGraphqlApiRequest& request) const
1463 {
1464 if (!request.ApiIdHasBeenSet())
1465 {
1466 AWS_LOGSTREAM_ERROR("UpdateGraphqlApi", "Required field: ApiId, is not set");
1467 return UpdateGraphqlApiOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1468 }
1469 Aws::Http::URI uri = m_uri;
1470 uri.AddPathSegments("/v1/apis/");
1471 uri.AddPathSegment(request.GetApiId());
1472 return UpdateGraphqlApiOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1473 }
1474
UpdateGraphqlApiCallable(const UpdateGraphqlApiRequest & request) const1475 UpdateGraphqlApiOutcomeCallable AppSyncClient::UpdateGraphqlApiCallable(const UpdateGraphqlApiRequest& request) const
1476 {
1477 auto task = Aws::MakeShared< std::packaged_task< UpdateGraphqlApiOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateGraphqlApi(request); } );
1478 auto packagedFunction = [task]() { (*task)(); };
1479 m_executor->Submit(packagedFunction);
1480 return task->get_future();
1481 }
1482
UpdateGraphqlApiAsync(const UpdateGraphqlApiRequest & request,const UpdateGraphqlApiResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1483 void AppSyncClient::UpdateGraphqlApiAsync(const UpdateGraphqlApiRequest& request, const UpdateGraphqlApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1484 {
1485 m_executor->Submit( [this, request, handler, context](){ this->UpdateGraphqlApiAsyncHelper( request, handler, context ); } );
1486 }
1487
UpdateGraphqlApiAsyncHelper(const UpdateGraphqlApiRequest & request,const UpdateGraphqlApiResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1488 void AppSyncClient::UpdateGraphqlApiAsyncHelper(const UpdateGraphqlApiRequest& request, const UpdateGraphqlApiResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1489 {
1490 handler(this, request, UpdateGraphqlApi(request), context);
1491 }
1492
UpdateResolver(const UpdateResolverRequest & request) const1493 UpdateResolverOutcome AppSyncClient::UpdateResolver(const UpdateResolverRequest& request) const
1494 {
1495 if (!request.ApiIdHasBeenSet())
1496 {
1497 AWS_LOGSTREAM_ERROR("UpdateResolver", "Required field: ApiId, is not set");
1498 return UpdateResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1499 }
1500 if (!request.TypeNameHasBeenSet())
1501 {
1502 AWS_LOGSTREAM_ERROR("UpdateResolver", "Required field: TypeName, is not set");
1503 return UpdateResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TypeName]", false));
1504 }
1505 if (!request.FieldNameHasBeenSet())
1506 {
1507 AWS_LOGSTREAM_ERROR("UpdateResolver", "Required field: FieldName, is not set");
1508 return UpdateResolverOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FieldName]", false));
1509 }
1510 Aws::Http::URI uri = m_uri;
1511 uri.AddPathSegments("/v1/apis/");
1512 uri.AddPathSegment(request.GetApiId());
1513 uri.AddPathSegments("/types/");
1514 uri.AddPathSegment(request.GetTypeName());
1515 uri.AddPathSegments("/resolvers/");
1516 uri.AddPathSegment(request.GetFieldName());
1517 return UpdateResolverOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1518 }
1519
UpdateResolverCallable(const UpdateResolverRequest & request) const1520 UpdateResolverOutcomeCallable AppSyncClient::UpdateResolverCallable(const UpdateResolverRequest& request) const
1521 {
1522 auto task = Aws::MakeShared< std::packaged_task< UpdateResolverOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateResolver(request); } );
1523 auto packagedFunction = [task]() { (*task)(); };
1524 m_executor->Submit(packagedFunction);
1525 return task->get_future();
1526 }
1527
UpdateResolverAsync(const UpdateResolverRequest & request,const UpdateResolverResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1528 void AppSyncClient::UpdateResolverAsync(const UpdateResolverRequest& request, const UpdateResolverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1529 {
1530 m_executor->Submit( [this, request, handler, context](){ this->UpdateResolverAsyncHelper( request, handler, context ); } );
1531 }
1532
UpdateResolverAsyncHelper(const UpdateResolverRequest & request,const UpdateResolverResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1533 void AppSyncClient::UpdateResolverAsyncHelper(const UpdateResolverRequest& request, const UpdateResolverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1534 {
1535 handler(this, request, UpdateResolver(request), context);
1536 }
1537
UpdateType(const UpdateTypeRequest & request) const1538 UpdateTypeOutcome AppSyncClient::UpdateType(const UpdateTypeRequest& request) const
1539 {
1540 if (!request.ApiIdHasBeenSet())
1541 {
1542 AWS_LOGSTREAM_ERROR("UpdateType", "Required field: ApiId, is not set");
1543 return UpdateTypeOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ApiId]", false));
1544 }
1545 if (!request.TypeNameHasBeenSet())
1546 {
1547 AWS_LOGSTREAM_ERROR("UpdateType", "Required field: TypeName, is not set");
1548 return UpdateTypeOutcome(Aws::Client::AWSError<AppSyncErrors>(AppSyncErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TypeName]", false));
1549 }
1550 Aws::Http::URI uri = m_uri;
1551 uri.AddPathSegments("/v1/apis/");
1552 uri.AddPathSegment(request.GetApiId());
1553 uri.AddPathSegments("/types/");
1554 uri.AddPathSegment(request.GetTypeName());
1555 return UpdateTypeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1556 }
1557
UpdateTypeCallable(const UpdateTypeRequest & request) const1558 UpdateTypeOutcomeCallable AppSyncClient::UpdateTypeCallable(const UpdateTypeRequest& request) const
1559 {
1560 auto task = Aws::MakeShared< std::packaged_task< UpdateTypeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateType(request); } );
1561 auto packagedFunction = [task]() { (*task)(); };
1562 m_executor->Submit(packagedFunction);
1563 return task->get_future();
1564 }
1565
UpdateTypeAsync(const UpdateTypeRequest & request,const UpdateTypeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1566 void AppSyncClient::UpdateTypeAsync(const UpdateTypeRequest& request, const UpdateTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1567 {
1568 m_executor->Submit( [this, request, handler, context](){ this->UpdateTypeAsyncHelper( request, handler, context ); } );
1569 }
1570
UpdateTypeAsyncHelper(const UpdateTypeRequest & request,const UpdateTypeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1571 void AppSyncClient::UpdateTypeAsyncHelper(const UpdateTypeRequest& request, const UpdateTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1572 {
1573 handler(this, request, UpdateType(request), context);
1574 }
1575
1576