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/connect/ConnectClient.h>
21 #include <aws/connect/ConnectEndpoint.h>
22 #include <aws/connect/ConnectErrorMarshaller.h>
23 #include <aws/connect/model/AssociateApprovedOriginRequest.h>
24 #include <aws/connect/model/AssociateBotRequest.h>
25 #include <aws/connect/model/AssociateInstanceStorageConfigRequest.h>
26 #include <aws/connect/model/AssociateLambdaFunctionRequest.h>
27 #include <aws/connect/model/AssociateLexBotRequest.h>
28 #include <aws/connect/model/AssociateQueueQuickConnectsRequest.h>
29 #include <aws/connect/model/AssociateRoutingProfileQueuesRequest.h>
30 #include <aws/connect/model/AssociateSecurityKeyRequest.h>
31 #include <aws/connect/model/CreateAgentStatusRequest.h>
32 #include <aws/connect/model/CreateContactFlowRequest.h>
33 #include <aws/connect/model/CreateHoursOfOperationRequest.h>
34 #include <aws/connect/model/CreateInstanceRequest.h>
35 #include <aws/connect/model/CreateIntegrationAssociationRequest.h>
36 #include <aws/connect/model/CreateQueueRequest.h>
37 #include <aws/connect/model/CreateQuickConnectRequest.h>
38 #include <aws/connect/model/CreateRoutingProfileRequest.h>
39 #include <aws/connect/model/CreateUseCaseRequest.h>
40 #include <aws/connect/model/CreateUserRequest.h>
41 #include <aws/connect/model/CreateUserHierarchyGroupRequest.h>
42 #include <aws/connect/model/DeleteHoursOfOperationRequest.h>
43 #include <aws/connect/model/DeleteInstanceRequest.h>
44 #include <aws/connect/model/DeleteIntegrationAssociationRequest.h>
45 #include <aws/connect/model/DeleteQuickConnectRequest.h>
46 #include <aws/connect/model/DeleteUseCaseRequest.h>
47 #include <aws/connect/model/DeleteUserRequest.h>
48 #include <aws/connect/model/DeleteUserHierarchyGroupRequest.h>
49 #include <aws/connect/model/DescribeAgentStatusRequest.h>
50 #include <aws/connect/model/DescribeContactFlowRequest.h>
51 #include <aws/connect/model/DescribeHoursOfOperationRequest.h>
52 #include <aws/connect/model/DescribeInstanceRequest.h>
53 #include <aws/connect/model/DescribeInstanceAttributeRequest.h>
54 #include <aws/connect/model/DescribeInstanceStorageConfigRequest.h>
55 #include <aws/connect/model/DescribeQueueRequest.h>
56 #include <aws/connect/model/DescribeQuickConnectRequest.h>
57 #include <aws/connect/model/DescribeRoutingProfileRequest.h>
58 #include <aws/connect/model/DescribeUserRequest.h>
59 #include <aws/connect/model/DescribeUserHierarchyGroupRequest.h>
60 #include <aws/connect/model/DescribeUserHierarchyStructureRequest.h>
61 #include <aws/connect/model/DisassociateApprovedOriginRequest.h>
62 #include <aws/connect/model/DisassociateBotRequest.h>
63 #include <aws/connect/model/DisassociateInstanceStorageConfigRequest.h>
64 #include <aws/connect/model/DisassociateLambdaFunctionRequest.h>
65 #include <aws/connect/model/DisassociateLexBotRequest.h>
66 #include <aws/connect/model/DisassociateQueueQuickConnectsRequest.h>
67 #include <aws/connect/model/DisassociateRoutingProfileQueuesRequest.h>
68 #include <aws/connect/model/DisassociateSecurityKeyRequest.h>
69 #include <aws/connect/model/GetContactAttributesRequest.h>
70 #include <aws/connect/model/GetCurrentMetricDataRequest.h>
71 #include <aws/connect/model/GetFederationTokenRequest.h>
72 #include <aws/connect/model/GetMetricDataRequest.h>
73 #include <aws/connect/model/ListAgentStatusesRequest.h>
74 #include <aws/connect/model/ListApprovedOriginsRequest.h>
75 #include <aws/connect/model/ListBotsRequest.h>
76 #include <aws/connect/model/ListContactFlowsRequest.h>
77 #include <aws/connect/model/ListHoursOfOperationsRequest.h>
78 #include <aws/connect/model/ListInstanceAttributesRequest.h>
79 #include <aws/connect/model/ListInstanceStorageConfigsRequest.h>
80 #include <aws/connect/model/ListInstancesRequest.h>
81 #include <aws/connect/model/ListIntegrationAssociationsRequest.h>
82 #include <aws/connect/model/ListLambdaFunctionsRequest.h>
83 #include <aws/connect/model/ListLexBotsRequest.h>
84 #include <aws/connect/model/ListPhoneNumbersRequest.h>
85 #include <aws/connect/model/ListPromptsRequest.h>
86 #include <aws/connect/model/ListQueueQuickConnectsRequest.h>
87 #include <aws/connect/model/ListQueuesRequest.h>
88 #include <aws/connect/model/ListQuickConnectsRequest.h>
89 #include <aws/connect/model/ListRoutingProfileQueuesRequest.h>
90 #include <aws/connect/model/ListRoutingProfilesRequest.h>
91 #include <aws/connect/model/ListSecurityKeysRequest.h>
92 #include <aws/connect/model/ListSecurityProfilesRequest.h>
93 #include <aws/connect/model/ListTagsForResourceRequest.h>
94 #include <aws/connect/model/ListUseCasesRequest.h>
95 #include <aws/connect/model/ListUserHierarchyGroupsRequest.h>
96 #include <aws/connect/model/ListUsersRequest.h>
97 #include <aws/connect/model/ResumeContactRecordingRequest.h>
98 #include <aws/connect/model/StartChatContactRequest.h>
99 #include <aws/connect/model/StartContactRecordingRequest.h>
100 #include <aws/connect/model/StartOutboundVoiceContactRequest.h>
101 #include <aws/connect/model/StartTaskContactRequest.h>
102 #include <aws/connect/model/StopContactRequest.h>
103 #include <aws/connect/model/StopContactRecordingRequest.h>
104 #include <aws/connect/model/SuspendContactRecordingRequest.h>
105 #include <aws/connect/model/TagResourceRequest.h>
106 #include <aws/connect/model/UntagResourceRequest.h>
107 #include <aws/connect/model/UpdateAgentStatusRequest.h>
108 #include <aws/connect/model/UpdateContactAttributesRequest.h>
109 #include <aws/connect/model/UpdateContactFlowContentRequest.h>
110 #include <aws/connect/model/UpdateContactFlowNameRequest.h>
111 #include <aws/connect/model/UpdateHoursOfOperationRequest.h>
112 #include <aws/connect/model/UpdateInstanceAttributeRequest.h>
113 #include <aws/connect/model/UpdateInstanceStorageConfigRequest.h>
114 #include <aws/connect/model/UpdateQueueHoursOfOperationRequest.h>
115 #include <aws/connect/model/UpdateQueueMaxContactsRequest.h>
116 #include <aws/connect/model/UpdateQueueNameRequest.h>
117 #include <aws/connect/model/UpdateQueueOutboundCallerConfigRequest.h>
118 #include <aws/connect/model/UpdateQueueStatusRequest.h>
119 #include <aws/connect/model/UpdateQuickConnectConfigRequest.h>
120 #include <aws/connect/model/UpdateQuickConnectNameRequest.h>
121 #include <aws/connect/model/UpdateRoutingProfileConcurrencyRequest.h>
122 #include <aws/connect/model/UpdateRoutingProfileDefaultOutboundQueueRequest.h>
123 #include <aws/connect/model/UpdateRoutingProfileNameRequest.h>
124 #include <aws/connect/model/UpdateRoutingProfileQueuesRequest.h>
125 #include <aws/connect/model/UpdateUserHierarchyRequest.h>
126 #include <aws/connect/model/UpdateUserHierarchyGroupNameRequest.h>
127 #include <aws/connect/model/UpdateUserHierarchyStructureRequest.h>
128 #include <aws/connect/model/UpdateUserIdentityInfoRequest.h>
129 #include <aws/connect/model/UpdateUserPhoneConfigRequest.h>
130 #include <aws/connect/model/UpdateUserRoutingProfileRequest.h>
131 #include <aws/connect/model/UpdateUserSecurityProfilesRequest.h>
132
133 using namespace Aws;
134 using namespace Aws::Auth;
135 using namespace Aws::Client;
136 using namespace Aws::Connect;
137 using namespace Aws::Connect::Model;
138 using namespace Aws::Http;
139 using namespace Aws::Utils::Json;
140
141 static const char* SERVICE_NAME = "connect";
142 static const char* ALLOCATION_TAG = "ConnectClient";
143
144
ConnectClient(const Client::ClientConfiguration & clientConfiguration)145 ConnectClient::ConnectClient(const Client::ClientConfiguration& clientConfiguration) :
146 BASECLASS(clientConfiguration,
147 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
148 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
149 Aws::MakeShared<ConnectErrorMarshaller>(ALLOCATION_TAG)),
150 m_executor(clientConfiguration.executor)
151 {
152 init(clientConfiguration);
153 }
154
ConnectClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)155 ConnectClient::ConnectClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
156 BASECLASS(clientConfiguration,
157 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
158 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
159 Aws::MakeShared<ConnectErrorMarshaller>(ALLOCATION_TAG)),
160 m_executor(clientConfiguration.executor)
161 {
162 init(clientConfiguration);
163 }
164
ConnectClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)165 ConnectClient::ConnectClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
166 const Client::ClientConfiguration& clientConfiguration) :
167 BASECLASS(clientConfiguration,
168 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
169 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
170 Aws::MakeShared<ConnectErrorMarshaller>(ALLOCATION_TAG)),
171 m_executor(clientConfiguration.executor)
172 {
173 init(clientConfiguration);
174 }
175
~ConnectClient()176 ConnectClient::~ConnectClient()
177 {
178 }
179
init(const Client::ClientConfiguration & config)180 void ConnectClient::init(const Client::ClientConfiguration& config)
181 {
182 SetServiceClientName("Connect");
183 m_configScheme = SchemeMapper::ToString(config.scheme);
184 if (config.endpointOverride.empty())
185 {
186 m_uri = m_configScheme + "://" + ConnectEndpoint::ForRegion(config.region, config.useDualStack);
187 }
188 else
189 {
190 OverrideEndpoint(config.endpointOverride);
191 }
192 }
193
OverrideEndpoint(const Aws::String & endpoint)194 void ConnectClient::OverrideEndpoint(const Aws::String& endpoint)
195 {
196 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
197 {
198 m_uri = endpoint;
199 }
200 else
201 {
202 m_uri = m_configScheme + "://" + endpoint;
203 }
204 }
205
AssociateApprovedOrigin(const AssociateApprovedOriginRequest & request) const206 AssociateApprovedOriginOutcome ConnectClient::AssociateApprovedOrigin(const AssociateApprovedOriginRequest& request) const
207 {
208 if (!request.InstanceIdHasBeenSet())
209 {
210 AWS_LOGSTREAM_ERROR("AssociateApprovedOrigin", "Required field: InstanceId, is not set");
211 return AssociateApprovedOriginOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
212 }
213 Aws::Http::URI uri = m_uri;
214 uri.AddPathSegments("/instance/");
215 uri.AddPathSegment(request.GetInstanceId());
216 uri.AddPathSegments("/approved-origin");
217 return AssociateApprovedOriginOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
218 }
219
AssociateApprovedOriginCallable(const AssociateApprovedOriginRequest & request) const220 AssociateApprovedOriginOutcomeCallable ConnectClient::AssociateApprovedOriginCallable(const AssociateApprovedOriginRequest& request) const
221 {
222 auto task = Aws::MakeShared< std::packaged_task< AssociateApprovedOriginOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateApprovedOrigin(request); } );
223 auto packagedFunction = [task]() { (*task)(); };
224 m_executor->Submit(packagedFunction);
225 return task->get_future();
226 }
227
AssociateApprovedOriginAsync(const AssociateApprovedOriginRequest & request,const AssociateApprovedOriginResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const228 void ConnectClient::AssociateApprovedOriginAsync(const AssociateApprovedOriginRequest& request, const AssociateApprovedOriginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
229 {
230 m_executor->Submit( [this, request, handler, context](){ this->AssociateApprovedOriginAsyncHelper( request, handler, context ); } );
231 }
232
AssociateApprovedOriginAsyncHelper(const AssociateApprovedOriginRequest & request,const AssociateApprovedOriginResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const233 void ConnectClient::AssociateApprovedOriginAsyncHelper(const AssociateApprovedOriginRequest& request, const AssociateApprovedOriginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
234 {
235 handler(this, request, AssociateApprovedOrigin(request), context);
236 }
237
AssociateBot(const AssociateBotRequest & request) const238 AssociateBotOutcome ConnectClient::AssociateBot(const AssociateBotRequest& request) const
239 {
240 if (!request.InstanceIdHasBeenSet())
241 {
242 AWS_LOGSTREAM_ERROR("AssociateBot", "Required field: InstanceId, is not set");
243 return AssociateBotOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
244 }
245 Aws::Http::URI uri = m_uri;
246 uri.AddPathSegments("/instance/");
247 uri.AddPathSegment(request.GetInstanceId());
248 uri.AddPathSegments("/bot");
249 return AssociateBotOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
250 }
251
AssociateBotCallable(const AssociateBotRequest & request) const252 AssociateBotOutcomeCallable ConnectClient::AssociateBotCallable(const AssociateBotRequest& request) const
253 {
254 auto task = Aws::MakeShared< std::packaged_task< AssociateBotOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateBot(request); } );
255 auto packagedFunction = [task]() { (*task)(); };
256 m_executor->Submit(packagedFunction);
257 return task->get_future();
258 }
259
AssociateBotAsync(const AssociateBotRequest & request,const AssociateBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const260 void ConnectClient::AssociateBotAsync(const AssociateBotRequest& request, const AssociateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
261 {
262 m_executor->Submit( [this, request, handler, context](){ this->AssociateBotAsyncHelper( request, handler, context ); } );
263 }
264
AssociateBotAsyncHelper(const AssociateBotRequest & request,const AssociateBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const265 void ConnectClient::AssociateBotAsyncHelper(const AssociateBotRequest& request, const AssociateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
266 {
267 handler(this, request, AssociateBot(request), context);
268 }
269
AssociateInstanceStorageConfig(const AssociateInstanceStorageConfigRequest & request) const270 AssociateInstanceStorageConfigOutcome ConnectClient::AssociateInstanceStorageConfig(const AssociateInstanceStorageConfigRequest& request) const
271 {
272 if (!request.InstanceIdHasBeenSet())
273 {
274 AWS_LOGSTREAM_ERROR("AssociateInstanceStorageConfig", "Required field: InstanceId, is not set");
275 return AssociateInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
276 }
277 Aws::Http::URI uri = m_uri;
278 uri.AddPathSegments("/instance/");
279 uri.AddPathSegment(request.GetInstanceId());
280 uri.AddPathSegments("/storage-config");
281 return AssociateInstanceStorageConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
282 }
283
AssociateInstanceStorageConfigCallable(const AssociateInstanceStorageConfigRequest & request) const284 AssociateInstanceStorageConfigOutcomeCallable ConnectClient::AssociateInstanceStorageConfigCallable(const AssociateInstanceStorageConfigRequest& request) const
285 {
286 auto task = Aws::MakeShared< std::packaged_task< AssociateInstanceStorageConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateInstanceStorageConfig(request); } );
287 auto packagedFunction = [task]() { (*task)(); };
288 m_executor->Submit(packagedFunction);
289 return task->get_future();
290 }
291
AssociateInstanceStorageConfigAsync(const AssociateInstanceStorageConfigRequest & request,const AssociateInstanceStorageConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const292 void ConnectClient::AssociateInstanceStorageConfigAsync(const AssociateInstanceStorageConfigRequest& request, const AssociateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
293 {
294 m_executor->Submit( [this, request, handler, context](){ this->AssociateInstanceStorageConfigAsyncHelper( request, handler, context ); } );
295 }
296
AssociateInstanceStorageConfigAsyncHelper(const AssociateInstanceStorageConfigRequest & request,const AssociateInstanceStorageConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const297 void ConnectClient::AssociateInstanceStorageConfigAsyncHelper(const AssociateInstanceStorageConfigRequest& request, const AssociateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
298 {
299 handler(this, request, AssociateInstanceStorageConfig(request), context);
300 }
301
AssociateLambdaFunction(const AssociateLambdaFunctionRequest & request) const302 AssociateLambdaFunctionOutcome ConnectClient::AssociateLambdaFunction(const AssociateLambdaFunctionRequest& request) const
303 {
304 if (!request.InstanceIdHasBeenSet())
305 {
306 AWS_LOGSTREAM_ERROR("AssociateLambdaFunction", "Required field: InstanceId, is not set");
307 return AssociateLambdaFunctionOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
308 }
309 Aws::Http::URI uri = m_uri;
310 uri.AddPathSegments("/instance/");
311 uri.AddPathSegment(request.GetInstanceId());
312 uri.AddPathSegments("/lambda-function");
313 return AssociateLambdaFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
314 }
315
AssociateLambdaFunctionCallable(const AssociateLambdaFunctionRequest & request) const316 AssociateLambdaFunctionOutcomeCallable ConnectClient::AssociateLambdaFunctionCallable(const AssociateLambdaFunctionRequest& request) const
317 {
318 auto task = Aws::MakeShared< std::packaged_task< AssociateLambdaFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateLambdaFunction(request); } );
319 auto packagedFunction = [task]() { (*task)(); };
320 m_executor->Submit(packagedFunction);
321 return task->get_future();
322 }
323
AssociateLambdaFunctionAsync(const AssociateLambdaFunctionRequest & request,const AssociateLambdaFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const324 void ConnectClient::AssociateLambdaFunctionAsync(const AssociateLambdaFunctionRequest& request, const AssociateLambdaFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
325 {
326 m_executor->Submit( [this, request, handler, context](){ this->AssociateLambdaFunctionAsyncHelper( request, handler, context ); } );
327 }
328
AssociateLambdaFunctionAsyncHelper(const AssociateLambdaFunctionRequest & request,const AssociateLambdaFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const329 void ConnectClient::AssociateLambdaFunctionAsyncHelper(const AssociateLambdaFunctionRequest& request, const AssociateLambdaFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
330 {
331 handler(this, request, AssociateLambdaFunction(request), context);
332 }
333
AssociateLexBot(const AssociateLexBotRequest & request) const334 AssociateLexBotOutcome ConnectClient::AssociateLexBot(const AssociateLexBotRequest& request) const
335 {
336 if (!request.InstanceIdHasBeenSet())
337 {
338 AWS_LOGSTREAM_ERROR("AssociateLexBot", "Required field: InstanceId, is not set");
339 return AssociateLexBotOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
340 }
341 Aws::Http::URI uri = m_uri;
342 uri.AddPathSegments("/instance/");
343 uri.AddPathSegment(request.GetInstanceId());
344 uri.AddPathSegments("/lex-bot");
345 return AssociateLexBotOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
346 }
347
AssociateLexBotCallable(const AssociateLexBotRequest & request) const348 AssociateLexBotOutcomeCallable ConnectClient::AssociateLexBotCallable(const AssociateLexBotRequest& request) const
349 {
350 auto task = Aws::MakeShared< std::packaged_task< AssociateLexBotOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateLexBot(request); } );
351 auto packagedFunction = [task]() { (*task)(); };
352 m_executor->Submit(packagedFunction);
353 return task->get_future();
354 }
355
AssociateLexBotAsync(const AssociateLexBotRequest & request,const AssociateLexBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const356 void ConnectClient::AssociateLexBotAsync(const AssociateLexBotRequest& request, const AssociateLexBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
357 {
358 m_executor->Submit( [this, request, handler, context](){ this->AssociateLexBotAsyncHelper( request, handler, context ); } );
359 }
360
AssociateLexBotAsyncHelper(const AssociateLexBotRequest & request,const AssociateLexBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const361 void ConnectClient::AssociateLexBotAsyncHelper(const AssociateLexBotRequest& request, const AssociateLexBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
362 {
363 handler(this, request, AssociateLexBot(request), context);
364 }
365
AssociateQueueQuickConnects(const AssociateQueueQuickConnectsRequest & request) const366 AssociateQueueQuickConnectsOutcome ConnectClient::AssociateQueueQuickConnects(const AssociateQueueQuickConnectsRequest& request) const
367 {
368 if (!request.InstanceIdHasBeenSet())
369 {
370 AWS_LOGSTREAM_ERROR("AssociateQueueQuickConnects", "Required field: InstanceId, is not set");
371 return AssociateQueueQuickConnectsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
372 }
373 if (!request.QueueIdHasBeenSet())
374 {
375 AWS_LOGSTREAM_ERROR("AssociateQueueQuickConnects", "Required field: QueueId, is not set");
376 return AssociateQueueQuickConnectsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
377 }
378 Aws::Http::URI uri = m_uri;
379 uri.AddPathSegments("/queues/");
380 uri.AddPathSegment(request.GetInstanceId());
381 uri.AddPathSegment(request.GetQueueId());
382 uri.AddPathSegments("/associate-quick-connects");
383 return AssociateQueueQuickConnectsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
384 }
385
AssociateQueueQuickConnectsCallable(const AssociateQueueQuickConnectsRequest & request) const386 AssociateQueueQuickConnectsOutcomeCallable ConnectClient::AssociateQueueQuickConnectsCallable(const AssociateQueueQuickConnectsRequest& request) const
387 {
388 auto task = Aws::MakeShared< std::packaged_task< AssociateQueueQuickConnectsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateQueueQuickConnects(request); } );
389 auto packagedFunction = [task]() { (*task)(); };
390 m_executor->Submit(packagedFunction);
391 return task->get_future();
392 }
393
AssociateQueueQuickConnectsAsync(const AssociateQueueQuickConnectsRequest & request,const AssociateQueueQuickConnectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const394 void ConnectClient::AssociateQueueQuickConnectsAsync(const AssociateQueueQuickConnectsRequest& request, const AssociateQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
395 {
396 m_executor->Submit( [this, request, handler, context](){ this->AssociateQueueQuickConnectsAsyncHelper( request, handler, context ); } );
397 }
398
AssociateQueueQuickConnectsAsyncHelper(const AssociateQueueQuickConnectsRequest & request,const AssociateQueueQuickConnectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const399 void ConnectClient::AssociateQueueQuickConnectsAsyncHelper(const AssociateQueueQuickConnectsRequest& request, const AssociateQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
400 {
401 handler(this, request, AssociateQueueQuickConnects(request), context);
402 }
403
AssociateRoutingProfileQueues(const AssociateRoutingProfileQueuesRequest & request) const404 AssociateRoutingProfileQueuesOutcome ConnectClient::AssociateRoutingProfileQueues(const AssociateRoutingProfileQueuesRequest& request) const
405 {
406 if (!request.InstanceIdHasBeenSet())
407 {
408 AWS_LOGSTREAM_ERROR("AssociateRoutingProfileQueues", "Required field: InstanceId, is not set");
409 return AssociateRoutingProfileQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
410 }
411 if (!request.RoutingProfileIdHasBeenSet())
412 {
413 AWS_LOGSTREAM_ERROR("AssociateRoutingProfileQueues", "Required field: RoutingProfileId, is not set");
414 return AssociateRoutingProfileQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoutingProfileId]", false));
415 }
416 Aws::Http::URI uri = m_uri;
417 uri.AddPathSegments("/routing-profiles/");
418 uri.AddPathSegment(request.GetInstanceId());
419 uri.AddPathSegment(request.GetRoutingProfileId());
420 uri.AddPathSegments("/associate-queues");
421 return AssociateRoutingProfileQueuesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
422 }
423
AssociateRoutingProfileQueuesCallable(const AssociateRoutingProfileQueuesRequest & request) const424 AssociateRoutingProfileQueuesOutcomeCallable ConnectClient::AssociateRoutingProfileQueuesCallable(const AssociateRoutingProfileQueuesRequest& request) const
425 {
426 auto task = Aws::MakeShared< std::packaged_task< AssociateRoutingProfileQueuesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateRoutingProfileQueues(request); } );
427 auto packagedFunction = [task]() { (*task)(); };
428 m_executor->Submit(packagedFunction);
429 return task->get_future();
430 }
431
AssociateRoutingProfileQueuesAsync(const AssociateRoutingProfileQueuesRequest & request,const AssociateRoutingProfileQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const432 void ConnectClient::AssociateRoutingProfileQueuesAsync(const AssociateRoutingProfileQueuesRequest& request, const AssociateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
433 {
434 m_executor->Submit( [this, request, handler, context](){ this->AssociateRoutingProfileQueuesAsyncHelper( request, handler, context ); } );
435 }
436
AssociateRoutingProfileQueuesAsyncHelper(const AssociateRoutingProfileQueuesRequest & request,const AssociateRoutingProfileQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const437 void ConnectClient::AssociateRoutingProfileQueuesAsyncHelper(const AssociateRoutingProfileQueuesRequest& request, const AssociateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
438 {
439 handler(this, request, AssociateRoutingProfileQueues(request), context);
440 }
441
AssociateSecurityKey(const AssociateSecurityKeyRequest & request) const442 AssociateSecurityKeyOutcome ConnectClient::AssociateSecurityKey(const AssociateSecurityKeyRequest& request) const
443 {
444 if (!request.InstanceIdHasBeenSet())
445 {
446 AWS_LOGSTREAM_ERROR("AssociateSecurityKey", "Required field: InstanceId, is not set");
447 return AssociateSecurityKeyOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
448 }
449 Aws::Http::URI uri = m_uri;
450 uri.AddPathSegments("/instance/");
451 uri.AddPathSegment(request.GetInstanceId());
452 uri.AddPathSegments("/security-key");
453 return AssociateSecurityKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
454 }
455
AssociateSecurityKeyCallable(const AssociateSecurityKeyRequest & request) const456 AssociateSecurityKeyOutcomeCallable ConnectClient::AssociateSecurityKeyCallable(const AssociateSecurityKeyRequest& request) const
457 {
458 auto task = Aws::MakeShared< std::packaged_task< AssociateSecurityKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateSecurityKey(request); } );
459 auto packagedFunction = [task]() { (*task)(); };
460 m_executor->Submit(packagedFunction);
461 return task->get_future();
462 }
463
AssociateSecurityKeyAsync(const AssociateSecurityKeyRequest & request,const AssociateSecurityKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const464 void ConnectClient::AssociateSecurityKeyAsync(const AssociateSecurityKeyRequest& request, const AssociateSecurityKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
465 {
466 m_executor->Submit( [this, request, handler, context](){ this->AssociateSecurityKeyAsyncHelper( request, handler, context ); } );
467 }
468
AssociateSecurityKeyAsyncHelper(const AssociateSecurityKeyRequest & request,const AssociateSecurityKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const469 void ConnectClient::AssociateSecurityKeyAsyncHelper(const AssociateSecurityKeyRequest& request, const AssociateSecurityKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
470 {
471 handler(this, request, AssociateSecurityKey(request), context);
472 }
473
CreateAgentStatus(const CreateAgentStatusRequest & request) const474 CreateAgentStatusOutcome ConnectClient::CreateAgentStatus(const CreateAgentStatusRequest& request) const
475 {
476 if (!request.InstanceIdHasBeenSet())
477 {
478 AWS_LOGSTREAM_ERROR("CreateAgentStatus", "Required field: InstanceId, is not set");
479 return CreateAgentStatusOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
480 }
481 Aws::Http::URI uri = m_uri;
482 uri.AddPathSegments("/agent-status/");
483 uri.AddPathSegment(request.GetInstanceId());
484 return CreateAgentStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
485 }
486
CreateAgentStatusCallable(const CreateAgentStatusRequest & request) const487 CreateAgentStatusOutcomeCallable ConnectClient::CreateAgentStatusCallable(const CreateAgentStatusRequest& request) const
488 {
489 auto task = Aws::MakeShared< std::packaged_task< CreateAgentStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAgentStatus(request); } );
490 auto packagedFunction = [task]() { (*task)(); };
491 m_executor->Submit(packagedFunction);
492 return task->get_future();
493 }
494
CreateAgentStatusAsync(const CreateAgentStatusRequest & request,const CreateAgentStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const495 void ConnectClient::CreateAgentStatusAsync(const CreateAgentStatusRequest& request, const CreateAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
496 {
497 m_executor->Submit( [this, request, handler, context](){ this->CreateAgentStatusAsyncHelper( request, handler, context ); } );
498 }
499
CreateAgentStatusAsyncHelper(const CreateAgentStatusRequest & request,const CreateAgentStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const500 void ConnectClient::CreateAgentStatusAsyncHelper(const CreateAgentStatusRequest& request, const CreateAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
501 {
502 handler(this, request, CreateAgentStatus(request), context);
503 }
504
CreateContactFlow(const CreateContactFlowRequest & request) const505 CreateContactFlowOutcome ConnectClient::CreateContactFlow(const CreateContactFlowRequest& request) const
506 {
507 if (!request.InstanceIdHasBeenSet())
508 {
509 AWS_LOGSTREAM_ERROR("CreateContactFlow", "Required field: InstanceId, is not set");
510 return CreateContactFlowOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
511 }
512 Aws::Http::URI uri = m_uri;
513 uri.AddPathSegments("/contact-flows/");
514 uri.AddPathSegment(request.GetInstanceId());
515 return CreateContactFlowOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
516 }
517
CreateContactFlowCallable(const CreateContactFlowRequest & request) const518 CreateContactFlowOutcomeCallable ConnectClient::CreateContactFlowCallable(const CreateContactFlowRequest& request) const
519 {
520 auto task = Aws::MakeShared< std::packaged_task< CreateContactFlowOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateContactFlow(request); } );
521 auto packagedFunction = [task]() { (*task)(); };
522 m_executor->Submit(packagedFunction);
523 return task->get_future();
524 }
525
CreateContactFlowAsync(const CreateContactFlowRequest & request,const CreateContactFlowResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const526 void ConnectClient::CreateContactFlowAsync(const CreateContactFlowRequest& request, const CreateContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
527 {
528 m_executor->Submit( [this, request, handler, context](){ this->CreateContactFlowAsyncHelper( request, handler, context ); } );
529 }
530
CreateContactFlowAsyncHelper(const CreateContactFlowRequest & request,const CreateContactFlowResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const531 void ConnectClient::CreateContactFlowAsyncHelper(const CreateContactFlowRequest& request, const CreateContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
532 {
533 handler(this, request, CreateContactFlow(request), context);
534 }
535
CreateHoursOfOperation(const CreateHoursOfOperationRequest & request) const536 CreateHoursOfOperationOutcome ConnectClient::CreateHoursOfOperation(const CreateHoursOfOperationRequest& request) const
537 {
538 if (!request.InstanceIdHasBeenSet())
539 {
540 AWS_LOGSTREAM_ERROR("CreateHoursOfOperation", "Required field: InstanceId, is not set");
541 return CreateHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
542 }
543 Aws::Http::URI uri = m_uri;
544 uri.AddPathSegments("/hours-of-operations/");
545 uri.AddPathSegment(request.GetInstanceId());
546 return CreateHoursOfOperationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
547 }
548
CreateHoursOfOperationCallable(const CreateHoursOfOperationRequest & request) const549 CreateHoursOfOperationOutcomeCallable ConnectClient::CreateHoursOfOperationCallable(const CreateHoursOfOperationRequest& request) const
550 {
551 auto task = Aws::MakeShared< std::packaged_task< CreateHoursOfOperationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateHoursOfOperation(request); } );
552 auto packagedFunction = [task]() { (*task)(); };
553 m_executor->Submit(packagedFunction);
554 return task->get_future();
555 }
556
CreateHoursOfOperationAsync(const CreateHoursOfOperationRequest & request,const CreateHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const557 void ConnectClient::CreateHoursOfOperationAsync(const CreateHoursOfOperationRequest& request, const CreateHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
558 {
559 m_executor->Submit( [this, request, handler, context](){ this->CreateHoursOfOperationAsyncHelper( request, handler, context ); } );
560 }
561
CreateHoursOfOperationAsyncHelper(const CreateHoursOfOperationRequest & request,const CreateHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const562 void ConnectClient::CreateHoursOfOperationAsyncHelper(const CreateHoursOfOperationRequest& request, const CreateHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
563 {
564 handler(this, request, CreateHoursOfOperation(request), context);
565 }
566
CreateInstance(const CreateInstanceRequest & request) const567 CreateInstanceOutcome ConnectClient::CreateInstance(const CreateInstanceRequest& request) const
568 {
569 Aws::Http::URI uri = m_uri;
570 uri.AddPathSegments("/instance");
571 return CreateInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
572 }
573
CreateInstanceCallable(const CreateInstanceRequest & request) const574 CreateInstanceOutcomeCallable ConnectClient::CreateInstanceCallable(const CreateInstanceRequest& request) const
575 {
576 auto task = Aws::MakeShared< std::packaged_task< CreateInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateInstance(request); } );
577 auto packagedFunction = [task]() { (*task)(); };
578 m_executor->Submit(packagedFunction);
579 return task->get_future();
580 }
581
CreateInstanceAsync(const CreateInstanceRequest & request,const CreateInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const582 void ConnectClient::CreateInstanceAsync(const CreateInstanceRequest& request, const CreateInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
583 {
584 m_executor->Submit( [this, request, handler, context](){ this->CreateInstanceAsyncHelper( request, handler, context ); } );
585 }
586
CreateInstanceAsyncHelper(const CreateInstanceRequest & request,const CreateInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const587 void ConnectClient::CreateInstanceAsyncHelper(const CreateInstanceRequest& request, const CreateInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
588 {
589 handler(this, request, CreateInstance(request), context);
590 }
591
CreateIntegrationAssociation(const CreateIntegrationAssociationRequest & request) const592 CreateIntegrationAssociationOutcome ConnectClient::CreateIntegrationAssociation(const CreateIntegrationAssociationRequest& request) const
593 {
594 if (!request.InstanceIdHasBeenSet())
595 {
596 AWS_LOGSTREAM_ERROR("CreateIntegrationAssociation", "Required field: InstanceId, is not set");
597 return CreateIntegrationAssociationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
598 }
599 Aws::Http::URI uri = m_uri;
600 uri.AddPathSegments("/instance/");
601 uri.AddPathSegment(request.GetInstanceId());
602 uri.AddPathSegments("/integration-associations");
603 return CreateIntegrationAssociationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
604 }
605
CreateIntegrationAssociationCallable(const CreateIntegrationAssociationRequest & request) const606 CreateIntegrationAssociationOutcomeCallable ConnectClient::CreateIntegrationAssociationCallable(const CreateIntegrationAssociationRequest& request) const
607 {
608 auto task = Aws::MakeShared< std::packaged_task< CreateIntegrationAssociationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateIntegrationAssociation(request); } );
609 auto packagedFunction = [task]() { (*task)(); };
610 m_executor->Submit(packagedFunction);
611 return task->get_future();
612 }
613
CreateIntegrationAssociationAsync(const CreateIntegrationAssociationRequest & request,const CreateIntegrationAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const614 void ConnectClient::CreateIntegrationAssociationAsync(const CreateIntegrationAssociationRequest& request, const CreateIntegrationAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
615 {
616 m_executor->Submit( [this, request, handler, context](){ this->CreateIntegrationAssociationAsyncHelper( request, handler, context ); } );
617 }
618
CreateIntegrationAssociationAsyncHelper(const CreateIntegrationAssociationRequest & request,const CreateIntegrationAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const619 void ConnectClient::CreateIntegrationAssociationAsyncHelper(const CreateIntegrationAssociationRequest& request, const CreateIntegrationAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
620 {
621 handler(this, request, CreateIntegrationAssociation(request), context);
622 }
623
CreateQueue(const CreateQueueRequest & request) const624 CreateQueueOutcome ConnectClient::CreateQueue(const CreateQueueRequest& request) const
625 {
626 if (!request.InstanceIdHasBeenSet())
627 {
628 AWS_LOGSTREAM_ERROR("CreateQueue", "Required field: InstanceId, is not set");
629 return CreateQueueOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
630 }
631 Aws::Http::URI uri = m_uri;
632 uri.AddPathSegments("/queues/");
633 uri.AddPathSegment(request.GetInstanceId());
634 return CreateQueueOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
635 }
636
CreateQueueCallable(const CreateQueueRequest & request) const637 CreateQueueOutcomeCallable ConnectClient::CreateQueueCallable(const CreateQueueRequest& request) const
638 {
639 auto task = Aws::MakeShared< std::packaged_task< CreateQueueOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateQueue(request); } );
640 auto packagedFunction = [task]() { (*task)(); };
641 m_executor->Submit(packagedFunction);
642 return task->get_future();
643 }
644
CreateQueueAsync(const CreateQueueRequest & request,const CreateQueueResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const645 void ConnectClient::CreateQueueAsync(const CreateQueueRequest& request, const CreateQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
646 {
647 m_executor->Submit( [this, request, handler, context](){ this->CreateQueueAsyncHelper( request, handler, context ); } );
648 }
649
CreateQueueAsyncHelper(const CreateQueueRequest & request,const CreateQueueResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const650 void ConnectClient::CreateQueueAsyncHelper(const CreateQueueRequest& request, const CreateQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
651 {
652 handler(this, request, CreateQueue(request), context);
653 }
654
CreateQuickConnect(const CreateQuickConnectRequest & request) const655 CreateQuickConnectOutcome ConnectClient::CreateQuickConnect(const CreateQuickConnectRequest& request) const
656 {
657 if (!request.InstanceIdHasBeenSet())
658 {
659 AWS_LOGSTREAM_ERROR("CreateQuickConnect", "Required field: InstanceId, is not set");
660 return CreateQuickConnectOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
661 }
662 Aws::Http::URI uri = m_uri;
663 uri.AddPathSegments("/quick-connects/");
664 uri.AddPathSegment(request.GetInstanceId());
665 return CreateQuickConnectOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
666 }
667
CreateQuickConnectCallable(const CreateQuickConnectRequest & request) const668 CreateQuickConnectOutcomeCallable ConnectClient::CreateQuickConnectCallable(const CreateQuickConnectRequest& request) const
669 {
670 auto task = Aws::MakeShared< std::packaged_task< CreateQuickConnectOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateQuickConnect(request); } );
671 auto packagedFunction = [task]() { (*task)(); };
672 m_executor->Submit(packagedFunction);
673 return task->get_future();
674 }
675
CreateQuickConnectAsync(const CreateQuickConnectRequest & request,const CreateQuickConnectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const676 void ConnectClient::CreateQuickConnectAsync(const CreateQuickConnectRequest& request, const CreateQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
677 {
678 m_executor->Submit( [this, request, handler, context](){ this->CreateQuickConnectAsyncHelper( request, handler, context ); } );
679 }
680
CreateQuickConnectAsyncHelper(const CreateQuickConnectRequest & request,const CreateQuickConnectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const681 void ConnectClient::CreateQuickConnectAsyncHelper(const CreateQuickConnectRequest& request, const CreateQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
682 {
683 handler(this, request, CreateQuickConnect(request), context);
684 }
685
CreateRoutingProfile(const CreateRoutingProfileRequest & request) const686 CreateRoutingProfileOutcome ConnectClient::CreateRoutingProfile(const CreateRoutingProfileRequest& request) const
687 {
688 if (!request.InstanceIdHasBeenSet())
689 {
690 AWS_LOGSTREAM_ERROR("CreateRoutingProfile", "Required field: InstanceId, is not set");
691 return CreateRoutingProfileOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
692 }
693 Aws::Http::URI uri = m_uri;
694 uri.AddPathSegments("/routing-profiles/");
695 uri.AddPathSegment(request.GetInstanceId());
696 return CreateRoutingProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
697 }
698
CreateRoutingProfileCallable(const CreateRoutingProfileRequest & request) const699 CreateRoutingProfileOutcomeCallable ConnectClient::CreateRoutingProfileCallable(const CreateRoutingProfileRequest& request) const
700 {
701 auto task = Aws::MakeShared< std::packaged_task< CreateRoutingProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateRoutingProfile(request); } );
702 auto packagedFunction = [task]() { (*task)(); };
703 m_executor->Submit(packagedFunction);
704 return task->get_future();
705 }
706
CreateRoutingProfileAsync(const CreateRoutingProfileRequest & request,const CreateRoutingProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const707 void ConnectClient::CreateRoutingProfileAsync(const CreateRoutingProfileRequest& request, const CreateRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
708 {
709 m_executor->Submit( [this, request, handler, context](){ this->CreateRoutingProfileAsyncHelper( request, handler, context ); } );
710 }
711
CreateRoutingProfileAsyncHelper(const CreateRoutingProfileRequest & request,const CreateRoutingProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const712 void ConnectClient::CreateRoutingProfileAsyncHelper(const CreateRoutingProfileRequest& request, const CreateRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
713 {
714 handler(this, request, CreateRoutingProfile(request), context);
715 }
716
CreateUseCase(const CreateUseCaseRequest & request) const717 CreateUseCaseOutcome ConnectClient::CreateUseCase(const CreateUseCaseRequest& request) const
718 {
719 if (!request.InstanceIdHasBeenSet())
720 {
721 AWS_LOGSTREAM_ERROR("CreateUseCase", "Required field: InstanceId, is not set");
722 return CreateUseCaseOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
723 }
724 if (!request.IntegrationAssociationIdHasBeenSet())
725 {
726 AWS_LOGSTREAM_ERROR("CreateUseCase", "Required field: IntegrationAssociationId, is not set");
727 return CreateUseCaseOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IntegrationAssociationId]", false));
728 }
729 Aws::Http::URI uri = m_uri;
730 uri.AddPathSegments("/instance/");
731 uri.AddPathSegment(request.GetInstanceId());
732 uri.AddPathSegments("/integration-associations/");
733 uri.AddPathSegment(request.GetIntegrationAssociationId());
734 uri.AddPathSegments("/use-cases");
735 return CreateUseCaseOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
736 }
737
CreateUseCaseCallable(const CreateUseCaseRequest & request) const738 CreateUseCaseOutcomeCallable ConnectClient::CreateUseCaseCallable(const CreateUseCaseRequest& request) const
739 {
740 auto task = Aws::MakeShared< std::packaged_task< CreateUseCaseOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateUseCase(request); } );
741 auto packagedFunction = [task]() { (*task)(); };
742 m_executor->Submit(packagedFunction);
743 return task->get_future();
744 }
745
CreateUseCaseAsync(const CreateUseCaseRequest & request,const CreateUseCaseResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const746 void ConnectClient::CreateUseCaseAsync(const CreateUseCaseRequest& request, const CreateUseCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
747 {
748 m_executor->Submit( [this, request, handler, context](){ this->CreateUseCaseAsyncHelper( request, handler, context ); } );
749 }
750
CreateUseCaseAsyncHelper(const CreateUseCaseRequest & request,const CreateUseCaseResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const751 void ConnectClient::CreateUseCaseAsyncHelper(const CreateUseCaseRequest& request, const CreateUseCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
752 {
753 handler(this, request, CreateUseCase(request), context);
754 }
755
CreateUser(const CreateUserRequest & request) const756 CreateUserOutcome ConnectClient::CreateUser(const CreateUserRequest& request) const
757 {
758 if (!request.InstanceIdHasBeenSet())
759 {
760 AWS_LOGSTREAM_ERROR("CreateUser", "Required field: InstanceId, is not set");
761 return CreateUserOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
762 }
763 Aws::Http::URI uri = m_uri;
764 uri.AddPathSegments("/users/");
765 uri.AddPathSegment(request.GetInstanceId());
766 return CreateUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
767 }
768
CreateUserCallable(const CreateUserRequest & request) const769 CreateUserOutcomeCallable ConnectClient::CreateUserCallable(const CreateUserRequest& request) const
770 {
771 auto task = Aws::MakeShared< std::packaged_task< CreateUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateUser(request); } );
772 auto packagedFunction = [task]() { (*task)(); };
773 m_executor->Submit(packagedFunction);
774 return task->get_future();
775 }
776
CreateUserAsync(const CreateUserRequest & request,const CreateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const777 void ConnectClient::CreateUserAsync(const CreateUserRequest& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
778 {
779 m_executor->Submit( [this, request, handler, context](){ this->CreateUserAsyncHelper( request, handler, context ); } );
780 }
781
CreateUserAsyncHelper(const CreateUserRequest & request,const CreateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const782 void ConnectClient::CreateUserAsyncHelper(const CreateUserRequest& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
783 {
784 handler(this, request, CreateUser(request), context);
785 }
786
CreateUserHierarchyGroup(const CreateUserHierarchyGroupRequest & request) const787 CreateUserHierarchyGroupOutcome ConnectClient::CreateUserHierarchyGroup(const CreateUserHierarchyGroupRequest& request) const
788 {
789 if (!request.InstanceIdHasBeenSet())
790 {
791 AWS_LOGSTREAM_ERROR("CreateUserHierarchyGroup", "Required field: InstanceId, is not set");
792 return CreateUserHierarchyGroupOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
793 }
794 Aws::Http::URI uri = m_uri;
795 uri.AddPathSegments("/user-hierarchy-groups/");
796 uri.AddPathSegment(request.GetInstanceId());
797 return CreateUserHierarchyGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
798 }
799
CreateUserHierarchyGroupCallable(const CreateUserHierarchyGroupRequest & request) const800 CreateUserHierarchyGroupOutcomeCallable ConnectClient::CreateUserHierarchyGroupCallable(const CreateUserHierarchyGroupRequest& request) const
801 {
802 auto task = Aws::MakeShared< std::packaged_task< CreateUserHierarchyGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateUserHierarchyGroup(request); } );
803 auto packagedFunction = [task]() { (*task)(); };
804 m_executor->Submit(packagedFunction);
805 return task->get_future();
806 }
807
CreateUserHierarchyGroupAsync(const CreateUserHierarchyGroupRequest & request,const CreateUserHierarchyGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const808 void ConnectClient::CreateUserHierarchyGroupAsync(const CreateUserHierarchyGroupRequest& request, const CreateUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
809 {
810 m_executor->Submit( [this, request, handler, context](){ this->CreateUserHierarchyGroupAsyncHelper( request, handler, context ); } );
811 }
812
CreateUserHierarchyGroupAsyncHelper(const CreateUserHierarchyGroupRequest & request,const CreateUserHierarchyGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const813 void ConnectClient::CreateUserHierarchyGroupAsyncHelper(const CreateUserHierarchyGroupRequest& request, const CreateUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
814 {
815 handler(this, request, CreateUserHierarchyGroup(request), context);
816 }
817
DeleteHoursOfOperation(const DeleteHoursOfOperationRequest & request) const818 DeleteHoursOfOperationOutcome ConnectClient::DeleteHoursOfOperation(const DeleteHoursOfOperationRequest& request) const
819 {
820 if (!request.InstanceIdHasBeenSet())
821 {
822 AWS_LOGSTREAM_ERROR("DeleteHoursOfOperation", "Required field: InstanceId, is not set");
823 return DeleteHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
824 }
825 if (!request.HoursOfOperationIdHasBeenSet())
826 {
827 AWS_LOGSTREAM_ERROR("DeleteHoursOfOperation", "Required field: HoursOfOperationId, is not set");
828 return DeleteHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [HoursOfOperationId]", false));
829 }
830 Aws::Http::URI uri = m_uri;
831 uri.AddPathSegments("/hours-of-operations/");
832 uri.AddPathSegment(request.GetInstanceId());
833 uri.AddPathSegment(request.GetHoursOfOperationId());
834 return DeleteHoursOfOperationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
835 }
836
DeleteHoursOfOperationCallable(const DeleteHoursOfOperationRequest & request) const837 DeleteHoursOfOperationOutcomeCallable ConnectClient::DeleteHoursOfOperationCallable(const DeleteHoursOfOperationRequest& request) const
838 {
839 auto task = Aws::MakeShared< std::packaged_task< DeleteHoursOfOperationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteHoursOfOperation(request); } );
840 auto packagedFunction = [task]() { (*task)(); };
841 m_executor->Submit(packagedFunction);
842 return task->get_future();
843 }
844
DeleteHoursOfOperationAsync(const DeleteHoursOfOperationRequest & request,const DeleteHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const845 void ConnectClient::DeleteHoursOfOperationAsync(const DeleteHoursOfOperationRequest& request, const DeleteHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
846 {
847 m_executor->Submit( [this, request, handler, context](){ this->DeleteHoursOfOperationAsyncHelper( request, handler, context ); } );
848 }
849
DeleteHoursOfOperationAsyncHelper(const DeleteHoursOfOperationRequest & request,const DeleteHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const850 void ConnectClient::DeleteHoursOfOperationAsyncHelper(const DeleteHoursOfOperationRequest& request, const DeleteHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
851 {
852 handler(this, request, DeleteHoursOfOperation(request), context);
853 }
854
DeleteInstance(const DeleteInstanceRequest & request) const855 DeleteInstanceOutcome ConnectClient::DeleteInstance(const DeleteInstanceRequest& request) const
856 {
857 if (!request.InstanceIdHasBeenSet())
858 {
859 AWS_LOGSTREAM_ERROR("DeleteInstance", "Required field: InstanceId, is not set");
860 return DeleteInstanceOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
861 }
862 Aws::Http::URI uri = m_uri;
863 uri.AddPathSegments("/instance/");
864 uri.AddPathSegment(request.GetInstanceId());
865 return DeleteInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
866 }
867
DeleteInstanceCallable(const DeleteInstanceRequest & request) const868 DeleteInstanceOutcomeCallable ConnectClient::DeleteInstanceCallable(const DeleteInstanceRequest& request) const
869 {
870 auto task = Aws::MakeShared< std::packaged_task< DeleteInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteInstance(request); } );
871 auto packagedFunction = [task]() { (*task)(); };
872 m_executor->Submit(packagedFunction);
873 return task->get_future();
874 }
875
DeleteInstanceAsync(const DeleteInstanceRequest & request,const DeleteInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const876 void ConnectClient::DeleteInstanceAsync(const DeleteInstanceRequest& request, const DeleteInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
877 {
878 m_executor->Submit( [this, request, handler, context](){ this->DeleteInstanceAsyncHelper( request, handler, context ); } );
879 }
880
DeleteInstanceAsyncHelper(const DeleteInstanceRequest & request,const DeleteInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const881 void ConnectClient::DeleteInstanceAsyncHelper(const DeleteInstanceRequest& request, const DeleteInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
882 {
883 handler(this, request, DeleteInstance(request), context);
884 }
885
DeleteIntegrationAssociation(const DeleteIntegrationAssociationRequest & request) const886 DeleteIntegrationAssociationOutcome ConnectClient::DeleteIntegrationAssociation(const DeleteIntegrationAssociationRequest& request) const
887 {
888 if (!request.InstanceIdHasBeenSet())
889 {
890 AWS_LOGSTREAM_ERROR("DeleteIntegrationAssociation", "Required field: InstanceId, is not set");
891 return DeleteIntegrationAssociationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
892 }
893 if (!request.IntegrationAssociationIdHasBeenSet())
894 {
895 AWS_LOGSTREAM_ERROR("DeleteIntegrationAssociation", "Required field: IntegrationAssociationId, is not set");
896 return DeleteIntegrationAssociationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IntegrationAssociationId]", false));
897 }
898 Aws::Http::URI uri = m_uri;
899 uri.AddPathSegments("/instance/");
900 uri.AddPathSegment(request.GetInstanceId());
901 uri.AddPathSegments("/integration-associations/");
902 uri.AddPathSegment(request.GetIntegrationAssociationId());
903 return DeleteIntegrationAssociationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
904 }
905
DeleteIntegrationAssociationCallable(const DeleteIntegrationAssociationRequest & request) const906 DeleteIntegrationAssociationOutcomeCallable ConnectClient::DeleteIntegrationAssociationCallable(const DeleteIntegrationAssociationRequest& request) const
907 {
908 auto task = Aws::MakeShared< std::packaged_task< DeleteIntegrationAssociationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteIntegrationAssociation(request); } );
909 auto packagedFunction = [task]() { (*task)(); };
910 m_executor->Submit(packagedFunction);
911 return task->get_future();
912 }
913
DeleteIntegrationAssociationAsync(const DeleteIntegrationAssociationRequest & request,const DeleteIntegrationAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const914 void ConnectClient::DeleteIntegrationAssociationAsync(const DeleteIntegrationAssociationRequest& request, const DeleteIntegrationAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
915 {
916 m_executor->Submit( [this, request, handler, context](){ this->DeleteIntegrationAssociationAsyncHelper( request, handler, context ); } );
917 }
918
DeleteIntegrationAssociationAsyncHelper(const DeleteIntegrationAssociationRequest & request,const DeleteIntegrationAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const919 void ConnectClient::DeleteIntegrationAssociationAsyncHelper(const DeleteIntegrationAssociationRequest& request, const DeleteIntegrationAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
920 {
921 handler(this, request, DeleteIntegrationAssociation(request), context);
922 }
923
DeleteQuickConnect(const DeleteQuickConnectRequest & request) const924 DeleteQuickConnectOutcome ConnectClient::DeleteQuickConnect(const DeleteQuickConnectRequest& request) const
925 {
926 if (!request.InstanceIdHasBeenSet())
927 {
928 AWS_LOGSTREAM_ERROR("DeleteQuickConnect", "Required field: InstanceId, is not set");
929 return DeleteQuickConnectOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
930 }
931 if (!request.QuickConnectIdHasBeenSet())
932 {
933 AWS_LOGSTREAM_ERROR("DeleteQuickConnect", "Required field: QuickConnectId, is not set");
934 return DeleteQuickConnectOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QuickConnectId]", false));
935 }
936 Aws::Http::URI uri = m_uri;
937 uri.AddPathSegments("/quick-connects/");
938 uri.AddPathSegment(request.GetInstanceId());
939 uri.AddPathSegment(request.GetQuickConnectId());
940 return DeleteQuickConnectOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
941 }
942
DeleteQuickConnectCallable(const DeleteQuickConnectRequest & request) const943 DeleteQuickConnectOutcomeCallable ConnectClient::DeleteQuickConnectCallable(const DeleteQuickConnectRequest& request) const
944 {
945 auto task = Aws::MakeShared< std::packaged_task< DeleteQuickConnectOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteQuickConnect(request); } );
946 auto packagedFunction = [task]() { (*task)(); };
947 m_executor->Submit(packagedFunction);
948 return task->get_future();
949 }
950
DeleteQuickConnectAsync(const DeleteQuickConnectRequest & request,const DeleteQuickConnectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const951 void ConnectClient::DeleteQuickConnectAsync(const DeleteQuickConnectRequest& request, const DeleteQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
952 {
953 m_executor->Submit( [this, request, handler, context](){ this->DeleteQuickConnectAsyncHelper( request, handler, context ); } );
954 }
955
DeleteQuickConnectAsyncHelper(const DeleteQuickConnectRequest & request,const DeleteQuickConnectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const956 void ConnectClient::DeleteQuickConnectAsyncHelper(const DeleteQuickConnectRequest& request, const DeleteQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
957 {
958 handler(this, request, DeleteQuickConnect(request), context);
959 }
960
DeleteUseCase(const DeleteUseCaseRequest & request) const961 DeleteUseCaseOutcome ConnectClient::DeleteUseCase(const DeleteUseCaseRequest& request) const
962 {
963 if (!request.InstanceIdHasBeenSet())
964 {
965 AWS_LOGSTREAM_ERROR("DeleteUseCase", "Required field: InstanceId, is not set");
966 return DeleteUseCaseOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
967 }
968 if (!request.IntegrationAssociationIdHasBeenSet())
969 {
970 AWS_LOGSTREAM_ERROR("DeleteUseCase", "Required field: IntegrationAssociationId, is not set");
971 return DeleteUseCaseOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IntegrationAssociationId]", false));
972 }
973 if (!request.UseCaseIdHasBeenSet())
974 {
975 AWS_LOGSTREAM_ERROR("DeleteUseCase", "Required field: UseCaseId, is not set");
976 return DeleteUseCaseOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UseCaseId]", false));
977 }
978 Aws::Http::URI uri = m_uri;
979 uri.AddPathSegments("/instance/");
980 uri.AddPathSegment(request.GetInstanceId());
981 uri.AddPathSegments("/integration-associations/");
982 uri.AddPathSegment(request.GetIntegrationAssociationId());
983 uri.AddPathSegments("/use-cases/");
984 uri.AddPathSegment(request.GetUseCaseId());
985 return DeleteUseCaseOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
986 }
987
DeleteUseCaseCallable(const DeleteUseCaseRequest & request) const988 DeleteUseCaseOutcomeCallable ConnectClient::DeleteUseCaseCallable(const DeleteUseCaseRequest& request) const
989 {
990 auto task = Aws::MakeShared< std::packaged_task< DeleteUseCaseOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteUseCase(request); } );
991 auto packagedFunction = [task]() { (*task)(); };
992 m_executor->Submit(packagedFunction);
993 return task->get_future();
994 }
995
DeleteUseCaseAsync(const DeleteUseCaseRequest & request,const DeleteUseCaseResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const996 void ConnectClient::DeleteUseCaseAsync(const DeleteUseCaseRequest& request, const DeleteUseCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
997 {
998 m_executor->Submit( [this, request, handler, context](){ this->DeleteUseCaseAsyncHelper( request, handler, context ); } );
999 }
1000
DeleteUseCaseAsyncHelper(const DeleteUseCaseRequest & request,const DeleteUseCaseResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1001 void ConnectClient::DeleteUseCaseAsyncHelper(const DeleteUseCaseRequest& request, const DeleteUseCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1002 {
1003 handler(this, request, DeleteUseCase(request), context);
1004 }
1005
DeleteUser(const DeleteUserRequest & request) const1006 DeleteUserOutcome ConnectClient::DeleteUser(const DeleteUserRequest& request) const
1007 {
1008 if (!request.InstanceIdHasBeenSet())
1009 {
1010 AWS_LOGSTREAM_ERROR("DeleteUser", "Required field: InstanceId, is not set");
1011 return DeleteUserOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1012 }
1013 if (!request.UserIdHasBeenSet())
1014 {
1015 AWS_LOGSTREAM_ERROR("DeleteUser", "Required field: UserId, is not set");
1016 return DeleteUserOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
1017 }
1018 Aws::Http::URI uri = m_uri;
1019 uri.AddPathSegments("/users/");
1020 uri.AddPathSegment(request.GetInstanceId());
1021 uri.AddPathSegment(request.GetUserId());
1022 return DeleteUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1023 }
1024
DeleteUserCallable(const DeleteUserRequest & request) const1025 DeleteUserOutcomeCallable ConnectClient::DeleteUserCallable(const DeleteUserRequest& request) const
1026 {
1027 auto task = Aws::MakeShared< std::packaged_task< DeleteUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteUser(request); } );
1028 auto packagedFunction = [task]() { (*task)(); };
1029 m_executor->Submit(packagedFunction);
1030 return task->get_future();
1031 }
1032
DeleteUserAsync(const DeleteUserRequest & request,const DeleteUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1033 void ConnectClient::DeleteUserAsync(const DeleteUserRequest& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1034 {
1035 m_executor->Submit( [this, request, handler, context](){ this->DeleteUserAsyncHelper( request, handler, context ); } );
1036 }
1037
DeleteUserAsyncHelper(const DeleteUserRequest & request,const DeleteUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1038 void ConnectClient::DeleteUserAsyncHelper(const DeleteUserRequest& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1039 {
1040 handler(this, request, DeleteUser(request), context);
1041 }
1042
DeleteUserHierarchyGroup(const DeleteUserHierarchyGroupRequest & request) const1043 DeleteUserHierarchyGroupOutcome ConnectClient::DeleteUserHierarchyGroup(const DeleteUserHierarchyGroupRequest& request) const
1044 {
1045 if (!request.HierarchyGroupIdHasBeenSet())
1046 {
1047 AWS_LOGSTREAM_ERROR("DeleteUserHierarchyGroup", "Required field: HierarchyGroupId, is not set");
1048 return DeleteUserHierarchyGroupOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [HierarchyGroupId]", false));
1049 }
1050 if (!request.InstanceIdHasBeenSet())
1051 {
1052 AWS_LOGSTREAM_ERROR("DeleteUserHierarchyGroup", "Required field: InstanceId, is not set");
1053 return DeleteUserHierarchyGroupOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1054 }
1055 Aws::Http::URI uri = m_uri;
1056 uri.AddPathSegments("/user-hierarchy-groups/");
1057 uri.AddPathSegment(request.GetInstanceId());
1058 uri.AddPathSegment(request.GetHierarchyGroupId());
1059 return DeleteUserHierarchyGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1060 }
1061
DeleteUserHierarchyGroupCallable(const DeleteUserHierarchyGroupRequest & request) const1062 DeleteUserHierarchyGroupOutcomeCallable ConnectClient::DeleteUserHierarchyGroupCallable(const DeleteUserHierarchyGroupRequest& request) const
1063 {
1064 auto task = Aws::MakeShared< std::packaged_task< DeleteUserHierarchyGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteUserHierarchyGroup(request); } );
1065 auto packagedFunction = [task]() { (*task)(); };
1066 m_executor->Submit(packagedFunction);
1067 return task->get_future();
1068 }
1069
DeleteUserHierarchyGroupAsync(const DeleteUserHierarchyGroupRequest & request,const DeleteUserHierarchyGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1070 void ConnectClient::DeleteUserHierarchyGroupAsync(const DeleteUserHierarchyGroupRequest& request, const DeleteUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1071 {
1072 m_executor->Submit( [this, request, handler, context](){ this->DeleteUserHierarchyGroupAsyncHelper( request, handler, context ); } );
1073 }
1074
DeleteUserHierarchyGroupAsyncHelper(const DeleteUserHierarchyGroupRequest & request,const DeleteUserHierarchyGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1075 void ConnectClient::DeleteUserHierarchyGroupAsyncHelper(const DeleteUserHierarchyGroupRequest& request, const DeleteUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1076 {
1077 handler(this, request, DeleteUserHierarchyGroup(request), context);
1078 }
1079
DescribeAgentStatus(const DescribeAgentStatusRequest & request) const1080 DescribeAgentStatusOutcome ConnectClient::DescribeAgentStatus(const DescribeAgentStatusRequest& request) const
1081 {
1082 if (!request.InstanceIdHasBeenSet())
1083 {
1084 AWS_LOGSTREAM_ERROR("DescribeAgentStatus", "Required field: InstanceId, is not set");
1085 return DescribeAgentStatusOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1086 }
1087 if (!request.AgentStatusIdHasBeenSet())
1088 {
1089 AWS_LOGSTREAM_ERROR("DescribeAgentStatus", "Required field: AgentStatusId, is not set");
1090 return DescribeAgentStatusOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AgentStatusId]", false));
1091 }
1092 Aws::Http::URI uri = m_uri;
1093 uri.AddPathSegments("/agent-status/");
1094 uri.AddPathSegment(request.GetInstanceId());
1095 uri.AddPathSegment(request.GetAgentStatusId());
1096 return DescribeAgentStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1097 }
1098
DescribeAgentStatusCallable(const DescribeAgentStatusRequest & request) const1099 DescribeAgentStatusOutcomeCallable ConnectClient::DescribeAgentStatusCallable(const DescribeAgentStatusRequest& request) const
1100 {
1101 auto task = Aws::MakeShared< std::packaged_task< DescribeAgentStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeAgentStatus(request); } );
1102 auto packagedFunction = [task]() { (*task)(); };
1103 m_executor->Submit(packagedFunction);
1104 return task->get_future();
1105 }
1106
DescribeAgentStatusAsync(const DescribeAgentStatusRequest & request,const DescribeAgentStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1107 void ConnectClient::DescribeAgentStatusAsync(const DescribeAgentStatusRequest& request, const DescribeAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1108 {
1109 m_executor->Submit( [this, request, handler, context](){ this->DescribeAgentStatusAsyncHelper( request, handler, context ); } );
1110 }
1111
DescribeAgentStatusAsyncHelper(const DescribeAgentStatusRequest & request,const DescribeAgentStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1112 void ConnectClient::DescribeAgentStatusAsyncHelper(const DescribeAgentStatusRequest& request, const DescribeAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1113 {
1114 handler(this, request, DescribeAgentStatus(request), context);
1115 }
1116
DescribeContactFlow(const DescribeContactFlowRequest & request) const1117 DescribeContactFlowOutcome ConnectClient::DescribeContactFlow(const DescribeContactFlowRequest& request) const
1118 {
1119 if (!request.InstanceIdHasBeenSet())
1120 {
1121 AWS_LOGSTREAM_ERROR("DescribeContactFlow", "Required field: InstanceId, is not set");
1122 return DescribeContactFlowOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1123 }
1124 if (!request.ContactFlowIdHasBeenSet())
1125 {
1126 AWS_LOGSTREAM_ERROR("DescribeContactFlow", "Required field: ContactFlowId, is not set");
1127 return DescribeContactFlowOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ContactFlowId]", false));
1128 }
1129 Aws::Http::URI uri = m_uri;
1130 uri.AddPathSegments("/contact-flows/");
1131 uri.AddPathSegment(request.GetInstanceId());
1132 uri.AddPathSegment(request.GetContactFlowId());
1133 return DescribeContactFlowOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1134 }
1135
DescribeContactFlowCallable(const DescribeContactFlowRequest & request) const1136 DescribeContactFlowOutcomeCallable ConnectClient::DescribeContactFlowCallable(const DescribeContactFlowRequest& request) const
1137 {
1138 auto task = Aws::MakeShared< std::packaged_task< DescribeContactFlowOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeContactFlow(request); } );
1139 auto packagedFunction = [task]() { (*task)(); };
1140 m_executor->Submit(packagedFunction);
1141 return task->get_future();
1142 }
1143
DescribeContactFlowAsync(const DescribeContactFlowRequest & request,const DescribeContactFlowResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1144 void ConnectClient::DescribeContactFlowAsync(const DescribeContactFlowRequest& request, const DescribeContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1145 {
1146 m_executor->Submit( [this, request, handler, context](){ this->DescribeContactFlowAsyncHelper( request, handler, context ); } );
1147 }
1148
DescribeContactFlowAsyncHelper(const DescribeContactFlowRequest & request,const DescribeContactFlowResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1149 void ConnectClient::DescribeContactFlowAsyncHelper(const DescribeContactFlowRequest& request, const DescribeContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1150 {
1151 handler(this, request, DescribeContactFlow(request), context);
1152 }
1153
DescribeHoursOfOperation(const DescribeHoursOfOperationRequest & request) const1154 DescribeHoursOfOperationOutcome ConnectClient::DescribeHoursOfOperation(const DescribeHoursOfOperationRequest& request) const
1155 {
1156 if (!request.InstanceIdHasBeenSet())
1157 {
1158 AWS_LOGSTREAM_ERROR("DescribeHoursOfOperation", "Required field: InstanceId, is not set");
1159 return DescribeHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1160 }
1161 if (!request.HoursOfOperationIdHasBeenSet())
1162 {
1163 AWS_LOGSTREAM_ERROR("DescribeHoursOfOperation", "Required field: HoursOfOperationId, is not set");
1164 return DescribeHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [HoursOfOperationId]", false));
1165 }
1166 Aws::Http::URI uri = m_uri;
1167 uri.AddPathSegments("/hours-of-operations/");
1168 uri.AddPathSegment(request.GetInstanceId());
1169 uri.AddPathSegment(request.GetHoursOfOperationId());
1170 return DescribeHoursOfOperationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1171 }
1172
DescribeHoursOfOperationCallable(const DescribeHoursOfOperationRequest & request) const1173 DescribeHoursOfOperationOutcomeCallable ConnectClient::DescribeHoursOfOperationCallable(const DescribeHoursOfOperationRequest& request) const
1174 {
1175 auto task = Aws::MakeShared< std::packaged_task< DescribeHoursOfOperationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeHoursOfOperation(request); } );
1176 auto packagedFunction = [task]() { (*task)(); };
1177 m_executor->Submit(packagedFunction);
1178 return task->get_future();
1179 }
1180
DescribeHoursOfOperationAsync(const DescribeHoursOfOperationRequest & request,const DescribeHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1181 void ConnectClient::DescribeHoursOfOperationAsync(const DescribeHoursOfOperationRequest& request, const DescribeHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1182 {
1183 m_executor->Submit( [this, request, handler, context](){ this->DescribeHoursOfOperationAsyncHelper( request, handler, context ); } );
1184 }
1185
DescribeHoursOfOperationAsyncHelper(const DescribeHoursOfOperationRequest & request,const DescribeHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1186 void ConnectClient::DescribeHoursOfOperationAsyncHelper(const DescribeHoursOfOperationRequest& request, const DescribeHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1187 {
1188 handler(this, request, DescribeHoursOfOperation(request), context);
1189 }
1190
DescribeInstance(const DescribeInstanceRequest & request) const1191 DescribeInstanceOutcome ConnectClient::DescribeInstance(const DescribeInstanceRequest& request) const
1192 {
1193 if (!request.InstanceIdHasBeenSet())
1194 {
1195 AWS_LOGSTREAM_ERROR("DescribeInstance", "Required field: InstanceId, is not set");
1196 return DescribeInstanceOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1197 }
1198 Aws::Http::URI uri = m_uri;
1199 uri.AddPathSegments("/instance/");
1200 uri.AddPathSegment(request.GetInstanceId());
1201 return DescribeInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1202 }
1203
DescribeInstanceCallable(const DescribeInstanceRequest & request) const1204 DescribeInstanceOutcomeCallable ConnectClient::DescribeInstanceCallable(const DescribeInstanceRequest& request) const
1205 {
1206 auto task = Aws::MakeShared< std::packaged_task< DescribeInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeInstance(request); } );
1207 auto packagedFunction = [task]() { (*task)(); };
1208 m_executor->Submit(packagedFunction);
1209 return task->get_future();
1210 }
1211
DescribeInstanceAsync(const DescribeInstanceRequest & request,const DescribeInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1212 void ConnectClient::DescribeInstanceAsync(const DescribeInstanceRequest& request, const DescribeInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1213 {
1214 m_executor->Submit( [this, request, handler, context](){ this->DescribeInstanceAsyncHelper( request, handler, context ); } );
1215 }
1216
DescribeInstanceAsyncHelper(const DescribeInstanceRequest & request,const DescribeInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1217 void ConnectClient::DescribeInstanceAsyncHelper(const DescribeInstanceRequest& request, const DescribeInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1218 {
1219 handler(this, request, DescribeInstance(request), context);
1220 }
1221
DescribeInstanceAttribute(const DescribeInstanceAttributeRequest & request) const1222 DescribeInstanceAttributeOutcome ConnectClient::DescribeInstanceAttribute(const DescribeInstanceAttributeRequest& request) const
1223 {
1224 if (!request.InstanceIdHasBeenSet())
1225 {
1226 AWS_LOGSTREAM_ERROR("DescribeInstanceAttribute", "Required field: InstanceId, is not set");
1227 return DescribeInstanceAttributeOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1228 }
1229 if (!request.AttributeTypeHasBeenSet())
1230 {
1231 AWS_LOGSTREAM_ERROR("DescribeInstanceAttribute", "Required field: AttributeType, is not set");
1232 return DescribeInstanceAttributeOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AttributeType]", false));
1233 }
1234 Aws::Http::URI uri = m_uri;
1235 uri.AddPathSegments("/instance/");
1236 uri.AddPathSegment(request.GetInstanceId());
1237 uri.AddPathSegments("/attribute/");
1238 uri.AddPathSegment(InstanceAttributeTypeMapper::GetNameForInstanceAttributeType(request.GetAttributeType()));
1239 return DescribeInstanceAttributeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1240 }
1241
DescribeInstanceAttributeCallable(const DescribeInstanceAttributeRequest & request) const1242 DescribeInstanceAttributeOutcomeCallable ConnectClient::DescribeInstanceAttributeCallable(const DescribeInstanceAttributeRequest& request) const
1243 {
1244 auto task = Aws::MakeShared< std::packaged_task< DescribeInstanceAttributeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeInstanceAttribute(request); } );
1245 auto packagedFunction = [task]() { (*task)(); };
1246 m_executor->Submit(packagedFunction);
1247 return task->get_future();
1248 }
1249
DescribeInstanceAttributeAsync(const DescribeInstanceAttributeRequest & request,const DescribeInstanceAttributeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1250 void ConnectClient::DescribeInstanceAttributeAsync(const DescribeInstanceAttributeRequest& request, const DescribeInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1251 {
1252 m_executor->Submit( [this, request, handler, context](){ this->DescribeInstanceAttributeAsyncHelper( request, handler, context ); } );
1253 }
1254
DescribeInstanceAttributeAsyncHelper(const DescribeInstanceAttributeRequest & request,const DescribeInstanceAttributeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1255 void ConnectClient::DescribeInstanceAttributeAsyncHelper(const DescribeInstanceAttributeRequest& request, const DescribeInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1256 {
1257 handler(this, request, DescribeInstanceAttribute(request), context);
1258 }
1259
DescribeInstanceStorageConfig(const DescribeInstanceStorageConfigRequest & request) const1260 DescribeInstanceStorageConfigOutcome ConnectClient::DescribeInstanceStorageConfig(const DescribeInstanceStorageConfigRequest& request) const
1261 {
1262 if (!request.InstanceIdHasBeenSet())
1263 {
1264 AWS_LOGSTREAM_ERROR("DescribeInstanceStorageConfig", "Required field: InstanceId, is not set");
1265 return DescribeInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1266 }
1267 if (!request.AssociationIdHasBeenSet())
1268 {
1269 AWS_LOGSTREAM_ERROR("DescribeInstanceStorageConfig", "Required field: AssociationId, is not set");
1270 return DescribeInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AssociationId]", false));
1271 }
1272 if (!request.ResourceTypeHasBeenSet())
1273 {
1274 AWS_LOGSTREAM_ERROR("DescribeInstanceStorageConfig", "Required field: ResourceType, is not set");
1275 return DescribeInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceType]", false));
1276 }
1277 Aws::Http::URI uri = m_uri;
1278 uri.AddPathSegments("/instance/");
1279 uri.AddPathSegment(request.GetInstanceId());
1280 uri.AddPathSegments("/storage-config/");
1281 uri.AddPathSegment(request.GetAssociationId());
1282 return DescribeInstanceStorageConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1283 }
1284
DescribeInstanceStorageConfigCallable(const DescribeInstanceStorageConfigRequest & request) const1285 DescribeInstanceStorageConfigOutcomeCallable ConnectClient::DescribeInstanceStorageConfigCallable(const DescribeInstanceStorageConfigRequest& request) const
1286 {
1287 auto task = Aws::MakeShared< std::packaged_task< DescribeInstanceStorageConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeInstanceStorageConfig(request); } );
1288 auto packagedFunction = [task]() { (*task)(); };
1289 m_executor->Submit(packagedFunction);
1290 return task->get_future();
1291 }
1292
DescribeInstanceStorageConfigAsync(const DescribeInstanceStorageConfigRequest & request,const DescribeInstanceStorageConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1293 void ConnectClient::DescribeInstanceStorageConfigAsync(const DescribeInstanceStorageConfigRequest& request, const DescribeInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1294 {
1295 m_executor->Submit( [this, request, handler, context](){ this->DescribeInstanceStorageConfigAsyncHelper( request, handler, context ); } );
1296 }
1297
DescribeInstanceStorageConfigAsyncHelper(const DescribeInstanceStorageConfigRequest & request,const DescribeInstanceStorageConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1298 void ConnectClient::DescribeInstanceStorageConfigAsyncHelper(const DescribeInstanceStorageConfigRequest& request, const DescribeInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1299 {
1300 handler(this, request, DescribeInstanceStorageConfig(request), context);
1301 }
1302
DescribeQueue(const DescribeQueueRequest & request) const1303 DescribeQueueOutcome ConnectClient::DescribeQueue(const DescribeQueueRequest& request) const
1304 {
1305 if (!request.InstanceIdHasBeenSet())
1306 {
1307 AWS_LOGSTREAM_ERROR("DescribeQueue", "Required field: InstanceId, is not set");
1308 return DescribeQueueOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1309 }
1310 if (!request.QueueIdHasBeenSet())
1311 {
1312 AWS_LOGSTREAM_ERROR("DescribeQueue", "Required field: QueueId, is not set");
1313 return DescribeQueueOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
1314 }
1315 Aws::Http::URI uri = m_uri;
1316 uri.AddPathSegments("/queues/");
1317 uri.AddPathSegment(request.GetInstanceId());
1318 uri.AddPathSegment(request.GetQueueId());
1319 return DescribeQueueOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1320 }
1321
DescribeQueueCallable(const DescribeQueueRequest & request) const1322 DescribeQueueOutcomeCallable ConnectClient::DescribeQueueCallable(const DescribeQueueRequest& request) const
1323 {
1324 auto task = Aws::MakeShared< std::packaged_task< DescribeQueueOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeQueue(request); } );
1325 auto packagedFunction = [task]() { (*task)(); };
1326 m_executor->Submit(packagedFunction);
1327 return task->get_future();
1328 }
1329
DescribeQueueAsync(const DescribeQueueRequest & request,const DescribeQueueResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1330 void ConnectClient::DescribeQueueAsync(const DescribeQueueRequest& request, const DescribeQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1331 {
1332 m_executor->Submit( [this, request, handler, context](){ this->DescribeQueueAsyncHelper( request, handler, context ); } );
1333 }
1334
DescribeQueueAsyncHelper(const DescribeQueueRequest & request,const DescribeQueueResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1335 void ConnectClient::DescribeQueueAsyncHelper(const DescribeQueueRequest& request, const DescribeQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1336 {
1337 handler(this, request, DescribeQueue(request), context);
1338 }
1339
DescribeQuickConnect(const DescribeQuickConnectRequest & request) const1340 DescribeQuickConnectOutcome ConnectClient::DescribeQuickConnect(const DescribeQuickConnectRequest& request) const
1341 {
1342 if (!request.InstanceIdHasBeenSet())
1343 {
1344 AWS_LOGSTREAM_ERROR("DescribeQuickConnect", "Required field: InstanceId, is not set");
1345 return DescribeQuickConnectOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1346 }
1347 if (!request.QuickConnectIdHasBeenSet())
1348 {
1349 AWS_LOGSTREAM_ERROR("DescribeQuickConnect", "Required field: QuickConnectId, is not set");
1350 return DescribeQuickConnectOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QuickConnectId]", false));
1351 }
1352 Aws::Http::URI uri = m_uri;
1353 uri.AddPathSegments("/quick-connects/");
1354 uri.AddPathSegment(request.GetInstanceId());
1355 uri.AddPathSegment(request.GetQuickConnectId());
1356 return DescribeQuickConnectOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1357 }
1358
DescribeQuickConnectCallable(const DescribeQuickConnectRequest & request) const1359 DescribeQuickConnectOutcomeCallable ConnectClient::DescribeQuickConnectCallable(const DescribeQuickConnectRequest& request) const
1360 {
1361 auto task = Aws::MakeShared< std::packaged_task< DescribeQuickConnectOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeQuickConnect(request); } );
1362 auto packagedFunction = [task]() { (*task)(); };
1363 m_executor->Submit(packagedFunction);
1364 return task->get_future();
1365 }
1366
DescribeQuickConnectAsync(const DescribeQuickConnectRequest & request,const DescribeQuickConnectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1367 void ConnectClient::DescribeQuickConnectAsync(const DescribeQuickConnectRequest& request, const DescribeQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1368 {
1369 m_executor->Submit( [this, request, handler, context](){ this->DescribeQuickConnectAsyncHelper( request, handler, context ); } );
1370 }
1371
DescribeQuickConnectAsyncHelper(const DescribeQuickConnectRequest & request,const DescribeQuickConnectResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1372 void ConnectClient::DescribeQuickConnectAsyncHelper(const DescribeQuickConnectRequest& request, const DescribeQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1373 {
1374 handler(this, request, DescribeQuickConnect(request), context);
1375 }
1376
DescribeRoutingProfile(const DescribeRoutingProfileRequest & request) const1377 DescribeRoutingProfileOutcome ConnectClient::DescribeRoutingProfile(const DescribeRoutingProfileRequest& request) const
1378 {
1379 if (!request.InstanceIdHasBeenSet())
1380 {
1381 AWS_LOGSTREAM_ERROR("DescribeRoutingProfile", "Required field: InstanceId, is not set");
1382 return DescribeRoutingProfileOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1383 }
1384 if (!request.RoutingProfileIdHasBeenSet())
1385 {
1386 AWS_LOGSTREAM_ERROR("DescribeRoutingProfile", "Required field: RoutingProfileId, is not set");
1387 return DescribeRoutingProfileOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoutingProfileId]", false));
1388 }
1389 Aws::Http::URI uri = m_uri;
1390 uri.AddPathSegments("/routing-profiles/");
1391 uri.AddPathSegment(request.GetInstanceId());
1392 uri.AddPathSegment(request.GetRoutingProfileId());
1393 return DescribeRoutingProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1394 }
1395
DescribeRoutingProfileCallable(const DescribeRoutingProfileRequest & request) const1396 DescribeRoutingProfileOutcomeCallable ConnectClient::DescribeRoutingProfileCallable(const DescribeRoutingProfileRequest& request) const
1397 {
1398 auto task = Aws::MakeShared< std::packaged_task< DescribeRoutingProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeRoutingProfile(request); } );
1399 auto packagedFunction = [task]() { (*task)(); };
1400 m_executor->Submit(packagedFunction);
1401 return task->get_future();
1402 }
1403
DescribeRoutingProfileAsync(const DescribeRoutingProfileRequest & request,const DescribeRoutingProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1404 void ConnectClient::DescribeRoutingProfileAsync(const DescribeRoutingProfileRequest& request, const DescribeRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1405 {
1406 m_executor->Submit( [this, request, handler, context](){ this->DescribeRoutingProfileAsyncHelper( request, handler, context ); } );
1407 }
1408
DescribeRoutingProfileAsyncHelper(const DescribeRoutingProfileRequest & request,const DescribeRoutingProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1409 void ConnectClient::DescribeRoutingProfileAsyncHelper(const DescribeRoutingProfileRequest& request, const DescribeRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1410 {
1411 handler(this, request, DescribeRoutingProfile(request), context);
1412 }
1413
DescribeUser(const DescribeUserRequest & request) const1414 DescribeUserOutcome ConnectClient::DescribeUser(const DescribeUserRequest& request) const
1415 {
1416 if (!request.UserIdHasBeenSet())
1417 {
1418 AWS_LOGSTREAM_ERROR("DescribeUser", "Required field: UserId, is not set");
1419 return DescribeUserOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
1420 }
1421 if (!request.InstanceIdHasBeenSet())
1422 {
1423 AWS_LOGSTREAM_ERROR("DescribeUser", "Required field: InstanceId, is not set");
1424 return DescribeUserOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1425 }
1426 Aws::Http::URI uri = m_uri;
1427 uri.AddPathSegments("/users/");
1428 uri.AddPathSegment(request.GetInstanceId());
1429 uri.AddPathSegment(request.GetUserId());
1430 return DescribeUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1431 }
1432
DescribeUserCallable(const DescribeUserRequest & request) const1433 DescribeUserOutcomeCallable ConnectClient::DescribeUserCallable(const DescribeUserRequest& request) const
1434 {
1435 auto task = Aws::MakeShared< std::packaged_task< DescribeUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeUser(request); } );
1436 auto packagedFunction = [task]() { (*task)(); };
1437 m_executor->Submit(packagedFunction);
1438 return task->get_future();
1439 }
1440
DescribeUserAsync(const DescribeUserRequest & request,const DescribeUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1441 void ConnectClient::DescribeUserAsync(const DescribeUserRequest& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1442 {
1443 m_executor->Submit( [this, request, handler, context](){ this->DescribeUserAsyncHelper( request, handler, context ); } );
1444 }
1445
DescribeUserAsyncHelper(const DescribeUserRequest & request,const DescribeUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1446 void ConnectClient::DescribeUserAsyncHelper(const DescribeUserRequest& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1447 {
1448 handler(this, request, DescribeUser(request), context);
1449 }
1450
DescribeUserHierarchyGroup(const DescribeUserHierarchyGroupRequest & request) const1451 DescribeUserHierarchyGroupOutcome ConnectClient::DescribeUserHierarchyGroup(const DescribeUserHierarchyGroupRequest& request) const
1452 {
1453 if (!request.HierarchyGroupIdHasBeenSet())
1454 {
1455 AWS_LOGSTREAM_ERROR("DescribeUserHierarchyGroup", "Required field: HierarchyGroupId, is not set");
1456 return DescribeUserHierarchyGroupOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [HierarchyGroupId]", false));
1457 }
1458 if (!request.InstanceIdHasBeenSet())
1459 {
1460 AWS_LOGSTREAM_ERROR("DescribeUserHierarchyGroup", "Required field: InstanceId, is not set");
1461 return DescribeUserHierarchyGroupOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1462 }
1463 Aws::Http::URI uri = m_uri;
1464 uri.AddPathSegments("/user-hierarchy-groups/");
1465 uri.AddPathSegment(request.GetInstanceId());
1466 uri.AddPathSegment(request.GetHierarchyGroupId());
1467 return DescribeUserHierarchyGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1468 }
1469
DescribeUserHierarchyGroupCallable(const DescribeUserHierarchyGroupRequest & request) const1470 DescribeUserHierarchyGroupOutcomeCallable ConnectClient::DescribeUserHierarchyGroupCallable(const DescribeUserHierarchyGroupRequest& request) const
1471 {
1472 auto task = Aws::MakeShared< std::packaged_task< DescribeUserHierarchyGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeUserHierarchyGroup(request); } );
1473 auto packagedFunction = [task]() { (*task)(); };
1474 m_executor->Submit(packagedFunction);
1475 return task->get_future();
1476 }
1477
DescribeUserHierarchyGroupAsync(const DescribeUserHierarchyGroupRequest & request,const DescribeUserHierarchyGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1478 void ConnectClient::DescribeUserHierarchyGroupAsync(const DescribeUserHierarchyGroupRequest& request, const DescribeUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1479 {
1480 m_executor->Submit( [this, request, handler, context](){ this->DescribeUserHierarchyGroupAsyncHelper( request, handler, context ); } );
1481 }
1482
DescribeUserHierarchyGroupAsyncHelper(const DescribeUserHierarchyGroupRequest & request,const DescribeUserHierarchyGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1483 void ConnectClient::DescribeUserHierarchyGroupAsyncHelper(const DescribeUserHierarchyGroupRequest& request, const DescribeUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1484 {
1485 handler(this, request, DescribeUserHierarchyGroup(request), context);
1486 }
1487
DescribeUserHierarchyStructure(const DescribeUserHierarchyStructureRequest & request) const1488 DescribeUserHierarchyStructureOutcome ConnectClient::DescribeUserHierarchyStructure(const DescribeUserHierarchyStructureRequest& request) const
1489 {
1490 if (!request.InstanceIdHasBeenSet())
1491 {
1492 AWS_LOGSTREAM_ERROR("DescribeUserHierarchyStructure", "Required field: InstanceId, is not set");
1493 return DescribeUserHierarchyStructureOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1494 }
1495 Aws::Http::URI uri = m_uri;
1496 uri.AddPathSegments("/user-hierarchy-structure/");
1497 uri.AddPathSegment(request.GetInstanceId());
1498 return DescribeUserHierarchyStructureOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1499 }
1500
DescribeUserHierarchyStructureCallable(const DescribeUserHierarchyStructureRequest & request) const1501 DescribeUserHierarchyStructureOutcomeCallable ConnectClient::DescribeUserHierarchyStructureCallable(const DescribeUserHierarchyStructureRequest& request) const
1502 {
1503 auto task = Aws::MakeShared< std::packaged_task< DescribeUserHierarchyStructureOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeUserHierarchyStructure(request); } );
1504 auto packagedFunction = [task]() { (*task)(); };
1505 m_executor->Submit(packagedFunction);
1506 return task->get_future();
1507 }
1508
DescribeUserHierarchyStructureAsync(const DescribeUserHierarchyStructureRequest & request,const DescribeUserHierarchyStructureResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1509 void ConnectClient::DescribeUserHierarchyStructureAsync(const DescribeUserHierarchyStructureRequest& request, const DescribeUserHierarchyStructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1510 {
1511 m_executor->Submit( [this, request, handler, context](){ this->DescribeUserHierarchyStructureAsyncHelper( request, handler, context ); } );
1512 }
1513
DescribeUserHierarchyStructureAsyncHelper(const DescribeUserHierarchyStructureRequest & request,const DescribeUserHierarchyStructureResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1514 void ConnectClient::DescribeUserHierarchyStructureAsyncHelper(const DescribeUserHierarchyStructureRequest& request, const DescribeUserHierarchyStructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1515 {
1516 handler(this, request, DescribeUserHierarchyStructure(request), context);
1517 }
1518
DisassociateApprovedOrigin(const DisassociateApprovedOriginRequest & request) const1519 DisassociateApprovedOriginOutcome ConnectClient::DisassociateApprovedOrigin(const DisassociateApprovedOriginRequest& request) const
1520 {
1521 if (!request.InstanceIdHasBeenSet())
1522 {
1523 AWS_LOGSTREAM_ERROR("DisassociateApprovedOrigin", "Required field: InstanceId, is not set");
1524 return DisassociateApprovedOriginOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1525 }
1526 if (!request.OriginHasBeenSet())
1527 {
1528 AWS_LOGSTREAM_ERROR("DisassociateApprovedOrigin", "Required field: Origin, is not set");
1529 return DisassociateApprovedOriginOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Origin]", false));
1530 }
1531 Aws::Http::URI uri = m_uri;
1532 uri.AddPathSegments("/instance/");
1533 uri.AddPathSegment(request.GetInstanceId());
1534 uri.AddPathSegments("/approved-origin");
1535 return DisassociateApprovedOriginOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1536 }
1537
DisassociateApprovedOriginCallable(const DisassociateApprovedOriginRequest & request) const1538 DisassociateApprovedOriginOutcomeCallable ConnectClient::DisassociateApprovedOriginCallable(const DisassociateApprovedOriginRequest& request) const
1539 {
1540 auto task = Aws::MakeShared< std::packaged_task< DisassociateApprovedOriginOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateApprovedOrigin(request); } );
1541 auto packagedFunction = [task]() { (*task)(); };
1542 m_executor->Submit(packagedFunction);
1543 return task->get_future();
1544 }
1545
DisassociateApprovedOriginAsync(const DisassociateApprovedOriginRequest & request,const DisassociateApprovedOriginResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1546 void ConnectClient::DisassociateApprovedOriginAsync(const DisassociateApprovedOriginRequest& request, const DisassociateApprovedOriginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1547 {
1548 m_executor->Submit( [this, request, handler, context](){ this->DisassociateApprovedOriginAsyncHelper( request, handler, context ); } );
1549 }
1550
DisassociateApprovedOriginAsyncHelper(const DisassociateApprovedOriginRequest & request,const DisassociateApprovedOriginResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1551 void ConnectClient::DisassociateApprovedOriginAsyncHelper(const DisassociateApprovedOriginRequest& request, const DisassociateApprovedOriginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1552 {
1553 handler(this, request, DisassociateApprovedOrigin(request), context);
1554 }
1555
DisassociateBot(const DisassociateBotRequest & request) const1556 DisassociateBotOutcome ConnectClient::DisassociateBot(const DisassociateBotRequest& request) const
1557 {
1558 if (!request.InstanceIdHasBeenSet())
1559 {
1560 AWS_LOGSTREAM_ERROR("DisassociateBot", "Required field: InstanceId, is not set");
1561 return DisassociateBotOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1562 }
1563 Aws::Http::URI uri = m_uri;
1564 uri.AddPathSegments("/instance/");
1565 uri.AddPathSegment(request.GetInstanceId());
1566 uri.AddPathSegments("/bot");
1567 return DisassociateBotOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1568 }
1569
DisassociateBotCallable(const DisassociateBotRequest & request) const1570 DisassociateBotOutcomeCallable ConnectClient::DisassociateBotCallable(const DisassociateBotRequest& request) const
1571 {
1572 auto task = Aws::MakeShared< std::packaged_task< DisassociateBotOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateBot(request); } );
1573 auto packagedFunction = [task]() { (*task)(); };
1574 m_executor->Submit(packagedFunction);
1575 return task->get_future();
1576 }
1577
DisassociateBotAsync(const DisassociateBotRequest & request,const DisassociateBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1578 void ConnectClient::DisassociateBotAsync(const DisassociateBotRequest& request, const DisassociateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1579 {
1580 m_executor->Submit( [this, request, handler, context](){ this->DisassociateBotAsyncHelper( request, handler, context ); } );
1581 }
1582
DisassociateBotAsyncHelper(const DisassociateBotRequest & request,const DisassociateBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1583 void ConnectClient::DisassociateBotAsyncHelper(const DisassociateBotRequest& request, const DisassociateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1584 {
1585 handler(this, request, DisassociateBot(request), context);
1586 }
1587
DisassociateInstanceStorageConfig(const DisassociateInstanceStorageConfigRequest & request) const1588 DisassociateInstanceStorageConfigOutcome ConnectClient::DisassociateInstanceStorageConfig(const DisassociateInstanceStorageConfigRequest& request) const
1589 {
1590 if (!request.InstanceIdHasBeenSet())
1591 {
1592 AWS_LOGSTREAM_ERROR("DisassociateInstanceStorageConfig", "Required field: InstanceId, is not set");
1593 return DisassociateInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1594 }
1595 if (!request.AssociationIdHasBeenSet())
1596 {
1597 AWS_LOGSTREAM_ERROR("DisassociateInstanceStorageConfig", "Required field: AssociationId, is not set");
1598 return DisassociateInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AssociationId]", false));
1599 }
1600 if (!request.ResourceTypeHasBeenSet())
1601 {
1602 AWS_LOGSTREAM_ERROR("DisassociateInstanceStorageConfig", "Required field: ResourceType, is not set");
1603 return DisassociateInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceType]", false));
1604 }
1605 Aws::Http::URI uri = m_uri;
1606 uri.AddPathSegments("/instance/");
1607 uri.AddPathSegment(request.GetInstanceId());
1608 uri.AddPathSegments("/storage-config/");
1609 uri.AddPathSegment(request.GetAssociationId());
1610 return DisassociateInstanceStorageConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1611 }
1612
DisassociateInstanceStorageConfigCallable(const DisassociateInstanceStorageConfigRequest & request) const1613 DisassociateInstanceStorageConfigOutcomeCallable ConnectClient::DisassociateInstanceStorageConfigCallable(const DisassociateInstanceStorageConfigRequest& request) const
1614 {
1615 auto task = Aws::MakeShared< std::packaged_task< DisassociateInstanceStorageConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateInstanceStorageConfig(request); } );
1616 auto packagedFunction = [task]() { (*task)(); };
1617 m_executor->Submit(packagedFunction);
1618 return task->get_future();
1619 }
1620
DisassociateInstanceStorageConfigAsync(const DisassociateInstanceStorageConfigRequest & request,const DisassociateInstanceStorageConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1621 void ConnectClient::DisassociateInstanceStorageConfigAsync(const DisassociateInstanceStorageConfigRequest& request, const DisassociateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1622 {
1623 m_executor->Submit( [this, request, handler, context](){ this->DisassociateInstanceStorageConfigAsyncHelper( request, handler, context ); } );
1624 }
1625
DisassociateInstanceStorageConfigAsyncHelper(const DisassociateInstanceStorageConfigRequest & request,const DisassociateInstanceStorageConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1626 void ConnectClient::DisassociateInstanceStorageConfigAsyncHelper(const DisassociateInstanceStorageConfigRequest& request, const DisassociateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1627 {
1628 handler(this, request, DisassociateInstanceStorageConfig(request), context);
1629 }
1630
DisassociateLambdaFunction(const DisassociateLambdaFunctionRequest & request) const1631 DisassociateLambdaFunctionOutcome ConnectClient::DisassociateLambdaFunction(const DisassociateLambdaFunctionRequest& request) const
1632 {
1633 if (!request.InstanceIdHasBeenSet())
1634 {
1635 AWS_LOGSTREAM_ERROR("DisassociateLambdaFunction", "Required field: InstanceId, is not set");
1636 return DisassociateLambdaFunctionOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1637 }
1638 if (!request.FunctionArnHasBeenSet())
1639 {
1640 AWS_LOGSTREAM_ERROR("DisassociateLambdaFunction", "Required field: FunctionArn, is not set");
1641 return DisassociateLambdaFunctionOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionArn]", false));
1642 }
1643 Aws::Http::URI uri = m_uri;
1644 uri.AddPathSegments("/instance/");
1645 uri.AddPathSegment(request.GetInstanceId());
1646 uri.AddPathSegments("/lambda-function");
1647 return DisassociateLambdaFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1648 }
1649
DisassociateLambdaFunctionCallable(const DisassociateLambdaFunctionRequest & request) const1650 DisassociateLambdaFunctionOutcomeCallable ConnectClient::DisassociateLambdaFunctionCallable(const DisassociateLambdaFunctionRequest& request) const
1651 {
1652 auto task = Aws::MakeShared< std::packaged_task< DisassociateLambdaFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateLambdaFunction(request); } );
1653 auto packagedFunction = [task]() { (*task)(); };
1654 m_executor->Submit(packagedFunction);
1655 return task->get_future();
1656 }
1657
DisassociateLambdaFunctionAsync(const DisassociateLambdaFunctionRequest & request,const DisassociateLambdaFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1658 void ConnectClient::DisassociateLambdaFunctionAsync(const DisassociateLambdaFunctionRequest& request, const DisassociateLambdaFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1659 {
1660 m_executor->Submit( [this, request, handler, context](){ this->DisassociateLambdaFunctionAsyncHelper( request, handler, context ); } );
1661 }
1662
DisassociateLambdaFunctionAsyncHelper(const DisassociateLambdaFunctionRequest & request,const DisassociateLambdaFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1663 void ConnectClient::DisassociateLambdaFunctionAsyncHelper(const DisassociateLambdaFunctionRequest& request, const DisassociateLambdaFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1664 {
1665 handler(this, request, DisassociateLambdaFunction(request), context);
1666 }
1667
DisassociateLexBot(const DisassociateLexBotRequest & request) const1668 DisassociateLexBotOutcome ConnectClient::DisassociateLexBot(const DisassociateLexBotRequest& request) const
1669 {
1670 if (!request.InstanceIdHasBeenSet())
1671 {
1672 AWS_LOGSTREAM_ERROR("DisassociateLexBot", "Required field: InstanceId, is not set");
1673 return DisassociateLexBotOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1674 }
1675 if (!request.BotNameHasBeenSet())
1676 {
1677 AWS_LOGSTREAM_ERROR("DisassociateLexBot", "Required field: BotName, is not set");
1678 return DisassociateLexBotOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [BotName]", false));
1679 }
1680 if (!request.LexRegionHasBeenSet())
1681 {
1682 AWS_LOGSTREAM_ERROR("DisassociateLexBot", "Required field: LexRegion, is not set");
1683 return DisassociateLexBotOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LexRegion]", false));
1684 }
1685 Aws::Http::URI uri = m_uri;
1686 uri.AddPathSegments("/instance/");
1687 uri.AddPathSegment(request.GetInstanceId());
1688 uri.AddPathSegments("/lex-bot");
1689 return DisassociateLexBotOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1690 }
1691
DisassociateLexBotCallable(const DisassociateLexBotRequest & request) const1692 DisassociateLexBotOutcomeCallable ConnectClient::DisassociateLexBotCallable(const DisassociateLexBotRequest& request) const
1693 {
1694 auto task = Aws::MakeShared< std::packaged_task< DisassociateLexBotOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateLexBot(request); } );
1695 auto packagedFunction = [task]() { (*task)(); };
1696 m_executor->Submit(packagedFunction);
1697 return task->get_future();
1698 }
1699
DisassociateLexBotAsync(const DisassociateLexBotRequest & request,const DisassociateLexBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1700 void ConnectClient::DisassociateLexBotAsync(const DisassociateLexBotRequest& request, const DisassociateLexBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1701 {
1702 m_executor->Submit( [this, request, handler, context](){ this->DisassociateLexBotAsyncHelper( request, handler, context ); } );
1703 }
1704
DisassociateLexBotAsyncHelper(const DisassociateLexBotRequest & request,const DisassociateLexBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1705 void ConnectClient::DisassociateLexBotAsyncHelper(const DisassociateLexBotRequest& request, const DisassociateLexBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1706 {
1707 handler(this, request, DisassociateLexBot(request), context);
1708 }
1709
DisassociateQueueQuickConnects(const DisassociateQueueQuickConnectsRequest & request) const1710 DisassociateQueueQuickConnectsOutcome ConnectClient::DisassociateQueueQuickConnects(const DisassociateQueueQuickConnectsRequest& request) const
1711 {
1712 if (!request.InstanceIdHasBeenSet())
1713 {
1714 AWS_LOGSTREAM_ERROR("DisassociateQueueQuickConnects", "Required field: InstanceId, is not set");
1715 return DisassociateQueueQuickConnectsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1716 }
1717 if (!request.QueueIdHasBeenSet())
1718 {
1719 AWS_LOGSTREAM_ERROR("DisassociateQueueQuickConnects", "Required field: QueueId, is not set");
1720 return DisassociateQueueQuickConnectsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
1721 }
1722 Aws::Http::URI uri = m_uri;
1723 uri.AddPathSegments("/queues/");
1724 uri.AddPathSegment(request.GetInstanceId());
1725 uri.AddPathSegment(request.GetQueueId());
1726 uri.AddPathSegments("/disassociate-quick-connects");
1727 return DisassociateQueueQuickConnectsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1728 }
1729
DisassociateQueueQuickConnectsCallable(const DisassociateQueueQuickConnectsRequest & request) const1730 DisassociateQueueQuickConnectsOutcomeCallable ConnectClient::DisassociateQueueQuickConnectsCallable(const DisassociateQueueQuickConnectsRequest& request) const
1731 {
1732 auto task = Aws::MakeShared< std::packaged_task< DisassociateQueueQuickConnectsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateQueueQuickConnects(request); } );
1733 auto packagedFunction = [task]() { (*task)(); };
1734 m_executor->Submit(packagedFunction);
1735 return task->get_future();
1736 }
1737
DisassociateQueueQuickConnectsAsync(const DisassociateQueueQuickConnectsRequest & request,const DisassociateQueueQuickConnectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1738 void ConnectClient::DisassociateQueueQuickConnectsAsync(const DisassociateQueueQuickConnectsRequest& request, const DisassociateQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1739 {
1740 m_executor->Submit( [this, request, handler, context](){ this->DisassociateQueueQuickConnectsAsyncHelper( request, handler, context ); } );
1741 }
1742
DisassociateQueueQuickConnectsAsyncHelper(const DisassociateQueueQuickConnectsRequest & request,const DisassociateQueueQuickConnectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1743 void ConnectClient::DisassociateQueueQuickConnectsAsyncHelper(const DisassociateQueueQuickConnectsRequest& request, const DisassociateQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1744 {
1745 handler(this, request, DisassociateQueueQuickConnects(request), context);
1746 }
1747
DisassociateRoutingProfileQueues(const DisassociateRoutingProfileQueuesRequest & request) const1748 DisassociateRoutingProfileQueuesOutcome ConnectClient::DisassociateRoutingProfileQueues(const DisassociateRoutingProfileQueuesRequest& request) const
1749 {
1750 if (!request.InstanceIdHasBeenSet())
1751 {
1752 AWS_LOGSTREAM_ERROR("DisassociateRoutingProfileQueues", "Required field: InstanceId, is not set");
1753 return DisassociateRoutingProfileQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1754 }
1755 if (!request.RoutingProfileIdHasBeenSet())
1756 {
1757 AWS_LOGSTREAM_ERROR("DisassociateRoutingProfileQueues", "Required field: RoutingProfileId, is not set");
1758 return DisassociateRoutingProfileQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoutingProfileId]", false));
1759 }
1760 Aws::Http::URI uri = m_uri;
1761 uri.AddPathSegments("/routing-profiles/");
1762 uri.AddPathSegment(request.GetInstanceId());
1763 uri.AddPathSegment(request.GetRoutingProfileId());
1764 uri.AddPathSegments("/disassociate-queues");
1765 return DisassociateRoutingProfileQueuesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1766 }
1767
DisassociateRoutingProfileQueuesCallable(const DisassociateRoutingProfileQueuesRequest & request) const1768 DisassociateRoutingProfileQueuesOutcomeCallable ConnectClient::DisassociateRoutingProfileQueuesCallable(const DisassociateRoutingProfileQueuesRequest& request) const
1769 {
1770 auto task = Aws::MakeShared< std::packaged_task< DisassociateRoutingProfileQueuesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateRoutingProfileQueues(request); } );
1771 auto packagedFunction = [task]() { (*task)(); };
1772 m_executor->Submit(packagedFunction);
1773 return task->get_future();
1774 }
1775
DisassociateRoutingProfileQueuesAsync(const DisassociateRoutingProfileQueuesRequest & request,const DisassociateRoutingProfileQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1776 void ConnectClient::DisassociateRoutingProfileQueuesAsync(const DisassociateRoutingProfileQueuesRequest& request, const DisassociateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1777 {
1778 m_executor->Submit( [this, request, handler, context](){ this->DisassociateRoutingProfileQueuesAsyncHelper( request, handler, context ); } );
1779 }
1780
DisassociateRoutingProfileQueuesAsyncHelper(const DisassociateRoutingProfileQueuesRequest & request,const DisassociateRoutingProfileQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1781 void ConnectClient::DisassociateRoutingProfileQueuesAsyncHelper(const DisassociateRoutingProfileQueuesRequest& request, const DisassociateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1782 {
1783 handler(this, request, DisassociateRoutingProfileQueues(request), context);
1784 }
1785
DisassociateSecurityKey(const DisassociateSecurityKeyRequest & request) const1786 DisassociateSecurityKeyOutcome ConnectClient::DisassociateSecurityKey(const DisassociateSecurityKeyRequest& request) const
1787 {
1788 if (!request.InstanceIdHasBeenSet())
1789 {
1790 AWS_LOGSTREAM_ERROR("DisassociateSecurityKey", "Required field: InstanceId, is not set");
1791 return DisassociateSecurityKeyOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1792 }
1793 if (!request.AssociationIdHasBeenSet())
1794 {
1795 AWS_LOGSTREAM_ERROR("DisassociateSecurityKey", "Required field: AssociationId, is not set");
1796 return DisassociateSecurityKeyOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AssociationId]", false));
1797 }
1798 Aws::Http::URI uri = m_uri;
1799 uri.AddPathSegments("/instance/");
1800 uri.AddPathSegment(request.GetInstanceId());
1801 uri.AddPathSegments("/security-key/");
1802 uri.AddPathSegment(request.GetAssociationId());
1803 return DisassociateSecurityKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1804 }
1805
DisassociateSecurityKeyCallable(const DisassociateSecurityKeyRequest & request) const1806 DisassociateSecurityKeyOutcomeCallable ConnectClient::DisassociateSecurityKeyCallable(const DisassociateSecurityKeyRequest& request) const
1807 {
1808 auto task = Aws::MakeShared< std::packaged_task< DisassociateSecurityKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateSecurityKey(request); } );
1809 auto packagedFunction = [task]() { (*task)(); };
1810 m_executor->Submit(packagedFunction);
1811 return task->get_future();
1812 }
1813
DisassociateSecurityKeyAsync(const DisassociateSecurityKeyRequest & request,const DisassociateSecurityKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1814 void ConnectClient::DisassociateSecurityKeyAsync(const DisassociateSecurityKeyRequest& request, const DisassociateSecurityKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1815 {
1816 m_executor->Submit( [this, request, handler, context](){ this->DisassociateSecurityKeyAsyncHelper( request, handler, context ); } );
1817 }
1818
DisassociateSecurityKeyAsyncHelper(const DisassociateSecurityKeyRequest & request,const DisassociateSecurityKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1819 void ConnectClient::DisassociateSecurityKeyAsyncHelper(const DisassociateSecurityKeyRequest& request, const DisassociateSecurityKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1820 {
1821 handler(this, request, DisassociateSecurityKey(request), context);
1822 }
1823
GetContactAttributes(const GetContactAttributesRequest & request) const1824 GetContactAttributesOutcome ConnectClient::GetContactAttributes(const GetContactAttributesRequest& request) const
1825 {
1826 if (!request.InstanceIdHasBeenSet())
1827 {
1828 AWS_LOGSTREAM_ERROR("GetContactAttributes", "Required field: InstanceId, is not set");
1829 return GetContactAttributesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1830 }
1831 if (!request.InitialContactIdHasBeenSet())
1832 {
1833 AWS_LOGSTREAM_ERROR("GetContactAttributes", "Required field: InitialContactId, is not set");
1834 return GetContactAttributesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InitialContactId]", false));
1835 }
1836 Aws::Http::URI uri = m_uri;
1837 uri.AddPathSegments("/contact/attributes/");
1838 uri.AddPathSegment(request.GetInstanceId());
1839 uri.AddPathSegment(request.GetInitialContactId());
1840 return GetContactAttributesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1841 }
1842
GetContactAttributesCallable(const GetContactAttributesRequest & request) const1843 GetContactAttributesOutcomeCallable ConnectClient::GetContactAttributesCallable(const GetContactAttributesRequest& request) const
1844 {
1845 auto task = Aws::MakeShared< std::packaged_task< GetContactAttributesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetContactAttributes(request); } );
1846 auto packagedFunction = [task]() { (*task)(); };
1847 m_executor->Submit(packagedFunction);
1848 return task->get_future();
1849 }
1850
GetContactAttributesAsync(const GetContactAttributesRequest & request,const GetContactAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1851 void ConnectClient::GetContactAttributesAsync(const GetContactAttributesRequest& request, const GetContactAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1852 {
1853 m_executor->Submit( [this, request, handler, context](){ this->GetContactAttributesAsyncHelper( request, handler, context ); } );
1854 }
1855
GetContactAttributesAsyncHelper(const GetContactAttributesRequest & request,const GetContactAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1856 void ConnectClient::GetContactAttributesAsyncHelper(const GetContactAttributesRequest& request, const GetContactAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1857 {
1858 handler(this, request, GetContactAttributes(request), context);
1859 }
1860
GetCurrentMetricData(const GetCurrentMetricDataRequest & request) const1861 GetCurrentMetricDataOutcome ConnectClient::GetCurrentMetricData(const GetCurrentMetricDataRequest& request) const
1862 {
1863 if (!request.InstanceIdHasBeenSet())
1864 {
1865 AWS_LOGSTREAM_ERROR("GetCurrentMetricData", "Required field: InstanceId, is not set");
1866 return GetCurrentMetricDataOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1867 }
1868 Aws::Http::URI uri = m_uri;
1869 uri.AddPathSegments("/metrics/current/");
1870 uri.AddPathSegment(request.GetInstanceId());
1871 return GetCurrentMetricDataOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1872 }
1873
GetCurrentMetricDataCallable(const GetCurrentMetricDataRequest & request) const1874 GetCurrentMetricDataOutcomeCallable ConnectClient::GetCurrentMetricDataCallable(const GetCurrentMetricDataRequest& request) const
1875 {
1876 auto task = Aws::MakeShared< std::packaged_task< GetCurrentMetricDataOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetCurrentMetricData(request); } );
1877 auto packagedFunction = [task]() { (*task)(); };
1878 m_executor->Submit(packagedFunction);
1879 return task->get_future();
1880 }
1881
GetCurrentMetricDataAsync(const GetCurrentMetricDataRequest & request,const GetCurrentMetricDataResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1882 void ConnectClient::GetCurrentMetricDataAsync(const GetCurrentMetricDataRequest& request, const GetCurrentMetricDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1883 {
1884 m_executor->Submit( [this, request, handler, context](){ this->GetCurrentMetricDataAsyncHelper( request, handler, context ); } );
1885 }
1886
GetCurrentMetricDataAsyncHelper(const GetCurrentMetricDataRequest & request,const GetCurrentMetricDataResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1887 void ConnectClient::GetCurrentMetricDataAsyncHelper(const GetCurrentMetricDataRequest& request, const GetCurrentMetricDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1888 {
1889 handler(this, request, GetCurrentMetricData(request), context);
1890 }
1891
GetFederationToken(const GetFederationTokenRequest & request) const1892 GetFederationTokenOutcome ConnectClient::GetFederationToken(const GetFederationTokenRequest& request) const
1893 {
1894 if (!request.InstanceIdHasBeenSet())
1895 {
1896 AWS_LOGSTREAM_ERROR("GetFederationToken", "Required field: InstanceId, is not set");
1897 return GetFederationTokenOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1898 }
1899 Aws::Http::URI uri = m_uri;
1900 uri.AddPathSegments("/user/federate/");
1901 uri.AddPathSegment(request.GetInstanceId());
1902 return GetFederationTokenOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1903 }
1904
GetFederationTokenCallable(const GetFederationTokenRequest & request) const1905 GetFederationTokenOutcomeCallable ConnectClient::GetFederationTokenCallable(const GetFederationTokenRequest& request) const
1906 {
1907 auto task = Aws::MakeShared< std::packaged_task< GetFederationTokenOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFederationToken(request); } );
1908 auto packagedFunction = [task]() { (*task)(); };
1909 m_executor->Submit(packagedFunction);
1910 return task->get_future();
1911 }
1912
GetFederationTokenAsync(const GetFederationTokenRequest & request,const GetFederationTokenResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1913 void ConnectClient::GetFederationTokenAsync(const GetFederationTokenRequest& request, const GetFederationTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1914 {
1915 m_executor->Submit( [this, request, handler, context](){ this->GetFederationTokenAsyncHelper( request, handler, context ); } );
1916 }
1917
GetFederationTokenAsyncHelper(const GetFederationTokenRequest & request,const GetFederationTokenResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1918 void ConnectClient::GetFederationTokenAsyncHelper(const GetFederationTokenRequest& request, const GetFederationTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1919 {
1920 handler(this, request, GetFederationToken(request), context);
1921 }
1922
GetMetricData(const GetMetricDataRequest & request) const1923 GetMetricDataOutcome ConnectClient::GetMetricData(const GetMetricDataRequest& request) const
1924 {
1925 if (!request.InstanceIdHasBeenSet())
1926 {
1927 AWS_LOGSTREAM_ERROR("GetMetricData", "Required field: InstanceId, is not set");
1928 return GetMetricDataOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1929 }
1930 Aws::Http::URI uri = m_uri;
1931 uri.AddPathSegments("/metrics/historical/");
1932 uri.AddPathSegment(request.GetInstanceId());
1933 return GetMetricDataOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1934 }
1935
GetMetricDataCallable(const GetMetricDataRequest & request) const1936 GetMetricDataOutcomeCallable ConnectClient::GetMetricDataCallable(const GetMetricDataRequest& request) const
1937 {
1938 auto task = Aws::MakeShared< std::packaged_task< GetMetricDataOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetMetricData(request); } );
1939 auto packagedFunction = [task]() { (*task)(); };
1940 m_executor->Submit(packagedFunction);
1941 return task->get_future();
1942 }
1943
GetMetricDataAsync(const GetMetricDataRequest & request,const GetMetricDataResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1944 void ConnectClient::GetMetricDataAsync(const GetMetricDataRequest& request, const GetMetricDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1945 {
1946 m_executor->Submit( [this, request, handler, context](){ this->GetMetricDataAsyncHelper( request, handler, context ); } );
1947 }
1948
GetMetricDataAsyncHelper(const GetMetricDataRequest & request,const GetMetricDataResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1949 void ConnectClient::GetMetricDataAsyncHelper(const GetMetricDataRequest& request, const GetMetricDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1950 {
1951 handler(this, request, GetMetricData(request), context);
1952 }
1953
ListAgentStatuses(const ListAgentStatusesRequest & request) const1954 ListAgentStatusesOutcome ConnectClient::ListAgentStatuses(const ListAgentStatusesRequest& request) const
1955 {
1956 if (!request.InstanceIdHasBeenSet())
1957 {
1958 AWS_LOGSTREAM_ERROR("ListAgentStatuses", "Required field: InstanceId, is not set");
1959 return ListAgentStatusesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1960 }
1961 Aws::Http::URI uri = m_uri;
1962 uri.AddPathSegments("/agent-status/");
1963 uri.AddPathSegment(request.GetInstanceId());
1964 return ListAgentStatusesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1965 }
1966
ListAgentStatusesCallable(const ListAgentStatusesRequest & request) const1967 ListAgentStatusesOutcomeCallable ConnectClient::ListAgentStatusesCallable(const ListAgentStatusesRequest& request) const
1968 {
1969 auto task = Aws::MakeShared< std::packaged_task< ListAgentStatusesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAgentStatuses(request); } );
1970 auto packagedFunction = [task]() { (*task)(); };
1971 m_executor->Submit(packagedFunction);
1972 return task->get_future();
1973 }
1974
ListAgentStatusesAsync(const ListAgentStatusesRequest & request,const ListAgentStatusesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1975 void ConnectClient::ListAgentStatusesAsync(const ListAgentStatusesRequest& request, const ListAgentStatusesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1976 {
1977 m_executor->Submit( [this, request, handler, context](){ this->ListAgentStatusesAsyncHelper( request, handler, context ); } );
1978 }
1979
ListAgentStatusesAsyncHelper(const ListAgentStatusesRequest & request,const ListAgentStatusesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1980 void ConnectClient::ListAgentStatusesAsyncHelper(const ListAgentStatusesRequest& request, const ListAgentStatusesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1981 {
1982 handler(this, request, ListAgentStatuses(request), context);
1983 }
1984
ListApprovedOrigins(const ListApprovedOriginsRequest & request) const1985 ListApprovedOriginsOutcome ConnectClient::ListApprovedOrigins(const ListApprovedOriginsRequest& request) const
1986 {
1987 if (!request.InstanceIdHasBeenSet())
1988 {
1989 AWS_LOGSTREAM_ERROR("ListApprovedOrigins", "Required field: InstanceId, is not set");
1990 return ListApprovedOriginsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
1991 }
1992 Aws::Http::URI uri = m_uri;
1993 uri.AddPathSegments("/instance/");
1994 uri.AddPathSegment(request.GetInstanceId());
1995 uri.AddPathSegments("/approved-origins");
1996 return ListApprovedOriginsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1997 }
1998
ListApprovedOriginsCallable(const ListApprovedOriginsRequest & request) const1999 ListApprovedOriginsOutcomeCallable ConnectClient::ListApprovedOriginsCallable(const ListApprovedOriginsRequest& request) const
2000 {
2001 auto task = Aws::MakeShared< std::packaged_task< ListApprovedOriginsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListApprovedOrigins(request); } );
2002 auto packagedFunction = [task]() { (*task)(); };
2003 m_executor->Submit(packagedFunction);
2004 return task->get_future();
2005 }
2006
ListApprovedOriginsAsync(const ListApprovedOriginsRequest & request,const ListApprovedOriginsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2007 void ConnectClient::ListApprovedOriginsAsync(const ListApprovedOriginsRequest& request, const ListApprovedOriginsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2008 {
2009 m_executor->Submit( [this, request, handler, context](){ this->ListApprovedOriginsAsyncHelper( request, handler, context ); } );
2010 }
2011
ListApprovedOriginsAsyncHelper(const ListApprovedOriginsRequest & request,const ListApprovedOriginsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2012 void ConnectClient::ListApprovedOriginsAsyncHelper(const ListApprovedOriginsRequest& request, const ListApprovedOriginsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2013 {
2014 handler(this, request, ListApprovedOrigins(request), context);
2015 }
2016
ListBots(const ListBotsRequest & request) const2017 ListBotsOutcome ConnectClient::ListBots(const ListBotsRequest& request) const
2018 {
2019 if (!request.InstanceIdHasBeenSet())
2020 {
2021 AWS_LOGSTREAM_ERROR("ListBots", "Required field: InstanceId, is not set");
2022 return ListBotsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2023 }
2024 if (!request.LexVersionHasBeenSet())
2025 {
2026 AWS_LOGSTREAM_ERROR("ListBots", "Required field: LexVersion, is not set");
2027 return ListBotsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LexVersion]", false));
2028 }
2029 Aws::Http::URI uri = m_uri;
2030 uri.AddPathSegments("/instance/");
2031 uri.AddPathSegment(request.GetInstanceId());
2032 uri.AddPathSegments("/bots");
2033 return ListBotsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2034 }
2035
ListBotsCallable(const ListBotsRequest & request) const2036 ListBotsOutcomeCallable ConnectClient::ListBotsCallable(const ListBotsRequest& request) const
2037 {
2038 auto task = Aws::MakeShared< std::packaged_task< ListBotsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListBots(request); } );
2039 auto packagedFunction = [task]() { (*task)(); };
2040 m_executor->Submit(packagedFunction);
2041 return task->get_future();
2042 }
2043
ListBotsAsync(const ListBotsRequest & request,const ListBotsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2044 void ConnectClient::ListBotsAsync(const ListBotsRequest& request, const ListBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2045 {
2046 m_executor->Submit( [this, request, handler, context](){ this->ListBotsAsyncHelper( request, handler, context ); } );
2047 }
2048
ListBotsAsyncHelper(const ListBotsRequest & request,const ListBotsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2049 void ConnectClient::ListBotsAsyncHelper(const ListBotsRequest& request, const ListBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2050 {
2051 handler(this, request, ListBots(request), context);
2052 }
2053
ListContactFlows(const ListContactFlowsRequest & request) const2054 ListContactFlowsOutcome ConnectClient::ListContactFlows(const ListContactFlowsRequest& request) const
2055 {
2056 if (!request.InstanceIdHasBeenSet())
2057 {
2058 AWS_LOGSTREAM_ERROR("ListContactFlows", "Required field: InstanceId, is not set");
2059 return ListContactFlowsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2060 }
2061 Aws::Http::URI uri = m_uri;
2062 uri.AddPathSegments("/contact-flows-summary/");
2063 uri.AddPathSegment(request.GetInstanceId());
2064 return ListContactFlowsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2065 }
2066
ListContactFlowsCallable(const ListContactFlowsRequest & request) const2067 ListContactFlowsOutcomeCallable ConnectClient::ListContactFlowsCallable(const ListContactFlowsRequest& request) const
2068 {
2069 auto task = Aws::MakeShared< std::packaged_task< ListContactFlowsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListContactFlows(request); } );
2070 auto packagedFunction = [task]() { (*task)(); };
2071 m_executor->Submit(packagedFunction);
2072 return task->get_future();
2073 }
2074
ListContactFlowsAsync(const ListContactFlowsRequest & request,const ListContactFlowsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2075 void ConnectClient::ListContactFlowsAsync(const ListContactFlowsRequest& request, const ListContactFlowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2076 {
2077 m_executor->Submit( [this, request, handler, context](){ this->ListContactFlowsAsyncHelper( request, handler, context ); } );
2078 }
2079
ListContactFlowsAsyncHelper(const ListContactFlowsRequest & request,const ListContactFlowsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2080 void ConnectClient::ListContactFlowsAsyncHelper(const ListContactFlowsRequest& request, const ListContactFlowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2081 {
2082 handler(this, request, ListContactFlows(request), context);
2083 }
2084
ListHoursOfOperations(const ListHoursOfOperationsRequest & request) const2085 ListHoursOfOperationsOutcome ConnectClient::ListHoursOfOperations(const ListHoursOfOperationsRequest& request) const
2086 {
2087 if (!request.InstanceIdHasBeenSet())
2088 {
2089 AWS_LOGSTREAM_ERROR("ListHoursOfOperations", "Required field: InstanceId, is not set");
2090 return ListHoursOfOperationsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2091 }
2092 Aws::Http::URI uri = m_uri;
2093 uri.AddPathSegments("/hours-of-operations-summary/");
2094 uri.AddPathSegment(request.GetInstanceId());
2095 return ListHoursOfOperationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2096 }
2097
ListHoursOfOperationsCallable(const ListHoursOfOperationsRequest & request) const2098 ListHoursOfOperationsOutcomeCallable ConnectClient::ListHoursOfOperationsCallable(const ListHoursOfOperationsRequest& request) const
2099 {
2100 auto task = Aws::MakeShared< std::packaged_task< ListHoursOfOperationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListHoursOfOperations(request); } );
2101 auto packagedFunction = [task]() { (*task)(); };
2102 m_executor->Submit(packagedFunction);
2103 return task->get_future();
2104 }
2105
ListHoursOfOperationsAsync(const ListHoursOfOperationsRequest & request,const ListHoursOfOperationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2106 void ConnectClient::ListHoursOfOperationsAsync(const ListHoursOfOperationsRequest& request, const ListHoursOfOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2107 {
2108 m_executor->Submit( [this, request, handler, context](){ this->ListHoursOfOperationsAsyncHelper( request, handler, context ); } );
2109 }
2110
ListHoursOfOperationsAsyncHelper(const ListHoursOfOperationsRequest & request,const ListHoursOfOperationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2111 void ConnectClient::ListHoursOfOperationsAsyncHelper(const ListHoursOfOperationsRequest& request, const ListHoursOfOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2112 {
2113 handler(this, request, ListHoursOfOperations(request), context);
2114 }
2115
ListInstanceAttributes(const ListInstanceAttributesRequest & request) const2116 ListInstanceAttributesOutcome ConnectClient::ListInstanceAttributes(const ListInstanceAttributesRequest& request) const
2117 {
2118 if (!request.InstanceIdHasBeenSet())
2119 {
2120 AWS_LOGSTREAM_ERROR("ListInstanceAttributes", "Required field: InstanceId, is not set");
2121 return ListInstanceAttributesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2122 }
2123 Aws::Http::URI uri = m_uri;
2124 uri.AddPathSegments("/instance/");
2125 uri.AddPathSegment(request.GetInstanceId());
2126 uri.AddPathSegments("/attributes");
2127 return ListInstanceAttributesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2128 }
2129
ListInstanceAttributesCallable(const ListInstanceAttributesRequest & request) const2130 ListInstanceAttributesOutcomeCallable ConnectClient::ListInstanceAttributesCallable(const ListInstanceAttributesRequest& request) const
2131 {
2132 auto task = Aws::MakeShared< std::packaged_task< ListInstanceAttributesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListInstanceAttributes(request); } );
2133 auto packagedFunction = [task]() { (*task)(); };
2134 m_executor->Submit(packagedFunction);
2135 return task->get_future();
2136 }
2137
ListInstanceAttributesAsync(const ListInstanceAttributesRequest & request,const ListInstanceAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2138 void ConnectClient::ListInstanceAttributesAsync(const ListInstanceAttributesRequest& request, const ListInstanceAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2139 {
2140 m_executor->Submit( [this, request, handler, context](){ this->ListInstanceAttributesAsyncHelper( request, handler, context ); } );
2141 }
2142
ListInstanceAttributesAsyncHelper(const ListInstanceAttributesRequest & request,const ListInstanceAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2143 void ConnectClient::ListInstanceAttributesAsyncHelper(const ListInstanceAttributesRequest& request, const ListInstanceAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2144 {
2145 handler(this, request, ListInstanceAttributes(request), context);
2146 }
2147
ListInstanceStorageConfigs(const ListInstanceStorageConfigsRequest & request) const2148 ListInstanceStorageConfigsOutcome ConnectClient::ListInstanceStorageConfigs(const ListInstanceStorageConfigsRequest& request) const
2149 {
2150 if (!request.InstanceIdHasBeenSet())
2151 {
2152 AWS_LOGSTREAM_ERROR("ListInstanceStorageConfigs", "Required field: InstanceId, is not set");
2153 return ListInstanceStorageConfigsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2154 }
2155 if (!request.ResourceTypeHasBeenSet())
2156 {
2157 AWS_LOGSTREAM_ERROR("ListInstanceStorageConfigs", "Required field: ResourceType, is not set");
2158 return ListInstanceStorageConfigsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceType]", false));
2159 }
2160 Aws::Http::URI uri = m_uri;
2161 uri.AddPathSegments("/instance/");
2162 uri.AddPathSegment(request.GetInstanceId());
2163 uri.AddPathSegments("/storage-configs");
2164 return ListInstanceStorageConfigsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2165 }
2166
ListInstanceStorageConfigsCallable(const ListInstanceStorageConfigsRequest & request) const2167 ListInstanceStorageConfigsOutcomeCallable ConnectClient::ListInstanceStorageConfigsCallable(const ListInstanceStorageConfigsRequest& request) const
2168 {
2169 auto task = Aws::MakeShared< std::packaged_task< ListInstanceStorageConfigsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListInstanceStorageConfigs(request); } );
2170 auto packagedFunction = [task]() { (*task)(); };
2171 m_executor->Submit(packagedFunction);
2172 return task->get_future();
2173 }
2174
ListInstanceStorageConfigsAsync(const ListInstanceStorageConfigsRequest & request,const ListInstanceStorageConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2175 void ConnectClient::ListInstanceStorageConfigsAsync(const ListInstanceStorageConfigsRequest& request, const ListInstanceStorageConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2176 {
2177 m_executor->Submit( [this, request, handler, context](){ this->ListInstanceStorageConfigsAsyncHelper( request, handler, context ); } );
2178 }
2179
ListInstanceStorageConfigsAsyncHelper(const ListInstanceStorageConfigsRequest & request,const ListInstanceStorageConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2180 void ConnectClient::ListInstanceStorageConfigsAsyncHelper(const ListInstanceStorageConfigsRequest& request, const ListInstanceStorageConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2181 {
2182 handler(this, request, ListInstanceStorageConfigs(request), context);
2183 }
2184
ListInstances(const ListInstancesRequest & request) const2185 ListInstancesOutcome ConnectClient::ListInstances(const ListInstancesRequest& request) const
2186 {
2187 Aws::Http::URI uri = m_uri;
2188 uri.AddPathSegments("/instance");
2189 return ListInstancesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2190 }
2191
ListInstancesCallable(const ListInstancesRequest & request) const2192 ListInstancesOutcomeCallable ConnectClient::ListInstancesCallable(const ListInstancesRequest& request) const
2193 {
2194 auto task = Aws::MakeShared< std::packaged_task< ListInstancesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListInstances(request); } );
2195 auto packagedFunction = [task]() { (*task)(); };
2196 m_executor->Submit(packagedFunction);
2197 return task->get_future();
2198 }
2199
ListInstancesAsync(const ListInstancesRequest & request,const ListInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2200 void ConnectClient::ListInstancesAsync(const ListInstancesRequest& request, const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2201 {
2202 m_executor->Submit( [this, request, handler, context](){ this->ListInstancesAsyncHelper( request, handler, context ); } );
2203 }
2204
ListInstancesAsyncHelper(const ListInstancesRequest & request,const ListInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2205 void ConnectClient::ListInstancesAsyncHelper(const ListInstancesRequest& request, const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2206 {
2207 handler(this, request, ListInstances(request), context);
2208 }
2209
ListIntegrationAssociations(const ListIntegrationAssociationsRequest & request) const2210 ListIntegrationAssociationsOutcome ConnectClient::ListIntegrationAssociations(const ListIntegrationAssociationsRequest& request) const
2211 {
2212 if (!request.InstanceIdHasBeenSet())
2213 {
2214 AWS_LOGSTREAM_ERROR("ListIntegrationAssociations", "Required field: InstanceId, is not set");
2215 return ListIntegrationAssociationsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2216 }
2217 Aws::Http::URI uri = m_uri;
2218 uri.AddPathSegments("/instance/");
2219 uri.AddPathSegment(request.GetInstanceId());
2220 uri.AddPathSegments("/integration-associations");
2221 return ListIntegrationAssociationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2222 }
2223
ListIntegrationAssociationsCallable(const ListIntegrationAssociationsRequest & request) const2224 ListIntegrationAssociationsOutcomeCallable ConnectClient::ListIntegrationAssociationsCallable(const ListIntegrationAssociationsRequest& request) const
2225 {
2226 auto task = Aws::MakeShared< std::packaged_task< ListIntegrationAssociationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListIntegrationAssociations(request); } );
2227 auto packagedFunction = [task]() { (*task)(); };
2228 m_executor->Submit(packagedFunction);
2229 return task->get_future();
2230 }
2231
ListIntegrationAssociationsAsync(const ListIntegrationAssociationsRequest & request,const ListIntegrationAssociationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2232 void ConnectClient::ListIntegrationAssociationsAsync(const ListIntegrationAssociationsRequest& request, const ListIntegrationAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2233 {
2234 m_executor->Submit( [this, request, handler, context](){ this->ListIntegrationAssociationsAsyncHelper( request, handler, context ); } );
2235 }
2236
ListIntegrationAssociationsAsyncHelper(const ListIntegrationAssociationsRequest & request,const ListIntegrationAssociationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2237 void ConnectClient::ListIntegrationAssociationsAsyncHelper(const ListIntegrationAssociationsRequest& request, const ListIntegrationAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2238 {
2239 handler(this, request, ListIntegrationAssociations(request), context);
2240 }
2241
ListLambdaFunctions(const ListLambdaFunctionsRequest & request) const2242 ListLambdaFunctionsOutcome ConnectClient::ListLambdaFunctions(const ListLambdaFunctionsRequest& request) const
2243 {
2244 if (!request.InstanceIdHasBeenSet())
2245 {
2246 AWS_LOGSTREAM_ERROR("ListLambdaFunctions", "Required field: InstanceId, is not set");
2247 return ListLambdaFunctionsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2248 }
2249 Aws::Http::URI uri = m_uri;
2250 uri.AddPathSegments("/instance/");
2251 uri.AddPathSegment(request.GetInstanceId());
2252 uri.AddPathSegments("/lambda-functions");
2253 return ListLambdaFunctionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2254 }
2255
ListLambdaFunctionsCallable(const ListLambdaFunctionsRequest & request) const2256 ListLambdaFunctionsOutcomeCallable ConnectClient::ListLambdaFunctionsCallable(const ListLambdaFunctionsRequest& request) const
2257 {
2258 auto task = Aws::MakeShared< std::packaged_task< ListLambdaFunctionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListLambdaFunctions(request); } );
2259 auto packagedFunction = [task]() { (*task)(); };
2260 m_executor->Submit(packagedFunction);
2261 return task->get_future();
2262 }
2263
ListLambdaFunctionsAsync(const ListLambdaFunctionsRequest & request,const ListLambdaFunctionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2264 void ConnectClient::ListLambdaFunctionsAsync(const ListLambdaFunctionsRequest& request, const ListLambdaFunctionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2265 {
2266 m_executor->Submit( [this, request, handler, context](){ this->ListLambdaFunctionsAsyncHelper( request, handler, context ); } );
2267 }
2268
ListLambdaFunctionsAsyncHelper(const ListLambdaFunctionsRequest & request,const ListLambdaFunctionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2269 void ConnectClient::ListLambdaFunctionsAsyncHelper(const ListLambdaFunctionsRequest& request, const ListLambdaFunctionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2270 {
2271 handler(this, request, ListLambdaFunctions(request), context);
2272 }
2273
ListLexBots(const ListLexBotsRequest & request) const2274 ListLexBotsOutcome ConnectClient::ListLexBots(const ListLexBotsRequest& request) const
2275 {
2276 if (!request.InstanceIdHasBeenSet())
2277 {
2278 AWS_LOGSTREAM_ERROR("ListLexBots", "Required field: InstanceId, is not set");
2279 return ListLexBotsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2280 }
2281 Aws::Http::URI uri = m_uri;
2282 uri.AddPathSegments("/instance/");
2283 uri.AddPathSegment(request.GetInstanceId());
2284 uri.AddPathSegments("/lex-bots");
2285 return ListLexBotsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2286 }
2287
ListLexBotsCallable(const ListLexBotsRequest & request) const2288 ListLexBotsOutcomeCallable ConnectClient::ListLexBotsCallable(const ListLexBotsRequest& request) const
2289 {
2290 auto task = Aws::MakeShared< std::packaged_task< ListLexBotsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListLexBots(request); } );
2291 auto packagedFunction = [task]() { (*task)(); };
2292 m_executor->Submit(packagedFunction);
2293 return task->get_future();
2294 }
2295
ListLexBotsAsync(const ListLexBotsRequest & request,const ListLexBotsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2296 void ConnectClient::ListLexBotsAsync(const ListLexBotsRequest& request, const ListLexBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2297 {
2298 m_executor->Submit( [this, request, handler, context](){ this->ListLexBotsAsyncHelper( request, handler, context ); } );
2299 }
2300
ListLexBotsAsyncHelper(const ListLexBotsRequest & request,const ListLexBotsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2301 void ConnectClient::ListLexBotsAsyncHelper(const ListLexBotsRequest& request, const ListLexBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2302 {
2303 handler(this, request, ListLexBots(request), context);
2304 }
2305
ListPhoneNumbers(const ListPhoneNumbersRequest & request) const2306 ListPhoneNumbersOutcome ConnectClient::ListPhoneNumbers(const ListPhoneNumbersRequest& request) const
2307 {
2308 if (!request.InstanceIdHasBeenSet())
2309 {
2310 AWS_LOGSTREAM_ERROR("ListPhoneNumbers", "Required field: InstanceId, is not set");
2311 return ListPhoneNumbersOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2312 }
2313 Aws::Http::URI uri = m_uri;
2314 uri.AddPathSegments("/phone-numbers-summary/");
2315 uri.AddPathSegment(request.GetInstanceId());
2316 return ListPhoneNumbersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2317 }
2318
ListPhoneNumbersCallable(const ListPhoneNumbersRequest & request) const2319 ListPhoneNumbersOutcomeCallable ConnectClient::ListPhoneNumbersCallable(const ListPhoneNumbersRequest& request) const
2320 {
2321 auto task = Aws::MakeShared< std::packaged_task< ListPhoneNumbersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPhoneNumbers(request); } );
2322 auto packagedFunction = [task]() { (*task)(); };
2323 m_executor->Submit(packagedFunction);
2324 return task->get_future();
2325 }
2326
ListPhoneNumbersAsync(const ListPhoneNumbersRequest & request,const ListPhoneNumbersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2327 void ConnectClient::ListPhoneNumbersAsync(const ListPhoneNumbersRequest& request, const ListPhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2328 {
2329 m_executor->Submit( [this, request, handler, context](){ this->ListPhoneNumbersAsyncHelper( request, handler, context ); } );
2330 }
2331
ListPhoneNumbersAsyncHelper(const ListPhoneNumbersRequest & request,const ListPhoneNumbersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2332 void ConnectClient::ListPhoneNumbersAsyncHelper(const ListPhoneNumbersRequest& request, const ListPhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2333 {
2334 handler(this, request, ListPhoneNumbers(request), context);
2335 }
2336
ListPrompts(const ListPromptsRequest & request) const2337 ListPromptsOutcome ConnectClient::ListPrompts(const ListPromptsRequest& request) const
2338 {
2339 if (!request.InstanceIdHasBeenSet())
2340 {
2341 AWS_LOGSTREAM_ERROR("ListPrompts", "Required field: InstanceId, is not set");
2342 return ListPromptsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2343 }
2344 Aws::Http::URI uri = m_uri;
2345 uri.AddPathSegments("/prompts-summary/");
2346 uri.AddPathSegment(request.GetInstanceId());
2347 return ListPromptsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2348 }
2349
ListPromptsCallable(const ListPromptsRequest & request) const2350 ListPromptsOutcomeCallable ConnectClient::ListPromptsCallable(const ListPromptsRequest& request) const
2351 {
2352 auto task = Aws::MakeShared< std::packaged_task< ListPromptsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPrompts(request); } );
2353 auto packagedFunction = [task]() { (*task)(); };
2354 m_executor->Submit(packagedFunction);
2355 return task->get_future();
2356 }
2357
ListPromptsAsync(const ListPromptsRequest & request,const ListPromptsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2358 void ConnectClient::ListPromptsAsync(const ListPromptsRequest& request, const ListPromptsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2359 {
2360 m_executor->Submit( [this, request, handler, context](){ this->ListPromptsAsyncHelper( request, handler, context ); } );
2361 }
2362
ListPromptsAsyncHelper(const ListPromptsRequest & request,const ListPromptsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2363 void ConnectClient::ListPromptsAsyncHelper(const ListPromptsRequest& request, const ListPromptsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2364 {
2365 handler(this, request, ListPrompts(request), context);
2366 }
2367
ListQueueQuickConnects(const ListQueueQuickConnectsRequest & request) const2368 ListQueueQuickConnectsOutcome ConnectClient::ListQueueQuickConnects(const ListQueueQuickConnectsRequest& request) const
2369 {
2370 if (!request.InstanceIdHasBeenSet())
2371 {
2372 AWS_LOGSTREAM_ERROR("ListQueueQuickConnects", "Required field: InstanceId, is not set");
2373 return ListQueueQuickConnectsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2374 }
2375 if (!request.QueueIdHasBeenSet())
2376 {
2377 AWS_LOGSTREAM_ERROR("ListQueueQuickConnects", "Required field: QueueId, is not set");
2378 return ListQueueQuickConnectsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
2379 }
2380 Aws::Http::URI uri = m_uri;
2381 uri.AddPathSegments("/queues/");
2382 uri.AddPathSegment(request.GetInstanceId());
2383 uri.AddPathSegment(request.GetQueueId());
2384 uri.AddPathSegments("/quick-connects");
2385 return ListQueueQuickConnectsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2386 }
2387
ListQueueQuickConnectsCallable(const ListQueueQuickConnectsRequest & request) const2388 ListQueueQuickConnectsOutcomeCallable ConnectClient::ListQueueQuickConnectsCallable(const ListQueueQuickConnectsRequest& request) const
2389 {
2390 auto task = Aws::MakeShared< std::packaged_task< ListQueueQuickConnectsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListQueueQuickConnects(request); } );
2391 auto packagedFunction = [task]() { (*task)(); };
2392 m_executor->Submit(packagedFunction);
2393 return task->get_future();
2394 }
2395
ListQueueQuickConnectsAsync(const ListQueueQuickConnectsRequest & request,const ListQueueQuickConnectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2396 void ConnectClient::ListQueueQuickConnectsAsync(const ListQueueQuickConnectsRequest& request, const ListQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2397 {
2398 m_executor->Submit( [this, request, handler, context](){ this->ListQueueQuickConnectsAsyncHelper( request, handler, context ); } );
2399 }
2400
ListQueueQuickConnectsAsyncHelper(const ListQueueQuickConnectsRequest & request,const ListQueueQuickConnectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2401 void ConnectClient::ListQueueQuickConnectsAsyncHelper(const ListQueueQuickConnectsRequest& request, const ListQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2402 {
2403 handler(this, request, ListQueueQuickConnects(request), context);
2404 }
2405
ListQueues(const ListQueuesRequest & request) const2406 ListQueuesOutcome ConnectClient::ListQueues(const ListQueuesRequest& request) const
2407 {
2408 if (!request.InstanceIdHasBeenSet())
2409 {
2410 AWS_LOGSTREAM_ERROR("ListQueues", "Required field: InstanceId, is not set");
2411 return ListQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2412 }
2413 Aws::Http::URI uri = m_uri;
2414 uri.AddPathSegments("/queues-summary/");
2415 uri.AddPathSegment(request.GetInstanceId());
2416 return ListQueuesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2417 }
2418
ListQueuesCallable(const ListQueuesRequest & request) const2419 ListQueuesOutcomeCallable ConnectClient::ListQueuesCallable(const ListQueuesRequest& request) const
2420 {
2421 auto task = Aws::MakeShared< std::packaged_task< ListQueuesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListQueues(request); } );
2422 auto packagedFunction = [task]() { (*task)(); };
2423 m_executor->Submit(packagedFunction);
2424 return task->get_future();
2425 }
2426
ListQueuesAsync(const ListQueuesRequest & request,const ListQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2427 void ConnectClient::ListQueuesAsync(const ListQueuesRequest& request, const ListQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2428 {
2429 m_executor->Submit( [this, request, handler, context](){ this->ListQueuesAsyncHelper( request, handler, context ); } );
2430 }
2431
ListQueuesAsyncHelper(const ListQueuesRequest & request,const ListQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2432 void ConnectClient::ListQueuesAsyncHelper(const ListQueuesRequest& request, const ListQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2433 {
2434 handler(this, request, ListQueues(request), context);
2435 }
2436
ListQuickConnects(const ListQuickConnectsRequest & request) const2437 ListQuickConnectsOutcome ConnectClient::ListQuickConnects(const ListQuickConnectsRequest& request) const
2438 {
2439 if (!request.InstanceIdHasBeenSet())
2440 {
2441 AWS_LOGSTREAM_ERROR("ListQuickConnects", "Required field: InstanceId, is not set");
2442 return ListQuickConnectsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2443 }
2444 Aws::Http::URI uri = m_uri;
2445 uri.AddPathSegments("/quick-connects/");
2446 uri.AddPathSegment(request.GetInstanceId());
2447 return ListQuickConnectsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2448 }
2449
ListQuickConnectsCallable(const ListQuickConnectsRequest & request) const2450 ListQuickConnectsOutcomeCallable ConnectClient::ListQuickConnectsCallable(const ListQuickConnectsRequest& request) const
2451 {
2452 auto task = Aws::MakeShared< std::packaged_task< ListQuickConnectsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListQuickConnects(request); } );
2453 auto packagedFunction = [task]() { (*task)(); };
2454 m_executor->Submit(packagedFunction);
2455 return task->get_future();
2456 }
2457
ListQuickConnectsAsync(const ListQuickConnectsRequest & request,const ListQuickConnectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2458 void ConnectClient::ListQuickConnectsAsync(const ListQuickConnectsRequest& request, const ListQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2459 {
2460 m_executor->Submit( [this, request, handler, context](){ this->ListQuickConnectsAsyncHelper( request, handler, context ); } );
2461 }
2462
ListQuickConnectsAsyncHelper(const ListQuickConnectsRequest & request,const ListQuickConnectsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2463 void ConnectClient::ListQuickConnectsAsyncHelper(const ListQuickConnectsRequest& request, const ListQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2464 {
2465 handler(this, request, ListQuickConnects(request), context);
2466 }
2467
ListRoutingProfileQueues(const ListRoutingProfileQueuesRequest & request) const2468 ListRoutingProfileQueuesOutcome ConnectClient::ListRoutingProfileQueues(const ListRoutingProfileQueuesRequest& request) const
2469 {
2470 if (!request.InstanceIdHasBeenSet())
2471 {
2472 AWS_LOGSTREAM_ERROR("ListRoutingProfileQueues", "Required field: InstanceId, is not set");
2473 return ListRoutingProfileQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2474 }
2475 if (!request.RoutingProfileIdHasBeenSet())
2476 {
2477 AWS_LOGSTREAM_ERROR("ListRoutingProfileQueues", "Required field: RoutingProfileId, is not set");
2478 return ListRoutingProfileQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoutingProfileId]", false));
2479 }
2480 Aws::Http::URI uri = m_uri;
2481 uri.AddPathSegments("/routing-profiles/");
2482 uri.AddPathSegment(request.GetInstanceId());
2483 uri.AddPathSegment(request.GetRoutingProfileId());
2484 uri.AddPathSegments("/queues");
2485 return ListRoutingProfileQueuesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2486 }
2487
ListRoutingProfileQueuesCallable(const ListRoutingProfileQueuesRequest & request) const2488 ListRoutingProfileQueuesOutcomeCallable ConnectClient::ListRoutingProfileQueuesCallable(const ListRoutingProfileQueuesRequest& request) const
2489 {
2490 auto task = Aws::MakeShared< std::packaged_task< ListRoutingProfileQueuesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRoutingProfileQueues(request); } );
2491 auto packagedFunction = [task]() { (*task)(); };
2492 m_executor->Submit(packagedFunction);
2493 return task->get_future();
2494 }
2495
ListRoutingProfileQueuesAsync(const ListRoutingProfileQueuesRequest & request,const ListRoutingProfileQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2496 void ConnectClient::ListRoutingProfileQueuesAsync(const ListRoutingProfileQueuesRequest& request, const ListRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2497 {
2498 m_executor->Submit( [this, request, handler, context](){ this->ListRoutingProfileQueuesAsyncHelper( request, handler, context ); } );
2499 }
2500
ListRoutingProfileQueuesAsyncHelper(const ListRoutingProfileQueuesRequest & request,const ListRoutingProfileQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2501 void ConnectClient::ListRoutingProfileQueuesAsyncHelper(const ListRoutingProfileQueuesRequest& request, const ListRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2502 {
2503 handler(this, request, ListRoutingProfileQueues(request), context);
2504 }
2505
ListRoutingProfiles(const ListRoutingProfilesRequest & request) const2506 ListRoutingProfilesOutcome ConnectClient::ListRoutingProfiles(const ListRoutingProfilesRequest& request) const
2507 {
2508 if (!request.InstanceIdHasBeenSet())
2509 {
2510 AWS_LOGSTREAM_ERROR("ListRoutingProfiles", "Required field: InstanceId, is not set");
2511 return ListRoutingProfilesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2512 }
2513 Aws::Http::URI uri = m_uri;
2514 uri.AddPathSegments("/routing-profiles-summary/");
2515 uri.AddPathSegment(request.GetInstanceId());
2516 return ListRoutingProfilesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2517 }
2518
ListRoutingProfilesCallable(const ListRoutingProfilesRequest & request) const2519 ListRoutingProfilesOutcomeCallable ConnectClient::ListRoutingProfilesCallable(const ListRoutingProfilesRequest& request) const
2520 {
2521 auto task = Aws::MakeShared< std::packaged_task< ListRoutingProfilesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRoutingProfiles(request); } );
2522 auto packagedFunction = [task]() { (*task)(); };
2523 m_executor->Submit(packagedFunction);
2524 return task->get_future();
2525 }
2526
ListRoutingProfilesAsync(const ListRoutingProfilesRequest & request,const ListRoutingProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2527 void ConnectClient::ListRoutingProfilesAsync(const ListRoutingProfilesRequest& request, const ListRoutingProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2528 {
2529 m_executor->Submit( [this, request, handler, context](){ this->ListRoutingProfilesAsyncHelper( request, handler, context ); } );
2530 }
2531
ListRoutingProfilesAsyncHelper(const ListRoutingProfilesRequest & request,const ListRoutingProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2532 void ConnectClient::ListRoutingProfilesAsyncHelper(const ListRoutingProfilesRequest& request, const ListRoutingProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2533 {
2534 handler(this, request, ListRoutingProfiles(request), context);
2535 }
2536
ListSecurityKeys(const ListSecurityKeysRequest & request) const2537 ListSecurityKeysOutcome ConnectClient::ListSecurityKeys(const ListSecurityKeysRequest& request) const
2538 {
2539 if (!request.InstanceIdHasBeenSet())
2540 {
2541 AWS_LOGSTREAM_ERROR("ListSecurityKeys", "Required field: InstanceId, is not set");
2542 return ListSecurityKeysOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2543 }
2544 Aws::Http::URI uri = m_uri;
2545 uri.AddPathSegments("/instance/");
2546 uri.AddPathSegment(request.GetInstanceId());
2547 uri.AddPathSegments("/security-keys");
2548 return ListSecurityKeysOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2549 }
2550
ListSecurityKeysCallable(const ListSecurityKeysRequest & request) const2551 ListSecurityKeysOutcomeCallable ConnectClient::ListSecurityKeysCallable(const ListSecurityKeysRequest& request) const
2552 {
2553 auto task = Aws::MakeShared< std::packaged_task< ListSecurityKeysOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSecurityKeys(request); } );
2554 auto packagedFunction = [task]() { (*task)(); };
2555 m_executor->Submit(packagedFunction);
2556 return task->get_future();
2557 }
2558
ListSecurityKeysAsync(const ListSecurityKeysRequest & request,const ListSecurityKeysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2559 void ConnectClient::ListSecurityKeysAsync(const ListSecurityKeysRequest& request, const ListSecurityKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2560 {
2561 m_executor->Submit( [this, request, handler, context](){ this->ListSecurityKeysAsyncHelper( request, handler, context ); } );
2562 }
2563
ListSecurityKeysAsyncHelper(const ListSecurityKeysRequest & request,const ListSecurityKeysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2564 void ConnectClient::ListSecurityKeysAsyncHelper(const ListSecurityKeysRequest& request, const ListSecurityKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2565 {
2566 handler(this, request, ListSecurityKeys(request), context);
2567 }
2568
ListSecurityProfiles(const ListSecurityProfilesRequest & request) const2569 ListSecurityProfilesOutcome ConnectClient::ListSecurityProfiles(const ListSecurityProfilesRequest& request) const
2570 {
2571 if (!request.InstanceIdHasBeenSet())
2572 {
2573 AWS_LOGSTREAM_ERROR("ListSecurityProfiles", "Required field: InstanceId, is not set");
2574 return ListSecurityProfilesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2575 }
2576 Aws::Http::URI uri = m_uri;
2577 uri.AddPathSegments("/security-profiles-summary/");
2578 uri.AddPathSegment(request.GetInstanceId());
2579 return ListSecurityProfilesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2580 }
2581
ListSecurityProfilesCallable(const ListSecurityProfilesRequest & request) const2582 ListSecurityProfilesOutcomeCallable ConnectClient::ListSecurityProfilesCallable(const ListSecurityProfilesRequest& request) const
2583 {
2584 auto task = Aws::MakeShared< std::packaged_task< ListSecurityProfilesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSecurityProfiles(request); } );
2585 auto packagedFunction = [task]() { (*task)(); };
2586 m_executor->Submit(packagedFunction);
2587 return task->get_future();
2588 }
2589
ListSecurityProfilesAsync(const ListSecurityProfilesRequest & request,const ListSecurityProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2590 void ConnectClient::ListSecurityProfilesAsync(const ListSecurityProfilesRequest& request, const ListSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2591 {
2592 m_executor->Submit( [this, request, handler, context](){ this->ListSecurityProfilesAsyncHelper( request, handler, context ); } );
2593 }
2594
ListSecurityProfilesAsyncHelper(const ListSecurityProfilesRequest & request,const ListSecurityProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2595 void ConnectClient::ListSecurityProfilesAsyncHelper(const ListSecurityProfilesRequest& request, const ListSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2596 {
2597 handler(this, request, ListSecurityProfiles(request), context);
2598 }
2599
ListTagsForResource(const ListTagsForResourceRequest & request) const2600 ListTagsForResourceOutcome ConnectClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
2601 {
2602 if (!request.ResourceArnHasBeenSet())
2603 {
2604 AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceArn, is not set");
2605 return ListTagsForResourceOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
2606 }
2607 Aws::Http::URI uri = m_uri;
2608 uri.AddPathSegments("/tags/");
2609 uri.AddPathSegment(request.GetResourceArn());
2610 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2611 }
2612
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const2613 ListTagsForResourceOutcomeCallable ConnectClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
2614 {
2615 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
2616 auto packagedFunction = [task]() { (*task)(); };
2617 m_executor->Submit(packagedFunction);
2618 return task->get_future();
2619 }
2620
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2621 void ConnectClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2622 {
2623 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
2624 }
2625
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2626 void ConnectClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2627 {
2628 handler(this, request, ListTagsForResource(request), context);
2629 }
2630
ListUseCases(const ListUseCasesRequest & request) const2631 ListUseCasesOutcome ConnectClient::ListUseCases(const ListUseCasesRequest& request) const
2632 {
2633 if (!request.InstanceIdHasBeenSet())
2634 {
2635 AWS_LOGSTREAM_ERROR("ListUseCases", "Required field: InstanceId, is not set");
2636 return ListUseCasesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2637 }
2638 if (!request.IntegrationAssociationIdHasBeenSet())
2639 {
2640 AWS_LOGSTREAM_ERROR("ListUseCases", "Required field: IntegrationAssociationId, is not set");
2641 return ListUseCasesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IntegrationAssociationId]", false));
2642 }
2643 Aws::Http::URI uri = m_uri;
2644 uri.AddPathSegments("/instance/");
2645 uri.AddPathSegment(request.GetInstanceId());
2646 uri.AddPathSegments("/integration-associations/");
2647 uri.AddPathSegment(request.GetIntegrationAssociationId());
2648 uri.AddPathSegments("/use-cases");
2649 return ListUseCasesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2650 }
2651
ListUseCasesCallable(const ListUseCasesRequest & request) const2652 ListUseCasesOutcomeCallable ConnectClient::ListUseCasesCallable(const ListUseCasesRequest& request) const
2653 {
2654 auto task = Aws::MakeShared< std::packaged_task< ListUseCasesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListUseCases(request); } );
2655 auto packagedFunction = [task]() { (*task)(); };
2656 m_executor->Submit(packagedFunction);
2657 return task->get_future();
2658 }
2659
ListUseCasesAsync(const ListUseCasesRequest & request,const ListUseCasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2660 void ConnectClient::ListUseCasesAsync(const ListUseCasesRequest& request, const ListUseCasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2661 {
2662 m_executor->Submit( [this, request, handler, context](){ this->ListUseCasesAsyncHelper( request, handler, context ); } );
2663 }
2664
ListUseCasesAsyncHelper(const ListUseCasesRequest & request,const ListUseCasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2665 void ConnectClient::ListUseCasesAsyncHelper(const ListUseCasesRequest& request, const ListUseCasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2666 {
2667 handler(this, request, ListUseCases(request), context);
2668 }
2669
ListUserHierarchyGroups(const ListUserHierarchyGroupsRequest & request) const2670 ListUserHierarchyGroupsOutcome ConnectClient::ListUserHierarchyGroups(const ListUserHierarchyGroupsRequest& request) const
2671 {
2672 if (!request.InstanceIdHasBeenSet())
2673 {
2674 AWS_LOGSTREAM_ERROR("ListUserHierarchyGroups", "Required field: InstanceId, is not set");
2675 return ListUserHierarchyGroupsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2676 }
2677 Aws::Http::URI uri = m_uri;
2678 uri.AddPathSegments("/user-hierarchy-groups-summary/");
2679 uri.AddPathSegment(request.GetInstanceId());
2680 return ListUserHierarchyGroupsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2681 }
2682
ListUserHierarchyGroupsCallable(const ListUserHierarchyGroupsRequest & request) const2683 ListUserHierarchyGroupsOutcomeCallable ConnectClient::ListUserHierarchyGroupsCallable(const ListUserHierarchyGroupsRequest& request) const
2684 {
2685 auto task = Aws::MakeShared< std::packaged_task< ListUserHierarchyGroupsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListUserHierarchyGroups(request); } );
2686 auto packagedFunction = [task]() { (*task)(); };
2687 m_executor->Submit(packagedFunction);
2688 return task->get_future();
2689 }
2690
ListUserHierarchyGroupsAsync(const ListUserHierarchyGroupsRequest & request,const ListUserHierarchyGroupsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2691 void ConnectClient::ListUserHierarchyGroupsAsync(const ListUserHierarchyGroupsRequest& request, const ListUserHierarchyGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2692 {
2693 m_executor->Submit( [this, request, handler, context](){ this->ListUserHierarchyGroupsAsyncHelper( request, handler, context ); } );
2694 }
2695
ListUserHierarchyGroupsAsyncHelper(const ListUserHierarchyGroupsRequest & request,const ListUserHierarchyGroupsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2696 void ConnectClient::ListUserHierarchyGroupsAsyncHelper(const ListUserHierarchyGroupsRequest& request, const ListUserHierarchyGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2697 {
2698 handler(this, request, ListUserHierarchyGroups(request), context);
2699 }
2700
ListUsers(const ListUsersRequest & request) const2701 ListUsersOutcome ConnectClient::ListUsers(const ListUsersRequest& request) const
2702 {
2703 if (!request.InstanceIdHasBeenSet())
2704 {
2705 AWS_LOGSTREAM_ERROR("ListUsers", "Required field: InstanceId, is not set");
2706 return ListUsersOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
2707 }
2708 Aws::Http::URI uri = m_uri;
2709 uri.AddPathSegments("/users-summary/");
2710 uri.AddPathSegment(request.GetInstanceId());
2711 return ListUsersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2712 }
2713
ListUsersCallable(const ListUsersRequest & request) const2714 ListUsersOutcomeCallable ConnectClient::ListUsersCallable(const ListUsersRequest& request) const
2715 {
2716 auto task = Aws::MakeShared< std::packaged_task< ListUsersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListUsers(request); } );
2717 auto packagedFunction = [task]() { (*task)(); };
2718 m_executor->Submit(packagedFunction);
2719 return task->get_future();
2720 }
2721
ListUsersAsync(const ListUsersRequest & request,const ListUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2722 void ConnectClient::ListUsersAsync(const ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2723 {
2724 m_executor->Submit( [this, request, handler, context](){ this->ListUsersAsyncHelper( request, handler, context ); } );
2725 }
2726
ListUsersAsyncHelper(const ListUsersRequest & request,const ListUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2727 void ConnectClient::ListUsersAsyncHelper(const ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2728 {
2729 handler(this, request, ListUsers(request), context);
2730 }
2731
ResumeContactRecording(const ResumeContactRecordingRequest & request) const2732 ResumeContactRecordingOutcome ConnectClient::ResumeContactRecording(const ResumeContactRecordingRequest& request) const
2733 {
2734 Aws::Http::URI uri = m_uri;
2735 uri.AddPathSegments("/contact/resume-recording");
2736 return ResumeContactRecordingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2737 }
2738
ResumeContactRecordingCallable(const ResumeContactRecordingRequest & request) const2739 ResumeContactRecordingOutcomeCallable ConnectClient::ResumeContactRecordingCallable(const ResumeContactRecordingRequest& request) const
2740 {
2741 auto task = Aws::MakeShared< std::packaged_task< ResumeContactRecordingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ResumeContactRecording(request); } );
2742 auto packagedFunction = [task]() { (*task)(); };
2743 m_executor->Submit(packagedFunction);
2744 return task->get_future();
2745 }
2746
ResumeContactRecordingAsync(const ResumeContactRecordingRequest & request,const ResumeContactRecordingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2747 void ConnectClient::ResumeContactRecordingAsync(const ResumeContactRecordingRequest& request, const ResumeContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2748 {
2749 m_executor->Submit( [this, request, handler, context](){ this->ResumeContactRecordingAsyncHelper( request, handler, context ); } );
2750 }
2751
ResumeContactRecordingAsyncHelper(const ResumeContactRecordingRequest & request,const ResumeContactRecordingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2752 void ConnectClient::ResumeContactRecordingAsyncHelper(const ResumeContactRecordingRequest& request, const ResumeContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2753 {
2754 handler(this, request, ResumeContactRecording(request), context);
2755 }
2756
StartChatContact(const StartChatContactRequest & request) const2757 StartChatContactOutcome ConnectClient::StartChatContact(const StartChatContactRequest& request) const
2758 {
2759 Aws::Http::URI uri = m_uri;
2760 uri.AddPathSegments("/contact/chat");
2761 return StartChatContactOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
2762 }
2763
StartChatContactCallable(const StartChatContactRequest & request) const2764 StartChatContactOutcomeCallable ConnectClient::StartChatContactCallable(const StartChatContactRequest& request) const
2765 {
2766 auto task = Aws::MakeShared< std::packaged_task< StartChatContactOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartChatContact(request); } );
2767 auto packagedFunction = [task]() { (*task)(); };
2768 m_executor->Submit(packagedFunction);
2769 return task->get_future();
2770 }
2771
StartChatContactAsync(const StartChatContactRequest & request,const StartChatContactResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2772 void ConnectClient::StartChatContactAsync(const StartChatContactRequest& request, const StartChatContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2773 {
2774 m_executor->Submit( [this, request, handler, context](){ this->StartChatContactAsyncHelper( request, handler, context ); } );
2775 }
2776
StartChatContactAsyncHelper(const StartChatContactRequest & request,const StartChatContactResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2777 void ConnectClient::StartChatContactAsyncHelper(const StartChatContactRequest& request, const StartChatContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2778 {
2779 handler(this, request, StartChatContact(request), context);
2780 }
2781
StartContactRecording(const StartContactRecordingRequest & request) const2782 StartContactRecordingOutcome ConnectClient::StartContactRecording(const StartContactRecordingRequest& request) const
2783 {
2784 Aws::Http::URI uri = m_uri;
2785 uri.AddPathSegments("/contact/start-recording");
2786 return StartContactRecordingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2787 }
2788
StartContactRecordingCallable(const StartContactRecordingRequest & request) const2789 StartContactRecordingOutcomeCallable ConnectClient::StartContactRecordingCallable(const StartContactRecordingRequest& request) const
2790 {
2791 auto task = Aws::MakeShared< std::packaged_task< StartContactRecordingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartContactRecording(request); } );
2792 auto packagedFunction = [task]() { (*task)(); };
2793 m_executor->Submit(packagedFunction);
2794 return task->get_future();
2795 }
2796
StartContactRecordingAsync(const StartContactRecordingRequest & request,const StartContactRecordingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2797 void ConnectClient::StartContactRecordingAsync(const StartContactRecordingRequest& request, const StartContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2798 {
2799 m_executor->Submit( [this, request, handler, context](){ this->StartContactRecordingAsyncHelper( request, handler, context ); } );
2800 }
2801
StartContactRecordingAsyncHelper(const StartContactRecordingRequest & request,const StartContactRecordingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2802 void ConnectClient::StartContactRecordingAsyncHelper(const StartContactRecordingRequest& request, const StartContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2803 {
2804 handler(this, request, StartContactRecording(request), context);
2805 }
2806
StartOutboundVoiceContact(const StartOutboundVoiceContactRequest & request) const2807 StartOutboundVoiceContactOutcome ConnectClient::StartOutboundVoiceContact(const StartOutboundVoiceContactRequest& request) const
2808 {
2809 Aws::Http::URI uri = m_uri;
2810 uri.AddPathSegments("/contact/outbound-voice");
2811 return StartOutboundVoiceContactOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
2812 }
2813
StartOutboundVoiceContactCallable(const StartOutboundVoiceContactRequest & request) const2814 StartOutboundVoiceContactOutcomeCallable ConnectClient::StartOutboundVoiceContactCallable(const StartOutboundVoiceContactRequest& request) const
2815 {
2816 auto task = Aws::MakeShared< std::packaged_task< StartOutboundVoiceContactOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartOutboundVoiceContact(request); } );
2817 auto packagedFunction = [task]() { (*task)(); };
2818 m_executor->Submit(packagedFunction);
2819 return task->get_future();
2820 }
2821
StartOutboundVoiceContactAsync(const StartOutboundVoiceContactRequest & request,const StartOutboundVoiceContactResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2822 void ConnectClient::StartOutboundVoiceContactAsync(const StartOutboundVoiceContactRequest& request, const StartOutboundVoiceContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2823 {
2824 m_executor->Submit( [this, request, handler, context](){ this->StartOutboundVoiceContactAsyncHelper( request, handler, context ); } );
2825 }
2826
StartOutboundVoiceContactAsyncHelper(const StartOutboundVoiceContactRequest & request,const StartOutboundVoiceContactResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2827 void ConnectClient::StartOutboundVoiceContactAsyncHelper(const StartOutboundVoiceContactRequest& request, const StartOutboundVoiceContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2828 {
2829 handler(this, request, StartOutboundVoiceContact(request), context);
2830 }
2831
StartTaskContact(const StartTaskContactRequest & request) const2832 StartTaskContactOutcome ConnectClient::StartTaskContact(const StartTaskContactRequest& request) const
2833 {
2834 Aws::Http::URI uri = m_uri;
2835 uri.AddPathSegments("/contact/task");
2836 return StartTaskContactOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
2837 }
2838
StartTaskContactCallable(const StartTaskContactRequest & request) const2839 StartTaskContactOutcomeCallable ConnectClient::StartTaskContactCallable(const StartTaskContactRequest& request) const
2840 {
2841 auto task = Aws::MakeShared< std::packaged_task< StartTaskContactOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartTaskContact(request); } );
2842 auto packagedFunction = [task]() { (*task)(); };
2843 m_executor->Submit(packagedFunction);
2844 return task->get_future();
2845 }
2846
StartTaskContactAsync(const StartTaskContactRequest & request,const StartTaskContactResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2847 void ConnectClient::StartTaskContactAsync(const StartTaskContactRequest& request, const StartTaskContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2848 {
2849 m_executor->Submit( [this, request, handler, context](){ this->StartTaskContactAsyncHelper( request, handler, context ); } );
2850 }
2851
StartTaskContactAsyncHelper(const StartTaskContactRequest & request,const StartTaskContactResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2852 void ConnectClient::StartTaskContactAsyncHelper(const StartTaskContactRequest& request, const StartTaskContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2853 {
2854 handler(this, request, StartTaskContact(request), context);
2855 }
2856
StopContact(const StopContactRequest & request) const2857 StopContactOutcome ConnectClient::StopContact(const StopContactRequest& request) const
2858 {
2859 Aws::Http::URI uri = m_uri;
2860 uri.AddPathSegments("/contact/stop");
2861 return StopContactOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2862 }
2863
StopContactCallable(const StopContactRequest & request) const2864 StopContactOutcomeCallable ConnectClient::StopContactCallable(const StopContactRequest& request) const
2865 {
2866 auto task = Aws::MakeShared< std::packaged_task< StopContactOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopContact(request); } );
2867 auto packagedFunction = [task]() { (*task)(); };
2868 m_executor->Submit(packagedFunction);
2869 return task->get_future();
2870 }
2871
StopContactAsync(const StopContactRequest & request,const StopContactResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2872 void ConnectClient::StopContactAsync(const StopContactRequest& request, const StopContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2873 {
2874 m_executor->Submit( [this, request, handler, context](){ this->StopContactAsyncHelper( request, handler, context ); } );
2875 }
2876
StopContactAsyncHelper(const StopContactRequest & request,const StopContactResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2877 void ConnectClient::StopContactAsyncHelper(const StopContactRequest& request, const StopContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2878 {
2879 handler(this, request, StopContact(request), context);
2880 }
2881
StopContactRecording(const StopContactRecordingRequest & request) const2882 StopContactRecordingOutcome ConnectClient::StopContactRecording(const StopContactRecordingRequest& request) const
2883 {
2884 Aws::Http::URI uri = m_uri;
2885 uri.AddPathSegments("/contact/stop-recording");
2886 return StopContactRecordingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2887 }
2888
StopContactRecordingCallable(const StopContactRecordingRequest & request) const2889 StopContactRecordingOutcomeCallable ConnectClient::StopContactRecordingCallable(const StopContactRecordingRequest& request) const
2890 {
2891 auto task = Aws::MakeShared< std::packaged_task< StopContactRecordingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopContactRecording(request); } );
2892 auto packagedFunction = [task]() { (*task)(); };
2893 m_executor->Submit(packagedFunction);
2894 return task->get_future();
2895 }
2896
StopContactRecordingAsync(const StopContactRecordingRequest & request,const StopContactRecordingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2897 void ConnectClient::StopContactRecordingAsync(const StopContactRecordingRequest& request, const StopContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2898 {
2899 m_executor->Submit( [this, request, handler, context](){ this->StopContactRecordingAsyncHelper( request, handler, context ); } );
2900 }
2901
StopContactRecordingAsyncHelper(const StopContactRecordingRequest & request,const StopContactRecordingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2902 void ConnectClient::StopContactRecordingAsyncHelper(const StopContactRecordingRequest& request, const StopContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2903 {
2904 handler(this, request, StopContactRecording(request), context);
2905 }
2906
SuspendContactRecording(const SuspendContactRecordingRequest & request) const2907 SuspendContactRecordingOutcome ConnectClient::SuspendContactRecording(const SuspendContactRecordingRequest& request) const
2908 {
2909 Aws::Http::URI uri = m_uri;
2910 uri.AddPathSegments("/contact/suspend-recording");
2911 return SuspendContactRecordingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2912 }
2913
SuspendContactRecordingCallable(const SuspendContactRecordingRequest & request) const2914 SuspendContactRecordingOutcomeCallable ConnectClient::SuspendContactRecordingCallable(const SuspendContactRecordingRequest& request) const
2915 {
2916 auto task = Aws::MakeShared< std::packaged_task< SuspendContactRecordingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SuspendContactRecording(request); } );
2917 auto packagedFunction = [task]() { (*task)(); };
2918 m_executor->Submit(packagedFunction);
2919 return task->get_future();
2920 }
2921
SuspendContactRecordingAsync(const SuspendContactRecordingRequest & request,const SuspendContactRecordingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2922 void ConnectClient::SuspendContactRecordingAsync(const SuspendContactRecordingRequest& request, const SuspendContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2923 {
2924 m_executor->Submit( [this, request, handler, context](){ this->SuspendContactRecordingAsyncHelper( request, handler, context ); } );
2925 }
2926
SuspendContactRecordingAsyncHelper(const SuspendContactRecordingRequest & request,const SuspendContactRecordingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2927 void ConnectClient::SuspendContactRecordingAsyncHelper(const SuspendContactRecordingRequest& request, const SuspendContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2928 {
2929 handler(this, request, SuspendContactRecording(request), context);
2930 }
2931
TagResource(const TagResourceRequest & request) const2932 TagResourceOutcome ConnectClient::TagResource(const TagResourceRequest& request) const
2933 {
2934 if (!request.ResourceArnHasBeenSet())
2935 {
2936 AWS_LOGSTREAM_ERROR("TagResource", "Required field: ResourceArn, is not set");
2937 return TagResourceOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
2938 }
2939 Aws::Http::URI uri = m_uri;
2940 uri.AddPathSegments("/tags/");
2941 uri.AddPathSegment(request.GetResourceArn());
2942 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2943 }
2944
TagResourceCallable(const TagResourceRequest & request) const2945 TagResourceOutcomeCallable ConnectClient::TagResourceCallable(const TagResourceRequest& request) const
2946 {
2947 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
2948 auto packagedFunction = [task]() { (*task)(); };
2949 m_executor->Submit(packagedFunction);
2950 return task->get_future();
2951 }
2952
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2953 void ConnectClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2954 {
2955 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
2956 }
2957
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2958 void ConnectClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2959 {
2960 handler(this, request, TagResource(request), context);
2961 }
2962
UntagResource(const UntagResourceRequest & request) const2963 UntagResourceOutcome ConnectClient::UntagResource(const UntagResourceRequest& request) const
2964 {
2965 if (!request.ResourceArnHasBeenSet())
2966 {
2967 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: ResourceArn, is not set");
2968 return UntagResourceOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
2969 }
2970 if (!request.TagKeysHasBeenSet())
2971 {
2972 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: TagKeys, is not set");
2973 return UntagResourceOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TagKeys]", false));
2974 }
2975 Aws::Http::URI uri = m_uri;
2976 uri.AddPathSegments("/tags/");
2977 uri.AddPathSegment(request.GetResourceArn());
2978 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2979 }
2980
UntagResourceCallable(const UntagResourceRequest & request) const2981 UntagResourceOutcomeCallable ConnectClient::UntagResourceCallable(const UntagResourceRequest& request) const
2982 {
2983 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
2984 auto packagedFunction = [task]() { (*task)(); };
2985 m_executor->Submit(packagedFunction);
2986 return task->get_future();
2987 }
2988
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2989 void ConnectClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2990 {
2991 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
2992 }
2993
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2994 void ConnectClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2995 {
2996 handler(this, request, UntagResource(request), context);
2997 }
2998
UpdateAgentStatus(const UpdateAgentStatusRequest & request) const2999 UpdateAgentStatusOutcome ConnectClient::UpdateAgentStatus(const UpdateAgentStatusRequest& request) const
3000 {
3001 if (!request.InstanceIdHasBeenSet())
3002 {
3003 AWS_LOGSTREAM_ERROR("UpdateAgentStatus", "Required field: InstanceId, is not set");
3004 return UpdateAgentStatusOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3005 }
3006 if (!request.AgentStatusIdHasBeenSet())
3007 {
3008 AWS_LOGSTREAM_ERROR("UpdateAgentStatus", "Required field: AgentStatusId, is not set");
3009 return UpdateAgentStatusOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AgentStatusId]", false));
3010 }
3011 Aws::Http::URI uri = m_uri;
3012 uri.AddPathSegments("/agent-status/");
3013 uri.AddPathSegment(request.GetInstanceId());
3014 uri.AddPathSegment(request.GetAgentStatusId());
3015 return UpdateAgentStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3016 }
3017
UpdateAgentStatusCallable(const UpdateAgentStatusRequest & request) const3018 UpdateAgentStatusOutcomeCallable ConnectClient::UpdateAgentStatusCallable(const UpdateAgentStatusRequest& request) const
3019 {
3020 auto task = Aws::MakeShared< std::packaged_task< UpdateAgentStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAgentStatus(request); } );
3021 auto packagedFunction = [task]() { (*task)(); };
3022 m_executor->Submit(packagedFunction);
3023 return task->get_future();
3024 }
3025
UpdateAgentStatusAsync(const UpdateAgentStatusRequest & request,const UpdateAgentStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3026 void ConnectClient::UpdateAgentStatusAsync(const UpdateAgentStatusRequest& request, const UpdateAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3027 {
3028 m_executor->Submit( [this, request, handler, context](){ this->UpdateAgentStatusAsyncHelper( request, handler, context ); } );
3029 }
3030
UpdateAgentStatusAsyncHelper(const UpdateAgentStatusRequest & request,const UpdateAgentStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3031 void ConnectClient::UpdateAgentStatusAsyncHelper(const UpdateAgentStatusRequest& request, const UpdateAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3032 {
3033 handler(this, request, UpdateAgentStatus(request), context);
3034 }
3035
UpdateContactAttributes(const UpdateContactAttributesRequest & request) const3036 UpdateContactAttributesOutcome ConnectClient::UpdateContactAttributes(const UpdateContactAttributesRequest& request) const
3037 {
3038 Aws::Http::URI uri = m_uri;
3039 uri.AddPathSegments("/contact/attributes");
3040 return UpdateContactAttributesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3041 }
3042
UpdateContactAttributesCallable(const UpdateContactAttributesRequest & request) const3043 UpdateContactAttributesOutcomeCallable ConnectClient::UpdateContactAttributesCallable(const UpdateContactAttributesRequest& request) const
3044 {
3045 auto task = Aws::MakeShared< std::packaged_task< UpdateContactAttributesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateContactAttributes(request); } );
3046 auto packagedFunction = [task]() { (*task)(); };
3047 m_executor->Submit(packagedFunction);
3048 return task->get_future();
3049 }
3050
UpdateContactAttributesAsync(const UpdateContactAttributesRequest & request,const UpdateContactAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3051 void ConnectClient::UpdateContactAttributesAsync(const UpdateContactAttributesRequest& request, const UpdateContactAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3052 {
3053 m_executor->Submit( [this, request, handler, context](){ this->UpdateContactAttributesAsyncHelper( request, handler, context ); } );
3054 }
3055
UpdateContactAttributesAsyncHelper(const UpdateContactAttributesRequest & request,const UpdateContactAttributesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3056 void ConnectClient::UpdateContactAttributesAsyncHelper(const UpdateContactAttributesRequest& request, const UpdateContactAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3057 {
3058 handler(this, request, UpdateContactAttributes(request), context);
3059 }
3060
UpdateContactFlowContent(const UpdateContactFlowContentRequest & request) const3061 UpdateContactFlowContentOutcome ConnectClient::UpdateContactFlowContent(const UpdateContactFlowContentRequest& request) const
3062 {
3063 if (!request.InstanceIdHasBeenSet())
3064 {
3065 AWS_LOGSTREAM_ERROR("UpdateContactFlowContent", "Required field: InstanceId, is not set");
3066 return UpdateContactFlowContentOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3067 }
3068 if (!request.ContactFlowIdHasBeenSet())
3069 {
3070 AWS_LOGSTREAM_ERROR("UpdateContactFlowContent", "Required field: ContactFlowId, is not set");
3071 return UpdateContactFlowContentOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ContactFlowId]", false));
3072 }
3073 Aws::Http::URI uri = m_uri;
3074 uri.AddPathSegments("/contact-flows/");
3075 uri.AddPathSegment(request.GetInstanceId());
3076 uri.AddPathSegment(request.GetContactFlowId());
3077 uri.AddPathSegments("/content");
3078 return UpdateContactFlowContentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3079 }
3080
UpdateContactFlowContentCallable(const UpdateContactFlowContentRequest & request) const3081 UpdateContactFlowContentOutcomeCallable ConnectClient::UpdateContactFlowContentCallable(const UpdateContactFlowContentRequest& request) const
3082 {
3083 auto task = Aws::MakeShared< std::packaged_task< UpdateContactFlowContentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateContactFlowContent(request); } );
3084 auto packagedFunction = [task]() { (*task)(); };
3085 m_executor->Submit(packagedFunction);
3086 return task->get_future();
3087 }
3088
UpdateContactFlowContentAsync(const UpdateContactFlowContentRequest & request,const UpdateContactFlowContentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3089 void ConnectClient::UpdateContactFlowContentAsync(const UpdateContactFlowContentRequest& request, const UpdateContactFlowContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3090 {
3091 m_executor->Submit( [this, request, handler, context](){ this->UpdateContactFlowContentAsyncHelper( request, handler, context ); } );
3092 }
3093
UpdateContactFlowContentAsyncHelper(const UpdateContactFlowContentRequest & request,const UpdateContactFlowContentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3094 void ConnectClient::UpdateContactFlowContentAsyncHelper(const UpdateContactFlowContentRequest& request, const UpdateContactFlowContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3095 {
3096 handler(this, request, UpdateContactFlowContent(request), context);
3097 }
3098
UpdateContactFlowName(const UpdateContactFlowNameRequest & request) const3099 UpdateContactFlowNameOutcome ConnectClient::UpdateContactFlowName(const UpdateContactFlowNameRequest& request) const
3100 {
3101 if (!request.InstanceIdHasBeenSet())
3102 {
3103 AWS_LOGSTREAM_ERROR("UpdateContactFlowName", "Required field: InstanceId, is not set");
3104 return UpdateContactFlowNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3105 }
3106 if (!request.ContactFlowIdHasBeenSet())
3107 {
3108 AWS_LOGSTREAM_ERROR("UpdateContactFlowName", "Required field: ContactFlowId, is not set");
3109 return UpdateContactFlowNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ContactFlowId]", false));
3110 }
3111 Aws::Http::URI uri = m_uri;
3112 uri.AddPathSegments("/contact-flows/");
3113 uri.AddPathSegment(request.GetInstanceId());
3114 uri.AddPathSegment(request.GetContactFlowId());
3115 uri.AddPathSegments("/name");
3116 return UpdateContactFlowNameOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3117 }
3118
UpdateContactFlowNameCallable(const UpdateContactFlowNameRequest & request) const3119 UpdateContactFlowNameOutcomeCallable ConnectClient::UpdateContactFlowNameCallable(const UpdateContactFlowNameRequest& request) const
3120 {
3121 auto task = Aws::MakeShared< std::packaged_task< UpdateContactFlowNameOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateContactFlowName(request); } );
3122 auto packagedFunction = [task]() { (*task)(); };
3123 m_executor->Submit(packagedFunction);
3124 return task->get_future();
3125 }
3126
UpdateContactFlowNameAsync(const UpdateContactFlowNameRequest & request,const UpdateContactFlowNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3127 void ConnectClient::UpdateContactFlowNameAsync(const UpdateContactFlowNameRequest& request, const UpdateContactFlowNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3128 {
3129 m_executor->Submit( [this, request, handler, context](){ this->UpdateContactFlowNameAsyncHelper( request, handler, context ); } );
3130 }
3131
UpdateContactFlowNameAsyncHelper(const UpdateContactFlowNameRequest & request,const UpdateContactFlowNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3132 void ConnectClient::UpdateContactFlowNameAsyncHelper(const UpdateContactFlowNameRequest& request, const UpdateContactFlowNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3133 {
3134 handler(this, request, UpdateContactFlowName(request), context);
3135 }
3136
UpdateHoursOfOperation(const UpdateHoursOfOperationRequest & request) const3137 UpdateHoursOfOperationOutcome ConnectClient::UpdateHoursOfOperation(const UpdateHoursOfOperationRequest& request) const
3138 {
3139 if (!request.InstanceIdHasBeenSet())
3140 {
3141 AWS_LOGSTREAM_ERROR("UpdateHoursOfOperation", "Required field: InstanceId, is not set");
3142 return UpdateHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3143 }
3144 if (!request.HoursOfOperationIdHasBeenSet())
3145 {
3146 AWS_LOGSTREAM_ERROR("UpdateHoursOfOperation", "Required field: HoursOfOperationId, is not set");
3147 return UpdateHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [HoursOfOperationId]", false));
3148 }
3149 Aws::Http::URI uri = m_uri;
3150 uri.AddPathSegments("/hours-of-operations/");
3151 uri.AddPathSegment(request.GetInstanceId());
3152 uri.AddPathSegment(request.GetHoursOfOperationId());
3153 return UpdateHoursOfOperationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3154 }
3155
UpdateHoursOfOperationCallable(const UpdateHoursOfOperationRequest & request) const3156 UpdateHoursOfOperationOutcomeCallable ConnectClient::UpdateHoursOfOperationCallable(const UpdateHoursOfOperationRequest& request) const
3157 {
3158 auto task = Aws::MakeShared< std::packaged_task< UpdateHoursOfOperationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateHoursOfOperation(request); } );
3159 auto packagedFunction = [task]() { (*task)(); };
3160 m_executor->Submit(packagedFunction);
3161 return task->get_future();
3162 }
3163
UpdateHoursOfOperationAsync(const UpdateHoursOfOperationRequest & request,const UpdateHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3164 void ConnectClient::UpdateHoursOfOperationAsync(const UpdateHoursOfOperationRequest& request, const UpdateHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3165 {
3166 m_executor->Submit( [this, request, handler, context](){ this->UpdateHoursOfOperationAsyncHelper( request, handler, context ); } );
3167 }
3168
UpdateHoursOfOperationAsyncHelper(const UpdateHoursOfOperationRequest & request,const UpdateHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3169 void ConnectClient::UpdateHoursOfOperationAsyncHelper(const UpdateHoursOfOperationRequest& request, const UpdateHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3170 {
3171 handler(this, request, UpdateHoursOfOperation(request), context);
3172 }
3173
UpdateInstanceAttribute(const UpdateInstanceAttributeRequest & request) const3174 UpdateInstanceAttributeOutcome ConnectClient::UpdateInstanceAttribute(const UpdateInstanceAttributeRequest& request) const
3175 {
3176 if (!request.InstanceIdHasBeenSet())
3177 {
3178 AWS_LOGSTREAM_ERROR("UpdateInstanceAttribute", "Required field: InstanceId, is not set");
3179 return UpdateInstanceAttributeOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3180 }
3181 if (!request.AttributeTypeHasBeenSet())
3182 {
3183 AWS_LOGSTREAM_ERROR("UpdateInstanceAttribute", "Required field: AttributeType, is not set");
3184 return UpdateInstanceAttributeOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AttributeType]", false));
3185 }
3186 Aws::Http::URI uri = m_uri;
3187 uri.AddPathSegments("/instance/");
3188 uri.AddPathSegment(request.GetInstanceId());
3189 uri.AddPathSegments("/attribute/");
3190 uri.AddPathSegment(InstanceAttributeTypeMapper::GetNameForInstanceAttributeType(request.GetAttributeType()));
3191 return UpdateInstanceAttributeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3192 }
3193
UpdateInstanceAttributeCallable(const UpdateInstanceAttributeRequest & request) const3194 UpdateInstanceAttributeOutcomeCallable ConnectClient::UpdateInstanceAttributeCallable(const UpdateInstanceAttributeRequest& request) const
3195 {
3196 auto task = Aws::MakeShared< std::packaged_task< UpdateInstanceAttributeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateInstanceAttribute(request); } );
3197 auto packagedFunction = [task]() { (*task)(); };
3198 m_executor->Submit(packagedFunction);
3199 return task->get_future();
3200 }
3201
UpdateInstanceAttributeAsync(const UpdateInstanceAttributeRequest & request,const UpdateInstanceAttributeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3202 void ConnectClient::UpdateInstanceAttributeAsync(const UpdateInstanceAttributeRequest& request, const UpdateInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3203 {
3204 m_executor->Submit( [this, request, handler, context](){ this->UpdateInstanceAttributeAsyncHelper( request, handler, context ); } );
3205 }
3206
UpdateInstanceAttributeAsyncHelper(const UpdateInstanceAttributeRequest & request,const UpdateInstanceAttributeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3207 void ConnectClient::UpdateInstanceAttributeAsyncHelper(const UpdateInstanceAttributeRequest& request, const UpdateInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3208 {
3209 handler(this, request, UpdateInstanceAttribute(request), context);
3210 }
3211
UpdateInstanceStorageConfig(const UpdateInstanceStorageConfigRequest & request) const3212 UpdateInstanceStorageConfigOutcome ConnectClient::UpdateInstanceStorageConfig(const UpdateInstanceStorageConfigRequest& request) const
3213 {
3214 if (!request.InstanceIdHasBeenSet())
3215 {
3216 AWS_LOGSTREAM_ERROR("UpdateInstanceStorageConfig", "Required field: InstanceId, is not set");
3217 return UpdateInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3218 }
3219 if (!request.AssociationIdHasBeenSet())
3220 {
3221 AWS_LOGSTREAM_ERROR("UpdateInstanceStorageConfig", "Required field: AssociationId, is not set");
3222 return UpdateInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AssociationId]", false));
3223 }
3224 if (!request.ResourceTypeHasBeenSet())
3225 {
3226 AWS_LOGSTREAM_ERROR("UpdateInstanceStorageConfig", "Required field: ResourceType, is not set");
3227 return UpdateInstanceStorageConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceType]", false));
3228 }
3229 Aws::Http::URI uri = m_uri;
3230 uri.AddPathSegments("/instance/");
3231 uri.AddPathSegment(request.GetInstanceId());
3232 uri.AddPathSegments("/storage-config/");
3233 uri.AddPathSegment(request.GetAssociationId());
3234 return UpdateInstanceStorageConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3235 }
3236
UpdateInstanceStorageConfigCallable(const UpdateInstanceStorageConfigRequest & request) const3237 UpdateInstanceStorageConfigOutcomeCallable ConnectClient::UpdateInstanceStorageConfigCallable(const UpdateInstanceStorageConfigRequest& request) const
3238 {
3239 auto task = Aws::MakeShared< std::packaged_task< UpdateInstanceStorageConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateInstanceStorageConfig(request); } );
3240 auto packagedFunction = [task]() { (*task)(); };
3241 m_executor->Submit(packagedFunction);
3242 return task->get_future();
3243 }
3244
UpdateInstanceStorageConfigAsync(const UpdateInstanceStorageConfigRequest & request,const UpdateInstanceStorageConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3245 void ConnectClient::UpdateInstanceStorageConfigAsync(const UpdateInstanceStorageConfigRequest& request, const UpdateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3246 {
3247 m_executor->Submit( [this, request, handler, context](){ this->UpdateInstanceStorageConfigAsyncHelper( request, handler, context ); } );
3248 }
3249
UpdateInstanceStorageConfigAsyncHelper(const UpdateInstanceStorageConfigRequest & request,const UpdateInstanceStorageConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3250 void ConnectClient::UpdateInstanceStorageConfigAsyncHelper(const UpdateInstanceStorageConfigRequest& request, const UpdateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3251 {
3252 handler(this, request, UpdateInstanceStorageConfig(request), context);
3253 }
3254
UpdateQueueHoursOfOperation(const UpdateQueueHoursOfOperationRequest & request) const3255 UpdateQueueHoursOfOperationOutcome ConnectClient::UpdateQueueHoursOfOperation(const UpdateQueueHoursOfOperationRequest& request) const
3256 {
3257 if (!request.InstanceIdHasBeenSet())
3258 {
3259 AWS_LOGSTREAM_ERROR("UpdateQueueHoursOfOperation", "Required field: InstanceId, is not set");
3260 return UpdateQueueHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3261 }
3262 if (!request.QueueIdHasBeenSet())
3263 {
3264 AWS_LOGSTREAM_ERROR("UpdateQueueHoursOfOperation", "Required field: QueueId, is not set");
3265 return UpdateQueueHoursOfOperationOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
3266 }
3267 Aws::Http::URI uri = m_uri;
3268 uri.AddPathSegments("/queues/");
3269 uri.AddPathSegment(request.GetInstanceId());
3270 uri.AddPathSegment(request.GetQueueId());
3271 uri.AddPathSegments("/hours-of-operation");
3272 return UpdateQueueHoursOfOperationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3273 }
3274
UpdateQueueHoursOfOperationCallable(const UpdateQueueHoursOfOperationRequest & request) const3275 UpdateQueueHoursOfOperationOutcomeCallable ConnectClient::UpdateQueueHoursOfOperationCallable(const UpdateQueueHoursOfOperationRequest& request) const
3276 {
3277 auto task = Aws::MakeShared< std::packaged_task< UpdateQueueHoursOfOperationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateQueueHoursOfOperation(request); } );
3278 auto packagedFunction = [task]() { (*task)(); };
3279 m_executor->Submit(packagedFunction);
3280 return task->get_future();
3281 }
3282
UpdateQueueHoursOfOperationAsync(const UpdateQueueHoursOfOperationRequest & request,const UpdateQueueHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3283 void ConnectClient::UpdateQueueHoursOfOperationAsync(const UpdateQueueHoursOfOperationRequest& request, const UpdateQueueHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3284 {
3285 m_executor->Submit( [this, request, handler, context](){ this->UpdateQueueHoursOfOperationAsyncHelper( request, handler, context ); } );
3286 }
3287
UpdateQueueHoursOfOperationAsyncHelper(const UpdateQueueHoursOfOperationRequest & request,const UpdateQueueHoursOfOperationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3288 void ConnectClient::UpdateQueueHoursOfOperationAsyncHelper(const UpdateQueueHoursOfOperationRequest& request, const UpdateQueueHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3289 {
3290 handler(this, request, UpdateQueueHoursOfOperation(request), context);
3291 }
3292
UpdateQueueMaxContacts(const UpdateQueueMaxContactsRequest & request) const3293 UpdateQueueMaxContactsOutcome ConnectClient::UpdateQueueMaxContacts(const UpdateQueueMaxContactsRequest& request) const
3294 {
3295 if (!request.InstanceIdHasBeenSet())
3296 {
3297 AWS_LOGSTREAM_ERROR("UpdateQueueMaxContacts", "Required field: InstanceId, is not set");
3298 return UpdateQueueMaxContactsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3299 }
3300 if (!request.QueueIdHasBeenSet())
3301 {
3302 AWS_LOGSTREAM_ERROR("UpdateQueueMaxContacts", "Required field: QueueId, is not set");
3303 return UpdateQueueMaxContactsOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
3304 }
3305 Aws::Http::URI uri = m_uri;
3306 uri.AddPathSegments("/queues/");
3307 uri.AddPathSegment(request.GetInstanceId());
3308 uri.AddPathSegment(request.GetQueueId());
3309 uri.AddPathSegments("/max-contacts");
3310 return UpdateQueueMaxContactsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3311 }
3312
UpdateQueueMaxContactsCallable(const UpdateQueueMaxContactsRequest & request) const3313 UpdateQueueMaxContactsOutcomeCallable ConnectClient::UpdateQueueMaxContactsCallable(const UpdateQueueMaxContactsRequest& request) const
3314 {
3315 auto task = Aws::MakeShared< std::packaged_task< UpdateQueueMaxContactsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateQueueMaxContacts(request); } );
3316 auto packagedFunction = [task]() { (*task)(); };
3317 m_executor->Submit(packagedFunction);
3318 return task->get_future();
3319 }
3320
UpdateQueueMaxContactsAsync(const UpdateQueueMaxContactsRequest & request,const UpdateQueueMaxContactsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3321 void ConnectClient::UpdateQueueMaxContactsAsync(const UpdateQueueMaxContactsRequest& request, const UpdateQueueMaxContactsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3322 {
3323 m_executor->Submit( [this, request, handler, context](){ this->UpdateQueueMaxContactsAsyncHelper( request, handler, context ); } );
3324 }
3325
UpdateQueueMaxContactsAsyncHelper(const UpdateQueueMaxContactsRequest & request,const UpdateQueueMaxContactsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3326 void ConnectClient::UpdateQueueMaxContactsAsyncHelper(const UpdateQueueMaxContactsRequest& request, const UpdateQueueMaxContactsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3327 {
3328 handler(this, request, UpdateQueueMaxContacts(request), context);
3329 }
3330
UpdateQueueName(const UpdateQueueNameRequest & request) const3331 UpdateQueueNameOutcome ConnectClient::UpdateQueueName(const UpdateQueueNameRequest& request) const
3332 {
3333 if (!request.InstanceIdHasBeenSet())
3334 {
3335 AWS_LOGSTREAM_ERROR("UpdateQueueName", "Required field: InstanceId, is not set");
3336 return UpdateQueueNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3337 }
3338 if (!request.QueueIdHasBeenSet())
3339 {
3340 AWS_LOGSTREAM_ERROR("UpdateQueueName", "Required field: QueueId, is not set");
3341 return UpdateQueueNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
3342 }
3343 Aws::Http::URI uri = m_uri;
3344 uri.AddPathSegments("/queues/");
3345 uri.AddPathSegment(request.GetInstanceId());
3346 uri.AddPathSegment(request.GetQueueId());
3347 uri.AddPathSegments("/name");
3348 return UpdateQueueNameOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3349 }
3350
UpdateQueueNameCallable(const UpdateQueueNameRequest & request) const3351 UpdateQueueNameOutcomeCallable ConnectClient::UpdateQueueNameCallable(const UpdateQueueNameRequest& request) const
3352 {
3353 auto task = Aws::MakeShared< std::packaged_task< UpdateQueueNameOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateQueueName(request); } );
3354 auto packagedFunction = [task]() { (*task)(); };
3355 m_executor->Submit(packagedFunction);
3356 return task->get_future();
3357 }
3358
UpdateQueueNameAsync(const UpdateQueueNameRequest & request,const UpdateQueueNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3359 void ConnectClient::UpdateQueueNameAsync(const UpdateQueueNameRequest& request, const UpdateQueueNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3360 {
3361 m_executor->Submit( [this, request, handler, context](){ this->UpdateQueueNameAsyncHelper( request, handler, context ); } );
3362 }
3363
UpdateQueueNameAsyncHelper(const UpdateQueueNameRequest & request,const UpdateQueueNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3364 void ConnectClient::UpdateQueueNameAsyncHelper(const UpdateQueueNameRequest& request, const UpdateQueueNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3365 {
3366 handler(this, request, UpdateQueueName(request), context);
3367 }
3368
UpdateQueueOutboundCallerConfig(const UpdateQueueOutboundCallerConfigRequest & request) const3369 UpdateQueueOutboundCallerConfigOutcome ConnectClient::UpdateQueueOutboundCallerConfig(const UpdateQueueOutboundCallerConfigRequest& request) const
3370 {
3371 if (!request.InstanceIdHasBeenSet())
3372 {
3373 AWS_LOGSTREAM_ERROR("UpdateQueueOutboundCallerConfig", "Required field: InstanceId, is not set");
3374 return UpdateQueueOutboundCallerConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3375 }
3376 if (!request.QueueIdHasBeenSet())
3377 {
3378 AWS_LOGSTREAM_ERROR("UpdateQueueOutboundCallerConfig", "Required field: QueueId, is not set");
3379 return UpdateQueueOutboundCallerConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
3380 }
3381 Aws::Http::URI uri = m_uri;
3382 uri.AddPathSegments("/queues/");
3383 uri.AddPathSegment(request.GetInstanceId());
3384 uri.AddPathSegment(request.GetQueueId());
3385 uri.AddPathSegments("/outbound-caller-config");
3386 return UpdateQueueOutboundCallerConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3387 }
3388
UpdateQueueOutboundCallerConfigCallable(const UpdateQueueOutboundCallerConfigRequest & request) const3389 UpdateQueueOutboundCallerConfigOutcomeCallable ConnectClient::UpdateQueueOutboundCallerConfigCallable(const UpdateQueueOutboundCallerConfigRequest& request) const
3390 {
3391 auto task = Aws::MakeShared< std::packaged_task< UpdateQueueOutboundCallerConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateQueueOutboundCallerConfig(request); } );
3392 auto packagedFunction = [task]() { (*task)(); };
3393 m_executor->Submit(packagedFunction);
3394 return task->get_future();
3395 }
3396
UpdateQueueOutboundCallerConfigAsync(const UpdateQueueOutboundCallerConfigRequest & request,const UpdateQueueOutboundCallerConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3397 void ConnectClient::UpdateQueueOutboundCallerConfigAsync(const UpdateQueueOutboundCallerConfigRequest& request, const UpdateQueueOutboundCallerConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3398 {
3399 m_executor->Submit( [this, request, handler, context](){ this->UpdateQueueOutboundCallerConfigAsyncHelper( request, handler, context ); } );
3400 }
3401
UpdateQueueOutboundCallerConfigAsyncHelper(const UpdateQueueOutboundCallerConfigRequest & request,const UpdateQueueOutboundCallerConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3402 void ConnectClient::UpdateQueueOutboundCallerConfigAsyncHelper(const UpdateQueueOutboundCallerConfigRequest& request, const UpdateQueueOutboundCallerConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3403 {
3404 handler(this, request, UpdateQueueOutboundCallerConfig(request), context);
3405 }
3406
UpdateQueueStatus(const UpdateQueueStatusRequest & request) const3407 UpdateQueueStatusOutcome ConnectClient::UpdateQueueStatus(const UpdateQueueStatusRequest& request) const
3408 {
3409 if (!request.InstanceIdHasBeenSet())
3410 {
3411 AWS_LOGSTREAM_ERROR("UpdateQueueStatus", "Required field: InstanceId, is not set");
3412 return UpdateQueueStatusOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3413 }
3414 if (!request.QueueIdHasBeenSet())
3415 {
3416 AWS_LOGSTREAM_ERROR("UpdateQueueStatus", "Required field: QueueId, is not set");
3417 return UpdateQueueStatusOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QueueId]", false));
3418 }
3419 Aws::Http::URI uri = m_uri;
3420 uri.AddPathSegments("/queues/");
3421 uri.AddPathSegment(request.GetInstanceId());
3422 uri.AddPathSegment(request.GetQueueId());
3423 uri.AddPathSegments("/status");
3424 return UpdateQueueStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3425 }
3426
UpdateQueueStatusCallable(const UpdateQueueStatusRequest & request) const3427 UpdateQueueStatusOutcomeCallable ConnectClient::UpdateQueueStatusCallable(const UpdateQueueStatusRequest& request) const
3428 {
3429 auto task = Aws::MakeShared< std::packaged_task< UpdateQueueStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateQueueStatus(request); } );
3430 auto packagedFunction = [task]() { (*task)(); };
3431 m_executor->Submit(packagedFunction);
3432 return task->get_future();
3433 }
3434
UpdateQueueStatusAsync(const UpdateQueueStatusRequest & request,const UpdateQueueStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3435 void ConnectClient::UpdateQueueStatusAsync(const UpdateQueueStatusRequest& request, const UpdateQueueStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3436 {
3437 m_executor->Submit( [this, request, handler, context](){ this->UpdateQueueStatusAsyncHelper( request, handler, context ); } );
3438 }
3439
UpdateQueueStatusAsyncHelper(const UpdateQueueStatusRequest & request,const UpdateQueueStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3440 void ConnectClient::UpdateQueueStatusAsyncHelper(const UpdateQueueStatusRequest& request, const UpdateQueueStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3441 {
3442 handler(this, request, UpdateQueueStatus(request), context);
3443 }
3444
UpdateQuickConnectConfig(const UpdateQuickConnectConfigRequest & request) const3445 UpdateQuickConnectConfigOutcome ConnectClient::UpdateQuickConnectConfig(const UpdateQuickConnectConfigRequest& request) const
3446 {
3447 if (!request.InstanceIdHasBeenSet())
3448 {
3449 AWS_LOGSTREAM_ERROR("UpdateQuickConnectConfig", "Required field: InstanceId, is not set");
3450 return UpdateQuickConnectConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3451 }
3452 if (!request.QuickConnectIdHasBeenSet())
3453 {
3454 AWS_LOGSTREAM_ERROR("UpdateQuickConnectConfig", "Required field: QuickConnectId, is not set");
3455 return UpdateQuickConnectConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QuickConnectId]", false));
3456 }
3457 Aws::Http::URI uri = m_uri;
3458 uri.AddPathSegments("/quick-connects/");
3459 uri.AddPathSegment(request.GetInstanceId());
3460 uri.AddPathSegment(request.GetQuickConnectId());
3461 uri.AddPathSegments("/config");
3462 return UpdateQuickConnectConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3463 }
3464
UpdateQuickConnectConfigCallable(const UpdateQuickConnectConfigRequest & request) const3465 UpdateQuickConnectConfigOutcomeCallable ConnectClient::UpdateQuickConnectConfigCallable(const UpdateQuickConnectConfigRequest& request) const
3466 {
3467 auto task = Aws::MakeShared< std::packaged_task< UpdateQuickConnectConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateQuickConnectConfig(request); } );
3468 auto packagedFunction = [task]() { (*task)(); };
3469 m_executor->Submit(packagedFunction);
3470 return task->get_future();
3471 }
3472
UpdateQuickConnectConfigAsync(const UpdateQuickConnectConfigRequest & request,const UpdateQuickConnectConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3473 void ConnectClient::UpdateQuickConnectConfigAsync(const UpdateQuickConnectConfigRequest& request, const UpdateQuickConnectConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3474 {
3475 m_executor->Submit( [this, request, handler, context](){ this->UpdateQuickConnectConfigAsyncHelper( request, handler, context ); } );
3476 }
3477
UpdateQuickConnectConfigAsyncHelper(const UpdateQuickConnectConfigRequest & request,const UpdateQuickConnectConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3478 void ConnectClient::UpdateQuickConnectConfigAsyncHelper(const UpdateQuickConnectConfigRequest& request, const UpdateQuickConnectConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3479 {
3480 handler(this, request, UpdateQuickConnectConfig(request), context);
3481 }
3482
UpdateQuickConnectName(const UpdateQuickConnectNameRequest & request) const3483 UpdateQuickConnectNameOutcome ConnectClient::UpdateQuickConnectName(const UpdateQuickConnectNameRequest& request) const
3484 {
3485 if (!request.InstanceIdHasBeenSet())
3486 {
3487 AWS_LOGSTREAM_ERROR("UpdateQuickConnectName", "Required field: InstanceId, is not set");
3488 return UpdateQuickConnectNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3489 }
3490 if (!request.QuickConnectIdHasBeenSet())
3491 {
3492 AWS_LOGSTREAM_ERROR("UpdateQuickConnectName", "Required field: QuickConnectId, is not set");
3493 return UpdateQuickConnectNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [QuickConnectId]", false));
3494 }
3495 Aws::Http::URI uri = m_uri;
3496 uri.AddPathSegments("/quick-connects/");
3497 uri.AddPathSegment(request.GetInstanceId());
3498 uri.AddPathSegment(request.GetQuickConnectId());
3499 uri.AddPathSegments("/name");
3500 return UpdateQuickConnectNameOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3501 }
3502
UpdateQuickConnectNameCallable(const UpdateQuickConnectNameRequest & request) const3503 UpdateQuickConnectNameOutcomeCallable ConnectClient::UpdateQuickConnectNameCallable(const UpdateQuickConnectNameRequest& request) const
3504 {
3505 auto task = Aws::MakeShared< std::packaged_task< UpdateQuickConnectNameOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateQuickConnectName(request); } );
3506 auto packagedFunction = [task]() { (*task)(); };
3507 m_executor->Submit(packagedFunction);
3508 return task->get_future();
3509 }
3510
UpdateQuickConnectNameAsync(const UpdateQuickConnectNameRequest & request,const UpdateQuickConnectNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3511 void ConnectClient::UpdateQuickConnectNameAsync(const UpdateQuickConnectNameRequest& request, const UpdateQuickConnectNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3512 {
3513 m_executor->Submit( [this, request, handler, context](){ this->UpdateQuickConnectNameAsyncHelper( request, handler, context ); } );
3514 }
3515
UpdateQuickConnectNameAsyncHelper(const UpdateQuickConnectNameRequest & request,const UpdateQuickConnectNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3516 void ConnectClient::UpdateQuickConnectNameAsyncHelper(const UpdateQuickConnectNameRequest& request, const UpdateQuickConnectNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3517 {
3518 handler(this, request, UpdateQuickConnectName(request), context);
3519 }
3520
UpdateRoutingProfileConcurrency(const UpdateRoutingProfileConcurrencyRequest & request) const3521 UpdateRoutingProfileConcurrencyOutcome ConnectClient::UpdateRoutingProfileConcurrency(const UpdateRoutingProfileConcurrencyRequest& request) const
3522 {
3523 if (!request.InstanceIdHasBeenSet())
3524 {
3525 AWS_LOGSTREAM_ERROR("UpdateRoutingProfileConcurrency", "Required field: InstanceId, is not set");
3526 return UpdateRoutingProfileConcurrencyOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3527 }
3528 if (!request.RoutingProfileIdHasBeenSet())
3529 {
3530 AWS_LOGSTREAM_ERROR("UpdateRoutingProfileConcurrency", "Required field: RoutingProfileId, is not set");
3531 return UpdateRoutingProfileConcurrencyOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoutingProfileId]", false));
3532 }
3533 Aws::Http::URI uri = m_uri;
3534 uri.AddPathSegments("/routing-profiles/");
3535 uri.AddPathSegment(request.GetInstanceId());
3536 uri.AddPathSegment(request.GetRoutingProfileId());
3537 uri.AddPathSegments("/concurrency");
3538 return UpdateRoutingProfileConcurrencyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3539 }
3540
UpdateRoutingProfileConcurrencyCallable(const UpdateRoutingProfileConcurrencyRequest & request) const3541 UpdateRoutingProfileConcurrencyOutcomeCallable ConnectClient::UpdateRoutingProfileConcurrencyCallable(const UpdateRoutingProfileConcurrencyRequest& request) const
3542 {
3543 auto task = Aws::MakeShared< std::packaged_task< UpdateRoutingProfileConcurrencyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRoutingProfileConcurrency(request); } );
3544 auto packagedFunction = [task]() { (*task)(); };
3545 m_executor->Submit(packagedFunction);
3546 return task->get_future();
3547 }
3548
UpdateRoutingProfileConcurrencyAsync(const UpdateRoutingProfileConcurrencyRequest & request,const UpdateRoutingProfileConcurrencyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3549 void ConnectClient::UpdateRoutingProfileConcurrencyAsync(const UpdateRoutingProfileConcurrencyRequest& request, const UpdateRoutingProfileConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3550 {
3551 m_executor->Submit( [this, request, handler, context](){ this->UpdateRoutingProfileConcurrencyAsyncHelper( request, handler, context ); } );
3552 }
3553
UpdateRoutingProfileConcurrencyAsyncHelper(const UpdateRoutingProfileConcurrencyRequest & request,const UpdateRoutingProfileConcurrencyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3554 void ConnectClient::UpdateRoutingProfileConcurrencyAsyncHelper(const UpdateRoutingProfileConcurrencyRequest& request, const UpdateRoutingProfileConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3555 {
3556 handler(this, request, UpdateRoutingProfileConcurrency(request), context);
3557 }
3558
UpdateRoutingProfileDefaultOutboundQueue(const UpdateRoutingProfileDefaultOutboundQueueRequest & request) const3559 UpdateRoutingProfileDefaultOutboundQueueOutcome ConnectClient::UpdateRoutingProfileDefaultOutboundQueue(const UpdateRoutingProfileDefaultOutboundQueueRequest& request) const
3560 {
3561 if (!request.InstanceIdHasBeenSet())
3562 {
3563 AWS_LOGSTREAM_ERROR("UpdateRoutingProfileDefaultOutboundQueue", "Required field: InstanceId, is not set");
3564 return UpdateRoutingProfileDefaultOutboundQueueOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3565 }
3566 if (!request.RoutingProfileIdHasBeenSet())
3567 {
3568 AWS_LOGSTREAM_ERROR("UpdateRoutingProfileDefaultOutboundQueue", "Required field: RoutingProfileId, is not set");
3569 return UpdateRoutingProfileDefaultOutboundQueueOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoutingProfileId]", false));
3570 }
3571 Aws::Http::URI uri = m_uri;
3572 uri.AddPathSegments("/routing-profiles/");
3573 uri.AddPathSegment(request.GetInstanceId());
3574 uri.AddPathSegment(request.GetRoutingProfileId());
3575 uri.AddPathSegments("/default-outbound-queue");
3576 return UpdateRoutingProfileDefaultOutboundQueueOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3577 }
3578
UpdateRoutingProfileDefaultOutboundQueueCallable(const UpdateRoutingProfileDefaultOutboundQueueRequest & request) const3579 UpdateRoutingProfileDefaultOutboundQueueOutcomeCallable ConnectClient::UpdateRoutingProfileDefaultOutboundQueueCallable(const UpdateRoutingProfileDefaultOutboundQueueRequest& request) const
3580 {
3581 auto task = Aws::MakeShared< std::packaged_task< UpdateRoutingProfileDefaultOutboundQueueOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRoutingProfileDefaultOutboundQueue(request); } );
3582 auto packagedFunction = [task]() { (*task)(); };
3583 m_executor->Submit(packagedFunction);
3584 return task->get_future();
3585 }
3586
UpdateRoutingProfileDefaultOutboundQueueAsync(const UpdateRoutingProfileDefaultOutboundQueueRequest & request,const UpdateRoutingProfileDefaultOutboundQueueResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3587 void ConnectClient::UpdateRoutingProfileDefaultOutboundQueueAsync(const UpdateRoutingProfileDefaultOutboundQueueRequest& request, const UpdateRoutingProfileDefaultOutboundQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3588 {
3589 m_executor->Submit( [this, request, handler, context](){ this->UpdateRoutingProfileDefaultOutboundQueueAsyncHelper( request, handler, context ); } );
3590 }
3591
UpdateRoutingProfileDefaultOutboundQueueAsyncHelper(const UpdateRoutingProfileDefaultOutboundQueueRequest & request,const UpdateRoutingProfileDefaultOutboundQueueResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3592 void ConnectClient::UpdateRoutingProfileDefaultOutboundQueueAsyncHelper(const UpdateRoutingProfileDefaultOutboundQueueRequest& request, const UpdateRoutingProfileDefaultOutboundQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3593 {
3594 handler(this, request, UpdateRoutingProfileDefaultOutboundQueue(request), context);
3595 }
3596
UpdateRoutingProfileName(const UpdateRoutingProfileNameRequest & request) const3597 UpdateRoutingProfileNameOutcome ConnectClient::UpdateRoutingProfileName(const UpdateRoutingProfileNameRequest& request) const
3598 {
3599 if (!request.InstanceIdHasBeenSet())
3600 {
3601 AWS_LOGSTREAM_ERROR("UpdateRoutingProfileName", "Required field: InstanceId, is not set");
3602 return UpdateRoutingProfileNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3603 }
3604 if (!request.RoutingProfileIdHasBeenSet())
3605 {
3606 AWS_LOGSTREAM_ERROR("UpdateRoutingProfileName", "Required field: RoutingProfileId, is not set");
3607 return UpdateRoutingProfileNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoutingProfileId]", false));
3608 }
3609 Aws::Http::URI uri = m_uri;
3610 uri.AddPathSegments("/routing-profiles/");
3611 uri.AddPathSegment(request.GetInstanceId());
3612 uri.AddPathSegment(request.GetRoutingProfileId());
3613 uri.AddPathSegments("/name");
3614 return UpdateRoutingProfileNameOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3615 }
3616
UpdateRoutingProfileNameCallable(const UpdateRoutingProfileNameRequest & request) const3617 UpdateRoutingProfileNameOutcomeCallable ConnectClient::UpdateRoutingProfileNameCallable(const UpdateRoutingProfileNameRequest& request) const
3618 {
3619 auto task = Aws::MakeShared< std::packaged_task< UpdateRoutingProfileNameOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRoutingProfileName(request); } );
3620 auto packagedFunction = [task]() { (*task)(); };
3621 m_executor->Submit(packagedFunction);
3622 return task->get_future();
3623 }
3624
UpdateRoutingProfileNameAsync(const UpdateRoutingProfileNameRequest & request,const UpdateRoutingProfileNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3625 void ConnectClient::UpdateRoutingProfileNameAsync(const UpdateRoutingProfileNameRequest& request, const UpdateRoutingProfileNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3626 {
3627 m_executor->Submit( [this, request, handler, context](){ this->UpdateRoutingProfileNameAsyncHelper( request, handler, context ); } );
3628 }
3629
UpdateRoutingProfileNameAsyncHelper(const UpdateRoutingProfileNameRequest & request,const UpdateRoutingProfileNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3630 void ConnectClient::UpdateRoutingProfileNameAsyncHelper(const UpdateRoutingProfileNameRequest& request, const UpdateRoutingProfileNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3631 {
3632 handler(this, request, UpdateRoutingProfileName(request), context);
3633 }
3634
UpdateRoutingProfileQueues(const UpdateRoutingProfileQueuesRequest & request) const3635 UpdateRoutingProfileQueuesOutcome ConnectClient::UpdateRoutingProfileQueues(const UpdateRoutingProfileQueuesRequest& request) const
3636 {
3637 if (!request.InstanceIdHasBeenSet())
3638 {
3639 AWS_LOGSTREAM_ERROR("UpdateRoutingProfileQueues", "Required field: InstanceId, is not set");
3640 return UpdateRoutingProfileQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3641 }
3642 if (!request.RoutingProfileIdHasBeenSet())
3643 {
3644 AWS_LOGSTREAM_ERROR("UpdateRoutingProfileQueues", "Required field: RoutingProfileId, is not set");
3645 return UpdateRoutingProfileQueuesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoutingProfileId]", false));
3646 }
3647 Aws::Http::URI uri = m_uri;
3648 uri.AddPathSegments("/routing-profiles/");
3649 uri.AddPathSegment(request.GetInstanceId());
3650 uri.AddPathSegment(request.GetRoutingProfileId());
3651 uri.AddPathSegments("/queues");
3652 return UpdateRoutingProfileQueuesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3653 }
3654
UpdateRoutingProfileQueuesCallable(const UpdateRoutingProfileQueuesRequest & request) const3655 UpdateRoutingProfileQueuesOutcomeCallable ConnectClient::UpdateRoutingProfileQueuesCallable(const UpdateRoutingProfileQueuesRequest& request) const
3656 {
3657 auto task = Aws::MakeShared< std::packaged_task< UpdateRoutingProfileQueuesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRoutingProfileQueues(request); } );
3658 auto packagedFunction = [task]() { (*task)(); };
3659 m_executor->Submit(packagedFunction);
3660 return task->get_future();
3661 }
3662
UpdateRoutingProfileQueuesAsync(const UpdateRoutingProfileQueuesRequest & request,const UpdateRoutingProfileQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3663 void ConnectClient::UpdateRoutingProfileQueuesAsync(const UpdateRoutingProfileQueuesRequest& request, const UpdateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3664 {
3665 m_executor->Submit( [this, request, handler, context](){ this->UpdateRoutingProfileQueuesAsyncHelper( request, handler, context ); } );
3666 }
3667
UpdateRoutingProfileQueuesAsyncHelper(const UpdateRoutingProfileQueuesRequest & request,const UpdateRoutingProfileQueuesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3668 void ConnectClient::UpdateRoutingProfileQueuesAsyncHelper(const UpdateRoutingProfileQueuesRequest& request, const UpdateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3669 {
3670 handler(this, request, UpdateRoutingProfileQueues(request), context);
3671 }
3672
UpdateUserHierarchy(const UpdateUserHierarchyRequest & request) const3673 UpdateUserHierarchyOutcome ConnectClient::UpdateUserHierarchy(const UpdateUserHierarchyRequest& request) const
3674 {
3675 if (!request.UserIdHasBeenSet())
3676 {
3677 AWS_LOGSTREAM_ERROR("UpdateUserHierarchy", "Required field: UserId, is not set");
3678 return UpdateUserHierarchyOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
3679 }
3680 if (!request.InstanceIdHasBeenSet())
3681 {
3682 AWS_LOGSTREAM_ERROR("UpdateUserHierarchy", "Required field: InstanceId, is not set");
3683 return UpdateUserHierarchyOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3684 }
3685 Aws::Http::URI uri = m_uri;
3686 uri.AddPathSegments("/users/");
3687 uri.AddPathSegment(request.GetInstanceId());
3688 uri.AddPathSegment(request.GetUserId());
3689 uri.AddPathSegments("/hierarchy");
3690 return UpdateUserHierarchyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3691 }
3692
UpdateUserHierarchyCallable(const UpdateUserHierarchyRequest & request) const3693 UpdateUserHierarchyOutcomeCallable ConnectClient::UpdateUserHierarchyCallable(const UpdateUserHierarchyRequest& request) const
3694 {
3695 auto task = Aws::MakeShared< std::packaged_task< UpdateUserHierarchyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUserHierarchy(request); } );
3696 auto packagedFunction = [task]() { (*task)(); };
3697 m_executor->Submit(packagedFunction);
3698 return task->get_future();
3699 }
3700
UpdateUserHierarchyAsync(const UpdateUserHierarchyRequest & request,const UpdateUserHierarchyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3701 void ConnectClient::UpdateUserHierarchyAsync(const UpdateUserHierarchyRequest& request, const UpdateUserHierarchyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3702 {
3703 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserHierarchyAsyncHelper( request, handler, context ); } );
3704 }
3705
UpdateUserHierarchyAsyncHelper(const UpdateUserHierarchyRequest & request,const UpdateUserHierarchyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3706 void ConnectClient::UpdateUserHierarchyAsyncHelper(const UpdateUserHierarchyRequest& request, const UpdateUserHierarchyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3707 {
3708 handler(this, request, UpdateUserHierarchy(request), context);
3709 }
3710
UpdateUserHierarchyGroupName(const UpdateUserHierarchyGroupNameRequest & request) const3711 UpdateUserHierarchyGroupNameOutcome ConnectClient::UpdateUserHierarchyGroupName(const UpdateUserHierarchyGroupNameRequest& request) const
3712 {
3713 if (!request.HierarchyGroupIdHasBeenSet())
3714 {
3715 AWS_LOGSTREAM_ERROR("UpdateUserHierarchyGroupName", "Required field: HierarchyGroupId, is not set");
3716 return UpdateUserHierarchyGroupNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [HierarchyGroupId]", false));
3717 }
3718 if (!request.InstanceIdHasBeenSet())
3719 {
3720 AWS_LOGSTREAM_ERROR("UpdateUserHierarchyGroupName", "Required field: InstanceId, is not set");
3721 return UpdateUserHierarchyGroupNameOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3722 }
3723 Aws::Http::URI uri = m_uri;
3724 uri.AddPathSegments("/user-hierarchy-groups/");
3725 uri.AddPathSegment(request.GetInstanceId());
3726 uri.AddPathSegment(request.GetHierarchyGroupId());
3727 uri.AddPathSegments("/name");
3728 return UpdateUserHierarchyGroupNameOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3729 }
3730
UpdateUserHierarchyGroupNameCallable(const UpdateUserHierarchyGroupNameRequest & request) const3731 UpdateUserHierarchyGroupNameOutcomeCallable ConnectClient::UpdateUserHierarchyGroupNameCallable(const UpdateUserHierarchyGroupNameRequest& request) const
3732 {
3733 auto task = Aws::MakeShared< std::packaged_task< UpdateUserHierarchyGroupNameOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUserHierarchyGroupName(request); } );
3734 auto packagedFunction = [task]() { (*task)(); };
3735 m_executor->Submit(packagedFunction);
3736 return task->get_future();
3737 }
3738
UpdateUserHierarchyGroupNameAsync(const UpdateUserHierarchyGroupNameRequest & request,const UpdateUserHierarchyGroupNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3739 void ConnectClient::UpdateUserHierarchyGroupNameAsync(const UpdateUserHierarchyGroupNameRequest& request, const UpdateUserHierarchyGroupNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3740 {
3741 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserHierarchyGroupNameAsyncHelper( request, handler, context ); } );
3742 }
3743
UpdateUserHierarchyGroupNameAsyncHelper(const UpdateUserHierarchyGroupNameRequest & request,const UpdateUserHierarchyGroupNameResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3744 void ConnectClient::UpdateUserHierarchyGroupNameAsyncHelper(const UpdateUserHierarchyGroupNameRequest& request, const UpdateUserHierarchyGroupNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3745 {
3746 handler(this, request, UpdateUserHierarchyGroupName(request), context);
3747 }
3748
UpdateUserHierarchyStructure(const UpdateUserHierarchyStructureRequest & request) const3749 UpdateUserHierarchyStructureOutcome ConnectClient::UpdateUserHierarchyStructure(const UpdateUserHierarchyStructureRequest& request) const
3750 {
3751 if (!request.InstanceIdHasBeenSet())
3752 {
3753 AWS_LOGSTREAM_ERROR("UpdateUserHierarchyStructure", "Required field: InstanceId, is not set");
3754 return UpdateUserHierarchyStructureOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3755 }
3756 Aws::Http::URI uri = m_uri;
3757 uri.AddPathSegments("/user-hierarchy-structure/");
3758 uri.AddPathSegment(request.GetInstanceId());
3759 return UpdateUserHierarchyStructureOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3760 }
3761
UpdateUserHierarchyStructureCallable(const UpdateUserHierarchyStructureRequest & request) const3762 UpdateUserHierarchyStructureOutcomeCallable ConnectClient::UpdateUserHierarchyStructureCallable(const UpdateUserHierarchyStructureRequest& request) const
3763 {
3764 auto task = Aws::MakeShared< std::packaged_task< UpdateUserHierarchyStructureOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUserHierarchyStructure(request); } );
3765 auto packagedFunction = [task]() { (*task)(); };
3766 m_executor->Submit(packagedFunction);
3767 return task->get_future();
3768 }
3769
UpdateUserHierarchyStructureAsync(const UpdateUserHierarchyStructureRequest & request,const UpdateUserHierarchyStructureResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3770 void ConnectClient::UpdateUserHierarchyStructureAsync(const UpdateUserHierarchyStructureRequest& request, const UpdateUserHierarchyStructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3771 {
3772 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserHierarchyStructureAsyncHelper( request, handler, context ); } );
3773 }
3774
UpdateUserHierarchyStructureAsyncHelper(const UpdateUserHierarchyStructureRequest & request,const UpdateUserHierarchyStructureResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3775 void ConnectClient::UpdateUserHierarchyStructureAsyncHelper(const UpdateUserHierarchyStructureRequest& request, const UpdateUserHierarchyStructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3776 {
3777 handler(this, request, UpdateUserHierarchyStructure(request), context);
3778 }
3779
UpdateUserIdentityInfo(const UpdateUserIdentityInfoRequest & request) const3780 UpdateUserIdentityInfoOutcome ConnectClient::UpdateUserIdentityInfo(const UpdateUserIdentityInfoRequest& request) const
3781 {
3782 if (!request.UserIdHasBeenSet())
3783 {
3784 AWS_LOGSTREAM_ERROR("UpdateUserIdentityInfo", "Required field: UserId, is not set");
3785 return UpdateUserIdentityInfoOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
3786 }
3787 if (!request.InstanceIdHasBeenSet())
3788 {
3789 AWS_LOGSTREAM_ERROR("UpdateUserIdentityInfo", "Required field: InstanceId, is not set");
3790 return UpdateUserIdentityInfoOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3791 }
3792 Aws::Http::URI uri = m_uri;
3793 uri.AddPathSegments("/users/");
3794 uri.AddPathSegment(request.GetInstanceId());
3795 uri.AddPathSegment(request.GetUserId());
3796 uri.AddPathSegments("/identity-info");
3797 return UpdateUserIdentityInfoOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3798 }
3799
UpdateUserIdentityInfoCallable(const UpdateUserIdentityInfoRequest & request) const3800 UpdateUserIdentityInfoOutcomeCallable ConnectClient::UpdateUserIdentityInfoCallable(const UpdateUserIdentityInfoRequest& request) const
3801 {
3802 auto task = Aws::MakeShared< std::packaged_task< UpdateUserIdentityInfoOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUserIdentityInfo(request); } );
3803 auto packagedFunction = [task]() { (*task)(); };
3804 m_executor->Submit(packagedFunction);
3805 return task->get_future();
3806 }
3807
UpdateUserIdentityInfoAsync(const UpdateUserIdentityInfoRequest & request,const UpdateUserIdentityInfoResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3808 void ConnectClient::UpdateUserIdentityInfoAsync(const UpdateUserIdentityInfoRequest& request, const UpdateUserIdentityInfoResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3809 {
3810 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserIdentityInfoAsyncHelper( request, handler, context ); } );
3811 }
3812
UpdateUserIdentityInfoAsyncHelper(const UpdateUserIdentityInfoRequest & request,const UpdateUserIdentityInfoResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3813 void ConnectClient::UpdateUserIdentityInfoAsyncHelper(const UpdateUserIdentityInfoRequest& request, const UpdateUserIdentityInfoResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3814 {
3815 handler(this, request, UpdateUserIdentityInfo(request), context);
3816 }
3817
UpdateUserPhoneConfig(const UpdateUserPhoneConfigRequest & request) const3818 UpdateUserPhoneConfigOutcome ConnectClient::UpdateUserPhoneConfig(const UpdateUserPhoneConfigRequest& request) const
3819 {
3820 if (!request.UserIdHasBeenSet())
3821 {
3822 AWS_LOGSTREAM_ERROR("UpdateUserPhoneConfig", "Required field: UserId, is not set");
3823 return UpdateUserPhoneConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
3824 }
3825 if (!request.InstanceIdHasBeenSet())
3826 {
3827 AWS_LOGSTREAM_ERROR("UpdateUserPhoneConfig", "Required field: InstanceId, is not set");
3828 return UpdateUserPhoneConfigOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3829 }
3830 Aws::Http::URI uri = m_uri;
3831 uri.AddPathSegments("/users/");
3832 uri.AddPathSegment(request.GetInstanceId());
3833 uri.AddPathSegment(request.GetUserId());
3834 uri.AddPathSegments("/phone-config");
3835 return UpdateUserPhoneConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3836 }
3837
UpdateUserPhoneConfigCallable(const UpdateUserPhoneConfigRequest & request) const3838 UpdateUserPhoneConfigOutcomeCallable ConnectClient::UpdateUserPhoneConfigCallable(const UpdateUserPhoneConfigRequest& request) const
3839 {
3840 auto task = Aws::MakeShared< std::packaged_task< UpdateUserPhoneConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUserPhoneConfig(request); } );
3841 auto packagedFunction = [task]() { (*task)(); };
3842 m_executor->Submit(packagedFunction);
3843 return task->get_future();
3844 }
3845
UpdateUserPhoneConfigAsync(const UpdateUserPhoneConfigRequest & request,const UpdateUserPhoneConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3846 void ConnectClient::UpdateUserPhoneConfigAsync(const UpdateUserPhoneConfigRequest& request, const UpdateUserPhoneConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3847 {
3848 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserPhoneConfigAsyncHelper( request, handler, context ); } );
3849 }
3850
UpdateUserPhoneConfigAsyncHelper(const UpdateUserPhoneConfigRequest & request,const UpdateUserPhoneConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3851 void ConnectClient::UpdateUserPhoneConfigAsyncHelper(const UpdateUserPhoneConfigRequest& request, const UpdateUserPhoneConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3852 {
3853 handler(this, request, UpdateUserPhoneConfig(request), context);
3854 }
3855
UpdateUserRoutingProfile(const UpdateUserRoutingProfileRequest & request) const3856 UpdateUserRoutingProfileOutcome ConnectClient::UpdateUserRoutingProfile(const UpdateUserRoutingProfileRequest& request) const
3857 {
3858 if (!request.UserIdHasBeenSet())
3859 {
3860 AWS_LOGSTREAM_ERROR("UpdateUserRoutingProfile", "Required field: UserId, is not set");
3861 return UpdateUserRoutingProfileOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
3862 }
3863 if (!request.InstanceIdHasBeenSet())
3864 {
3865 AWS_LOGSTREAM_ERROR("UpdateUserRoutingProfile", "Required field: InstanceId, is not set");
3866 return UpdateUserRoutingProfileOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3867 }
3868 Aws::Http::URI uri = m_uri;
3869 uri.AddPathSegments("/users/");
3870 uri.AddPathSegment(request.GetInstanceId());
3871 uri.AddPathSegment(request.GetUserId());
3872 uri.AddPathSegments("/routing-profile");
3873 return UpdateUserRoutingProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3874 }
3875
UpdateUserRoutingProfileCallable(const UpdateUserRoutingProfileRequest & request) const3876 UpdateUserRoutingProfileOutcomeCallable ConnectClient::UpdateUserRoutingProfileCallable(const UpdateUserRoutingProfileRequest& request) const
3877 {
3878 auto task = Aws::MakeShared< std::packaged_task< UpdateUserRoutingProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUserRoutingProfile(request); } );
3879 auto packagedFunction = [task]() { (*task)(); };
3880 m_executor->Submit(packagedFunction);
3881 return task->get_future();
3882 }
3883
UpdateUserRoutingProfileAsync(const UpdateUserRoutingProfileRequest & request,const UpdateUserRoutingProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3884 void ConnectClient::UpdateUserRoutingProfileAsync(const UpdateUserRoutingProfileRequest& request, const UpdateUserRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3885 {
3886 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserRoutingProfileAsyncHelper( request, handler, context ); } );
3887 }
3888
UpdateUserRoutingProfileAsyncHelper(const UpdateUserRoutingProfileRequest & request,const UpdateUserRoutingProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3889 void ConnectClient::UpdateUserRoutingProfileAsyncHelper(const UpdateUserRoutingProfileRequest& request, const UpdateUserRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3890 {
3891 handler(this, request, UpdateUserRoutingProfile(request), context);
3892 }
3893
UpdateUserSecurityProfiles(const UpdateUserSecurityProfilesRequest & request) const3894 UpdateUserSecurityProfilesOutcome ConnectClient::UpdateUserSecurityProfiles(const UpdateUserSecurityProfilesRequest& request) const
3895 {
3896 if (!request.UserIdHasBeenSet())
3897 {
3898 AWS_LOGSTREAM_ERROR("UpdateUserSecurityProfiles", "Required field: UserId, is not set");
3899 return UpdateUserSecurityProfilesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
3900 }
3901 if (!request.InstanceIdHasBeenSet())
3902 {
3903 AWS_LOGSTREAM_ERROR("UpdateUserSecurityProfiles", "Required field: InstanceId, is not set");
3904 return UpdateUserSecurityProfilesOutcome(Aws::Client::AWSError<ConnectErrors>(ConnectErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [InstanceId]", false));
3905 }
3906 Aws::Http::URI uri = m_uri;
3907 uri.AddPathSegments("/users/");
3908 uri.AddPathSegment(request.GetInstanceId());
3909 uri.AddPathSegment(request.GetUserId());
3910 uri.AddPathSegments("/security-profiles");
3911 return UpdateUserSecurityProfilesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3912 }
3913
UpdateUserSecurityProfilesCallable(const UpdateUserSecurityProfilesRequest & request) const3914 UpdateUserSecurityProfilesOutcomeCallable ConnectClient::UpdateUserSecurityProfilesCallable(const UpdateUserSecurityProfilesRequest& request) const
3915 {
3916 auto task = Aws::MakeShared< std::packaged_task< UpdateUserSecurityProfilesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUserSecurityProfiles(request); } );
3917 auto packagedFunction = [task]() { (*task)(); };
3918 m_executor->Submit(packagedFunction);
3919 return task->get_future();
3920 }
3921
UpdateUserSecurityProfilesAsync(const UpdateUserSecurityProfilesRequest & request,const UpdateUserSecurityProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3922 void ConnectClient::UpdateUserSecurityProfilesAsync(const UpdateUserSecurityProfilesRequest& request, const UpdateUserSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3923 {
3924 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserSecurityProfilesAsyncHelper( request, handler, context ); } );
3925 }
3926
UpdateUserSecurityProfilesAsyncHelper(const UpdateUserSecurityProfilesRequest & request,const UpdateUserSecurityProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3927 void ConnectClient::UpdateUserSecurityProfilesAsyncHelper(const UpdateUserSecurityProfilesRequest& request, const UpdateUserSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3928 {
3929 handler(this, request, UpdateUserSecurityProfiles(request), context);
3930 }
3931
3932