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/chime/ChimeClient.h>
21 #include <aws/chime/ChimeEndpoint.h>
22 #include <aws/chime/ChimeErrorMarshaller.h>
23 #include <aws/chime/model/AssociatePhoneNumberWithUserRequest.h>
24 #include <aws/chime/model/AssociatePhoneNumbersWithVoiceConnectorRequest.h>
25 #include <aws/chime/model/AssociatePhoneNumbersWithVoiceConnectorGroupRequest.h>
26 #include <aws/chime/model/AssociateSigninDelegateGroupsWithAccountRequest.h>
27 #include <aws/chime/model/BatchCreateAttendeeRequest.h>
28 #include <aws/chime/model/BatchCreateChannelMembershipRequest.h>
29 #include <aws/chime/model/BatchCreateRoomMembershipRequest.h>
30 #include <aws/chime/model/BatchDeletePhoneNumberRequest.h>
31 #include <aws/chime/model/BatchSuspendUserRequest.h>
32 #include <aws/chime/model/BatchUnsuspendUserRequest.h>
33 #include <aws/chime/model/BatchUpdatePhoneNumberRequest.h>
34 #include <aws/chime/model/BatchUpdateUserRequest.h>
35 #include <aws/chime/model/CreateAccountRequest.h>
36 #include <aws/chime/model/CreateAppInstanceRequest.h>
37 #include <aws/chime/model/CreateAppInstanceAdminRequest.h>
38 #include <aws/chime/model/CreateAppInstanceUserRequest.h>
39 #include <aws/chime/model/CreateAttendeeRequest.h>
40 #include <aws/chime/model/CreateBotRequest.h>
41 #include <aws/chime/model/CreateChannelRequest.h>
42 #include <aws/chime/model/CreateChannelBanRequest.h>
43 #include <aws/chime/model/CreateChannelMembershipRequest.h>
44 #include <aws/chime/model/CreateChannelModeratorRequest.h>
45 #include <aws/chime/model/CreateMediaCapturePipelineRequest.h>
46 #include <aws/chime/model/CreateMeetingRequest.h>
47 #include <aws/chime/model/CreateMeetingDialOutRequest.h>
48 #include <aws/chime/model/CreateMeetingWithAttendeesRequest.h>
49 #include <aws/chime/model/CreatePhoneNumberOrderRequest.h>
50 #include <aws/chime/model/CreateProxySessionRequest.h>
51 #include <aws/chime/model/CreateRoomRequest.h>
52 #include <aws/chime/model/CreateRoomMembershipRequest.h>
53 #include <aws/chime/model/CreateSipMediaApplicationRequest.h>
54 #include <aws/chime/model/CreateSipMediaApplicationCallRequest.h>
55 #include <aws/chime/model/CreateSipRuleRequest.h>
56 #include <aws/chime/model/CreateUserRequest.h>
57 #include <aws/chime/model/CreateVoiceConnectorRequest.h>
58 #include <aws/chime/model/CreateVoiceConnectorGroupRequest.h>
59 #include <aws/chime/model/DeleteAccountRequest.h>
60 #include <aws/chime/model/DeleteAppInstanceRequest.h>
61 #include <aws/chime/model/DeleteAppInstanceAdminRequest.h>
62 #include <aws/chime/model/DeleteAppInstanceStreamingConfigurationsRequest.h>
63 #include <aws/chime/model/DeleteAppInstanceUserRequest.h>
64 #include <aws/chime/model/DeleteAttendeeRequest.h>
65 #include <aws/chime/model/DeleteChannelRequest.h>
66 #include <aws/chime/model/DeleteChannelBanRequest.h>
67 #include <aws/chime/model/DeleteChannelMembershipRequest.h>
68 #include <aws/chime/model/DeleteChannelMessageRequest.h>
69 #include <aws/chime/model/DeleteChannelModeratorRequest.h>
70 #include <aws/chime/model/DeleteEventsConfigurationRequest.h>
71 #include <aws/chime/model/DeleteMediaCapturePipelineRequest.h>
72 #include <aws/chime/model/DeleteMeetingRequest.h>
73 #include <aws/chime/model/DeletePhoneNumberRequest.h>
74 #include <aws/chime/model/DeleteProxySessionRequest.h>
75 #include <aws/chime/model/DeleteRoomRequest.h>
76 #include <aws/chime/model/DeleteRoomMembershipRequest.h>
77 #include <aws/chime/model/DeleteSipMediaApplicationRequest.h>
78 #include <aws/chime/model/DeleteSipRuleRequest.h>
79 #include <aws/chime/model/DeleteVoiceConnectorRequest.h>
80 #include <aws/chime/model/DeleteVoiceConnectorEmergencyCallingConfigurationRequest.h>
81 #include <aws/chime/model/DeleteVoiceConnectorGroupRequest.h>
82 #include <aws/chime/model/DeleteVoiceConnectorOriginationRequest.h>
83 #include <aws/chime/model/DeleteVoiceConnectorProxyRequest.h>
84 #include <aws/chime/model/DeleteVoiceConnectorStreamingConfigurationRequest.h>
85 #include <aws/chime/model/DeleteVoiceConnectorTerminationRequest.h>
86 #include <aws/chime/model/DeleteVoiceConnectorTerminationCredentialsRequest.h>
87 #include <aws/chime/model/DescribeAppInstanceRequest.h>
88 #include <aws/chime/model/DescribeAppInstanceAdminRequest.h>
89 #include <aws/chime/model/DescribeAppInstanceUserRequest.h>
90 #include <aws/chime/model/DescribeChannelRequest.h>
91 #include <aws/chime/model/DescribeChannelBanRequest.h>
92 #include <aws/chime/model/DescribeChannelMembershipRequest.h>
93 #include <aws/chime/model/DescribeChannelMembershipForAppInstanceUserRequest.h>
94 #include <aws/chime/model/DescribeChannelModeratedByAppInstanceUserRequest.h>
95 #include <aws/chime/model/DescribeChannelModeratorRequest.h>
96 #include <aws/chime/model/DisassociatePhoneNumberFromUserRequest.h>
97 #include <aws/chime/model/DisassociatePhoneNumbersFromVoiceConnectorRequest.h>
98 #include <aws/chime/model/DisassociatePhoneNumbersFromVoiceConnectorGroupRequest.h>
99 #include <aws/chime/model/DisassociateSigninDelegateGroupsFromAccountRequest.h>
100 #include <aws/chime/model/GetAccountRequest.h>
101 #include <aws/chime/model/GetAccountSettingsRequest.h>
102 #include <aws/chime/model/GetAppInstanceRetentionSettingsRequest.h>
103 #include <aws/chime/model/GetAppInstanceStreamingConfigurationsRequest.h>
104 #include <aws/chime/model/GetAttendeeRequest.h>
105 #include <aws/chime/model/GetBotRequest.h>
106 #include <aws/chime/model/GetChannelMessageRequest.h>
107 #include <aws/chime/model/GetEventsConfigurationRequest.h>
108 #include <aws/chime/model/GetMediaCapturePipelineRequest.h>
109 #include <aws/chime/model/GetMeetingRequest.h>
110 #include <aws/chime/model/GetMessagingSessionEndpointRequest.h>
111 #include <aws/chime/model/GetPhoneNumberRequest.h>
112 #include <aws/chime/model/GetPhoneNumberOrderRequest.h>
113 #include <aws/chime/model/GetProxySessionRequest.h>
114 #include <aws/chime/model/GetRetentionSettingsRequest.h>
115 #include <aws/chime/model/GetRoomRequest.h>
116 #include <aws/chime/model/GetSipMediaApplicationRequest.h>
117 #include <aws/chime/model/GetSipMediaApplicationLoggingConfigurationRequest.h>
118 #include <aws/chime/model/GetSipRuleRequest.h>
119 #include <aws/chime/model/GetUserRequest.h>
120 #include <aws/chime/model/GetUserSettingsRequest.h>
121 #include <aws/chime/model/GetVoiceConnectorRequest.h>
122 #include <aws/chime/model/GetVoiceConnectorEmergencyCallingConfigurationRequest.h>
123 #include <aws/chime/model/GetVoiceConnectorGroupRequest.h>
124 #include <aws/chime/model/GetVoiceConnectorLoggingConfigurationRequest.h>
125 #include <aws/chime/model/GetVoiceConnectorOriginationRequest.h>
126 #include <aws/chime/model/GetVoiceConnectorProxyRequest.h>
127 #include <aws/chime/model/GetVoiceConnectorStreamingConfigurationRequest.h>
128 #include <aws/chime/model/GetVoiceConnectorTerminationRequest.h>
129 #include <aws/chime/model/GetVoiceConnectorTerminationHealthRequest.h>
130 #include <aws/chime/model/InviteUsersRequest.h>
131 #include <aws/chime/model/ListAccountsRequest.h>
132 #include <aws/chime/model/ListAppInstanceAdminsRequest.h>
133 #include <aws/chime/model/ListAppInstanceUsersRequest.h>
134 #include <aws/chime/model/ListAppInstancesRequest.h>
135 #include <aws/chime/model/ListAttendeeTagsRequest.h>
136 #include <aws/chime/model/ListAttendeesRequest.h>
137 #include <aws/chime/model/ListBotsRequest.h>
138 #include <aws/chime/model/ListChannelBansRequest.h>
139 #include <aws/chime/model/ListChannelMembershipsRequest.h>
140 #include <aws/chime/model/ListChannelMembershipsForAppInstanceUserRequest.h>
141 #include <aws/chime/model/ListChannelMessagesRequest.h>
142 #include <aws/chime/model/ListChannelModeratorsRequest.h>
143 #include <aws/chime/model/ListChannelsRequest.h>
144 #include <aws/chime/model/ListChannelsModeratedByAppInstanceUserRequest.h>
145 #include <aws/chime/model/ListMediaCapturePipelinesRequest.h>
146 #include <aws/chime/model/ListMeetingTagsRequest.h>
147 #include <aws/chime/model/ListMeetingsRequest.h>
148 #include <aws/chime/model/ListPhoneNumberOrdersRequest.h>
149 #include <aws/chime/model/ListPhoneNumbersRequest.h>
150 #include <aws/chime/model/ListProxySessionsRequest.h>
151 #include <aws/chime/model/ListRoomMembershipsRequest.h>
152 #include <aws/chime/model/ListRoomsRequest.h>
153 #include <aws/chime/model/ListSipMediaApplicationsRequest.h>
154 #include <aws/chime/model/ListSipRulesRequest.h>
155 #include <aws/chime/model/ListSupportedPhoneNumberCountriesRequest.h>
156 #include <aws/chime/model/ListTagsForResourceRequest.h>
157 #include <aws/chime/model/ListUsersRequest.h>
158 #include <aws/chime/model/ListVoiceConnectorGroupsRequest.h>
159 #include <aws/chime/model/ListVoiceConnectorTerminationCredentialsRequest.h>
160 #include <aws/chime/model/ListVoiceConnectorsRequest.h>
161 #include <aws/chime/model/LogoutUserRequest.h>
162 #include <aws/chime/model/PutAppInstanceRetentionSettingsRequest.h>
163 #include <aws/chime/model/PutAppInstanceStreamingConfigurationsRequest.h>
164 #include <aws/chime/model/PutEventsConfigurationRequest.h>
165 #include <aws/chime/model/PutRetentionSettingsRequest.h>
166 #include <aws/chime/model/PutSipMediaApplicationLoggingConfigurationRequest.h>
167 #include <aws/chime/model/PutVoiceConnectorEmergencyCallingConfigurationRequest.h>
168 #include <aws/chime/model/PutVoiceConnectorLoggingConfigurationRequest.h>
169 #include <aws/chime/model/PutVoiceConnectorOriginationRequest.h>
170 #include <aws/chime/model/PutVoiceConnectorProxyRequest.h>
171 #include <aws/chime/model/PutVoiceConnectorStreamingConfigurationRequest.h>
172 #include <aws/chime/model/PutVoiceConnectorTerminationRequest.h>
173 #include <aws/chime/model/PutVoiceConnectorTerminationCredentialsRequest.h>
174 #include <aws/chime/model/RedactChannelMessageRequest.h>
175 #include <aws/chime/model/RedactConversationMessageRequest.h>
176 #include <aws/chime/model/RedactRoomMessageRequest.h>
177 #include <aws/chime/model/RegenerateSecurityTokenRequest.h>
178 #include <aws/chime/model/ResetPersonalPINRequest.h>
179 #include <aws/chime/model/RestorePhoneNumberRequest.h>
180 #include <aws/chime/model/SearchAvailablePhoneNumbersRequest.h>
181 #include <aws/chime/model/SendChannelMessageRequest.h>
182 #include <aws/chime/model/StartMeetingTranscriptionRequest.h>
183 #include <aws/chime/model/StopMeetingTranscriptionRequest.h>
184 #include <aws/chime/model/TagAttendeeRequest.h>
185 #include <aws/chime/model/TagMeetingRequest.h>
186 #include <aws/chime/model/TagResourceRequest.h>
187 #include <aws/chime/model/UntagAttendeeRequest.h>
188 #include <aws/chime/model/UntagMeetingRequest.h>
189 #include <aws/chime/model/UntagResourceRequest.h>
190 #include <aws/chime/model/UpdateAccountRequest.h>
191 #include <aws/chime/model/UpdateAccountSettingsRequest.h>
192 #include <aws/chime/model/UpdateAppInstanceRequest.h>
193 #include <aws/chime/model/UpdateAppInstanceUserRequest.h>
194 #include <aws/chime/model/UpdateBotRequest.h>
195 #include <aws/chime/model/UpdateChannelRequest.h>
196 #include <aws/chime/model/UpdateChannelMessageRequest.h>
197 #include <aws/chime/model/UpdateChannelReadMarkerRequest.h>
198 #include <aws/chime/model/UpdateGlobalSettingsRequest.h>
199 #include <aws/chime/model/UpdatePhoneNumberRequest.h>
200 #include <aws/chime/model/UpdatePhoneNumberSettingsRequest.h>
201 #include <aws/chime/model/UpdateProxySessionRequest.h>
202 #include <aws/chime/model/UpdateRoomRequest.h>
203 #include <aws/chime/model/UpdateRoomMembershipRequest.h>
204 #include <aws/chime/model/UpdateSipMediaApplicationRequest.h>
205 #include <aws/chime/model/UpdateSipMediaApplicationCallRequest.h>
206 #include <aws/chime/model/UpdateSipRuleRequest.h>
207 #include <aws/chime/model/UpdateUserRequest.h>
208 #include <aws/chime/model/UpdateUserSettingsRequest.h>
209 #include <aws/chime/model/UpdateVoiceConnectorRequest.h>
210 #include <aws/chime/model/UpdateVoiceConnectorGroupRequest.h>
211
212 using namespace Aws;
213 using namespace Aws::Auth;
214 using namespace Aws::Client;
215 using namespace Aws::Chime;
216 using namespace Aws::Chime::Model;
217 using namespace Aws::Http;
218 using namespace Aws::Utils::Json;
219
220 static const char* SERVICE_NAME = "chime";
221 static const char* ALLOCATION_TAG = "ChimeClient";
222
223
ChimeClient(const Client::ClientConfiguration & clientConfiguration)224 ChimeClient::ChimeClient(const Client::ClientConfiguration& clientConfiguration) :
225 BASECLASS(clientConfiguration,
226 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
227 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
228 Aws::MakeShared<ChimeErrorMarshaller>(ALLOCATION_TAG)),
229 m_executor(clientConfiguration.executor)
230 {
231 init(clientConfiguration);
232 }
233
ChimeClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)234 ChimeClient::ChimeClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
235 BASECLASS(clientConfiguration,
236 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
237 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
238 Aws::MakeShared<ChimeErrorMarshaller>(ALLOCATION_TAG)),
239 m_executor(clientConfiguration.executor)
240 {
241 init(clientConfiguration);
242 }
243
ChimeClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)244 ChimeClient::ChimeClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
245 const Client::ClientConfiguration& clientConfiguration) :
246 BASECLASS(clientConfiguration,
247 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
248 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
249 Aws::MakeShared<ChimeErrorMarshaller>(ALLOCATION_TAG)),
250 m_executor(clientConfiguration.executor)
251 {
252 init(clientConfiguration);
253 }
254
~ChimeClient()255 ChimeClient::~ChimeClient()
256 {
257 }
258
init(const Client::ClientConfiguration & config)259 void ChimeClient::init(const Client::ClientConfiguration& config)
260 {
261 SetServiceClientName("Chime");
262 m_configScheme = SchemeMapper::ToString(config.scheme);
263 m_scheme = m_configScheme;
264 if (config.endpointOverride.empty())
265 {
266 m_baseUri = ChimeEndpoint::ForRegion(config.region, config.useDualStack);
267 }
268 else
269 {
270 OverrideEndpoint(config.endpointOverride);
271 }
272 m_enableHostPrefixInjection = config.enableHostPrefixInjection;
273 }
274
OverrideEndpoint(const Aws::String & endpoint)275 void ChimeClient::OverrideEndpoint(const Aws::String& endpoint)
276 {
277 if (endpoint.compare(0, 7, "http://") == 0)
278 {
279 m_scheme = "http";
280 m_baseUri = endpoint.substr(7);
281 }
282 else if (endpoint.compare(0, 8, "https://") == 0)
283 {
284 m_scheme = "https";
285 m_baseUri = endpoint.substr(8);
286 }
287 else
288 {
289 m_scheme = m_configScheme;
290 m_baseUri = endpoint;
291 }
292 }
293
AssociatePhoneNumberWithUser(const AssociatePhoneNumberWithUserRequest & request) const294 AssociatePhoneNumberWithUserOutcome ChimeClient::AssociatePhoneNumberWithUser(const AssociatePhoneNumberWithUserRequest& request) const
295 {
296 if (!request.AccountIdHasBeenSet())
297 {
298 AWS_LOGSTREAM_ERROR("AssociatePhoneNumberWithUser", "Required field: AccountId, is not set");
299 return AssociatePhoneNumberWithUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
300 }
301 if (!request.UserIdHasBeenSet())
302 {
303 AWS_LOGSTREAM_ERROR("AssociatePhoneNumberWithUser", "Required field: UserId, is not set");
304 return AssociatePhoneNumberWithUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
305 }
306 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
307 Aws::StringStream ss;
308 uri.AddPathSegments("/accounts/");
309 uri.AddPathSegment(request.GetAccountId());
310 uri.AddPathSegments("/users/");
311 uri.AddPathSegment(request.GetUserId());
312 ss.str("?operation=associate-phone-number");
313 uri.SetQueryString(ss.str());
314 return AssociatePhoneNumberWithUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
315 }
316
AssociatePhoneNumberWithUserCallable(const AssociatePhoneNumberWithUserRequest & request) const317 AssociatePhoneNumberWithUserOutcomeCallable ChimeClient::AssociatePhoneNumberWithUserCallable(const AssociatePhoneNumberWithUserRequest& request) const
318 {
319 auto task = Aws::MakeShared< std::packaged_task< AssociatePhoneNumberWithUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociatePhoneNumberWithUser(request); } );
320 auto packagedFunction = [task]() { (*task)(); };
321 m_executor->Submit(packagedFunction);
322 return task->get_future();
323 }
324
AssociatePhoneNumberWithUserAsync(const AssociatePhoneNumberWithUserRequest & request,const AssociatePhoneNumberWithUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const325 void ChimeClient::AssociatePhoneNumberWithUserAsync(const AssociatePhoneNumberWithUserRequest& request, const AssociatePhoneNumberWithUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
326 {
327 m_executor->Submit( [this, request, handler, context](){ this->AssociatePhoneNumberWithUserAsyncHelper( request, handler, context ); } );
328 }
329
AssociatePhoneNumberWithUserAsyncHelper(const AssociatePhoneNumberWithUserRequest & request,const AssociatePhoneNumberWithUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const330 void ChimeClient::AssociatePhoneNumberWithUserAsyncHelper(const AssociatePhoneNumberWithUserRequest& request, const AssociatePhoneNumberWithUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
331 {
332 handler(this, request, AssociatePhoneNumberWithUser(request), context);
333 }
334
AssociatePhoneNumbersWithVoiceConnector(const AssociatePhoneNumbersWithVoiceConnectorRequest & request) const335 AssociatePhoneNumbersWithVoiceConnectorOutcome ChimeClient::AssociatePhoneNumbersWithVoiceConnector(const AssociatePhoneNumbersWithVoiceConnectorRequest& request) const
336 {
337 if (!request.VoiceConnectorIdHasBeenSet())
338 {
339 AWS_LOGSTREAM_ERROR("AssociatePhoneNumbersWithVoiceConnector", "Required field: VoiceConnectorId, is not set");
340 return AssociatePhoneNumbersWithVoiceConnectorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
341 }
342 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
343 Aws::StringStream ss;
344 uri.AddPathSegments("/voice-connectors/");
345 uri.AddPathSegment(request.GetVoiceConnectorId());
346 ss.str("?operation=associate-phone-numbers");
347 uri.SetQueryString(ss.str());
348 return AssociatePhoneNumbersWithVoiceConnectorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
349 }
350
AssociatePhoneNumbersWithVoiceConnectorCallable(const AssociatePhoneNumbersWithVoiceConnectorRequest & request) const351 AssociatePhoneNumbersWithVoiceConnectorOutcomeCallable ChimeClient::AssociatePhoneNumbersWithVoiceConnectorCallable(const AssociatePhoneNumbersWithVoiceConnectorRequest& request) const
352 {
353 auto task = Aws::MakeShared< std::packaged_task< AssociatePhoneNumbersWithVoiceConnectorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociatePhoneNumbersWithVoiceConnector(request); } );
354 auto packagedFunction = [task]() { (*task)(); };
355 m_executor->Submit(packagedFunction);
356 return task->get_future();
357 }
358
AssociatePhoneNumbersWithVoiceConnectorAsync(const AssociatePhoneNumbersWithVoiceConnectorRequest & request,const AssociatePhoneNumbersWithVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const359 void ChimeClient::AssociatePhoneNumbersWithVoiceConnectorAsync(const AssociatePhoneNumbersWithVoiceConnectorRequest& request, const AssociatePhoneNumbersWithVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
360 {
361 m_executor->Submit( [this, request, handler, context](){ this->AssociatePhoneNumbersWithVoiceConnectorAsyncHelper( request, handler, context ); } );
362 }
363
AssociatePhoneNumbersWithVoiceConnectorAsyncHelper(const AssociatePhoneNumbersWithVoiceConnectorRequest & request,const AssociatePhoneNumbersWithVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const364 void ChimeClient::AssociatePhoneNumbersWithVoiceConnectorAsyncHelper(const AssociatePhoneNumbersWithVoiceConnectorRequest& request, const AssociatePhoneNumbersWithVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
365 {
366 handler(this, request, AssociatePhoneNumbersWithVoiceConnector(request), context);
367 }
368
AssociatePhoneNumbersWithVoiceConnectorGroup(const AssociatePhoneNumbersWithVoiceConnectorGroupRequest & request) const369 AssociatePhoneNumbersWithVoiceConnectorGroupOutcome ChimeClient::AssociatePhoneNumbersWithVoiceConnectorGroup(const AssociatePhoneNumbersWithVoiceConnectorGroupRequest& request) const
370 {
371 if (!request.VoiceConnectorGroupIdHasBeenSet())
372 {
373 AWS_LOGSTREAM_ERROR("AssociatePhoneNumbersWithVoiceConnectorGroup", "Required field: VoiceConnectorGroupId, is not set");
374 return AssociatePhoneNumbersWithVoiceConnectorGroupOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorGroupId]", false));
375 }
376 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
377 Aws::StringStream ss;
378 uri.AddPathSegments("/voice-connector-groups/");
379 uri.AddPathSegment(request.GetVoiceConnectorGroupId());
380 ss.str("?operation=associate-phone-numbers");
381 uri.SetQueryString(ss.str());
382 return AssociatePhoneNumbersWithVoiceConnectorGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
383 }
384
AssociatePhoneNumbersWithVoiceConnectorGroupCallable(const AssociatePhoneNumbersWithVoiceConnectorGroupRequest & request) const385 AssociatePhoneNumbersWithVoiceConnectorGroupOutcomeCallable ChimeClient::AssociatePhoneNumbersWithVoiceConnectorGroupCallable(const AssociatePhoneNumbersWithVoiceConnectorGroupRequest& request) const
386 {
387 auto task = Aws::MakeShared< std::packaged_task< AssociatePhoneNumbersWithVoiceConnectorGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociatePhoneNumbersWithVoiceConnectorGroup(request); } );
388 auto packagedFunction = [task]() { (*task)(); };
389 m_executor->Submit(packagedFunction);
390 return task->get_future();
391 }
392
AssociatePhoneNumbersWithVoiceConnectorGroupAsync(const AssociatePhoneNumbersWithVoiceConnectorGroupRequest & request,const AssociatePhoneNumbersWithVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const393 void ChimeClient::AssociatePhoneNumbersWithVoiceConnectorGroupAsync(const AssociatePhoneNumbersWithVoiceConnectorGroupRequest& request, const AssociatePhoneNumbersWithVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
394 {
395 m_executor->Submit( [this, request, handler, context](){ this->AssociatePhoneNumbersWithVoiceConnectorGroupAsyncHelper( request, handler, context ); } );
396 }
397
AssociatePhoneNumbersWithVoiceConnectorGroupAsyncHelper(const AssociatePhoneNumbersWithVoiceConnectorGroupRequest & request,const AssociatePhoneNumbersWithVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const398 void ChimeClient::AssociatePhoneNumbersWithVoiceConnectorGroupAsyncHelper(const AssociatePhoneNumbersWithVoiceConnectorGroupRequest& request, const AssociatePhoneNumbersWithVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
399 {
400 handler(this, request, AssociatePhoneNumbersWithVoiceConnectorGroup(request), context);
401 }
402
AssociateSigninDelegateGroupsWithAccount(const AssociateSigninDelegateGroupsWithAccountRequest & request) const403 AssociateSigninDelegateGroupsWithAccountOutcome ChimeClient::AssociateSigninDelegateGroupsWithAccount(const AssociateSigninDelegateGroupsWithAccountRequest& request) const
404 {
405 if (!request.AccountIdHasBeenSet())
406 {
407 AWS_LOGSTREAM_ERROR("AssociateSigninDelegateGroupsWithAccount", "Required field: AccountId, is not set");
408 return AssociateSigninDelegateGroupsWithAccountOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
409 }
410 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
411 Aws::StringStream ss;
412 uri.AddPathSegments("/accounts/");
413 uri.AddPathSegment(request.GetAccountId());
414 ss.str("?operation=associate-signin-delegate-groups");
415 uri.SetQueryString(ss.str());
416 return AssociateSigninDelegateGroupsWithAccountOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
417 }
418
AssociateSigninDelegateGroupsWithAccountCallable(const AssociateSigninDelegateGroupsWithAccountRequest & request) const419 AssociateSigninDelegateGroupsWithAccountOutcomeCallable ChimeClient::AssociateSigninDelegateGroupsWithAccountCallable(const AssociateSigninDelegateGroupsWithAccountRequest& request) const
420 {
421 auto task = Aws::MakeShared< std::packaged_task< AssociateSigninDelegateGroupsWithAccountOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateSigninDelegateGroupsWithAccount(request); } );
422 auto packagedFunction = [task]() { (*task)(); };
423 m_executor->Submit(packagedFunction);
424 return task->get_future();
425 }
426
AssociateSigninDelegateGroupsWithAccountAsync(const AssociateSigninDelegateGroupsWithAccountRequest & request,const AssociateSigninDelegateGroupsWithAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const427 void ChimeClient::AssociateSigninDelegateGroupsWithAccountAsync(const AssociateSigninDelegateGroupsWithAccountRequest& request, const AssociateSigninDelegateGroupsWithAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
428 {
429 m_executor->Submit( [this, request, handler, context](){ this->AssociateSigninDelegateGroupsWithAccountAsyncHelper( request, handler, context ); } );
430 }
431
AssociateSigninDelegateGroupsWithAccountAsyncHelper(const AssociateSigninDelegateGroupsWithAccountRequest & request,const AssociateSigninDelegateGroupsWithAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const432 void ChimeClient::AssociateSigninDelegateGroupsWithAccountAsyncHelper(const AssociateSigninDelegateGroupsWithAccountRequest& request, const AssociateSigninDelegateGroupsWithAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
433 {
434 handler(this, request, AssociateSigninDelegateGroupsWithAccount(request), context);
435 }
436
BatchCreateAttendee(const BatchCreateAttendeeRequest & request) const437 BatchCreateAttendeeOutcome ChimeClient::BatchCreateAttendee(const BatchCreateAttendeeRequest& request) const
438 {
439 if (!request.MeetingIdHasBeenSet())
440 {
441 AWS_LOGSTREAM_ERROR("BatchCreateAttendee", "Required field: MeetingId, is not set");
442 return BatchCreateAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
443 }
444 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
445 Aws::StringStream ss;
446 uri.AddPathSegments("/meetings/");
447 uri.AddPathSegment(request.GetMeetingId());
448 uri.AddPathSegments("/attendees");
449 ss.str("?operation=batch-create");
450 uri.SetQueryString(ss.str());
451 return BatchCreateAttendeeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
452 }
453
BatchCreateAttendeeCallable(const BatchCreateAttendeeRequest & request) const454 BatchCreateAttendeeOutcomeCallable ChimeClient::BatchCreateAttendeeCallable(const BatchCreateAttendeeRequest& request) const
455 {
456 auto task = Aws::MakeShared< std::packaged_task< BatchCreateAttendeeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchCreateAttendee(request); } );
457 auto packagedFunction = [task]() { (*task)(); };
458 m_executor->Submit(packagedFunction);
459 return task->get_future();
460 }
461
BatchCreateAttendeeAsync(const BatchCreateAttendeeRequest & request,const BatchCreateAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const462 void ChimeClient::BatchCreateAttendeeAsync(const BatchCreateAttendeeRequest& request, const BatchCreateAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
463 {
464 m_executor->Submit( [this, request, handler, context](){ this->BatchCreateAttendeeAsyncHelper( request, handler, context ); } );
465 }
466
BatchCreateAttendeeAsyncHelper(const BatchCreateAttendeeRequest & request,const BatchCreateAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const467 void ChimeClient::BatchCreateAttendeeAsyncHelper(const BatchCreateAttendeeRequest& request, const BatchCreateAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
468 {
469 handler(this, request, BatchCreateAttendee(request), context);
470 }
471
BatchCreateChannelMembership(const BatchCreateChannelMembershipRequest & request) const472 BatchCreateChannelMembershipOutcome ChimeClient::BatchCreateChannelMembership(const BatchCreateChannelMembershipRequest& request) const
473 {
474 if (!request.ChannelArnHasBeenSet())
475 {
476 AWS_LOGSTREAM_ERROR("BatchCreateChannelMembership", "Required field: ChannelArn, is not set");
477 return BatchCreateChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
478 }
479 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
480 if (m_enableHostPrefixInjection)
481 {
482 uri.SetAuthority("messaging-" + uri.GetAuthority());
483 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
484 {
485 AWS_LOGSTREAM_ERROR("BatchCreateChannelMembership", "Invalid DNS host: " << uri.GetAuthority());
486 return BatchCreateChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
487 }
488 }
489 Aws::StringStream ss;
490 uri.AddPathSegments("/channels/");
491 uri.AddPathSegment(request.GetChannelArn());
492 uri.AddPathSegments("/memberships");
493 ss.str("?operation=batch-create");
494 uri.SetQueryString(ss.str());
495 return BatchCreateChannelMembershipOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
496 }
497
BatchCreateChannelMembershipCallable(const BatchCreateChannelMembershipRequest & request) const498 BatchCreateChannelMembershipOutcomeCallable ChimeClient::BatchCreateChannelMembershipCallable(const BatchCreateChannelMembershipRequest& request) const
499 {
500 auto task = Aws::MakeShared< std::packaged_task< BatchCreateChannelMembershipOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchCreateChannelMembership(request); } );
501 auto packagedFunction = [task]() { (*task)(); };
502 m_executor->Submit(packagedFunction);
503 return task->get_future();
504 }
505
BatchCreateChannelMembershipAsync(const BatchCreateChannelMembershipRequest & request,const BatchCreateChannelMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const506 void ChimeClient::BatchCreateChannelMembershipAsync(const BatchCreateChannelMembershipRequest& request, const BatchCreateChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
507 {
508 m_executor->Submit( [this, request, handler, context](){ this->BatchCreateChannelMembershipAsyncHelper( request, handler, context ); } );
509 }
510
BatchCreateChannelMembershipAsyncHelper(const BatchCreateChannelMembershipRequest & request,const BatchCreateChannelMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const511 void ChimeClient::BatchCreateChannelMembershipAsyncHelper(const BatchCreateChannelMembershipRequest& request, const BatchCreateChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
512 {
513 handler(this, request, BatchCreateChannelMembership(request), context);
514 }
515
BatchCreateRoomMembership(const BatchCreateRoomMembershipRequest & request) const516 BatchCreateRoomMembershipOutcome ChimeClient::BatchCreateRoomMembership(const BatchCreateRoomMembershipRequest& request) const
517 {
518 if (!request.AccountIdHasBeenSet())
519 {
520 AWS_LOGSTREAM_ERROR("BatchCreateRoomMembership", "Required field: AccountId, is not set");
521 return BatchCreateRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
522 }
523 if (!request.RoomIdHasBeenSet())
524 {
525 AWS_LOGSTREAM_ERROR("BatchCreateRoomMembership", "Required field: RoomId, is not set");
526 return BatchCreateRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
527 }
528 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
529 Aws::StringStream ss;
530 uri.AddPathSegments("/accounts/");
531 uri.AddPathSegment(request.GetAccountId());
532 uri.AddPathSegments("/rooms/");
533 uri.AddPathSegment(request.GetRoomId());
534 uri.AddPathSegments("/memberships");
535 ss.str("?operation=batch-create");
536 uri.SetQueryString(ss.str());
537 return BatchCreateRoomMembershipOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
538 }
539
BatchCreateRoomMembershipCallable(const BatchCreateRoomMembershipRequest & request) const540 BatchCreateRoomMembershipOutcomeCallable ChimeClient::BatchCreateRoomMembershipCallable(const BatchCreateRoomMembershipRequest& request) const
541 {
542 auto task = Aws::MakeShared< std::packaged_task< BatchCreateRoomMembershipOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchCreateRoomMembership(request); } );
543 auto packagedFunction = [task]() { (*task)(); };
544 m_executor->Submit(packagedFunction);
545 return task->get_future();
546 }
547
BatchCreateRoomMembershipAsync(const BatchCreateRoomMembershipRequest & request,const BatchCreateRoomMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const548 void ChimeClient::BatchCreateRoomMembershipAsync(const BatchCreateRoomMembershipRequest& request, const BatchCreateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
549 {
550 m_executor->Submit( [this, request, handler, context](){ this->BatchCreateRoomMembershipAsyncHelper( request, handler, context ); } );
551 }
552
BatchCreateRoomMembershipAsyncHelper(const BatchCreateRoomMembershipRequest & request,const BatchCreateRoomMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const553 void ChimeClient::BatchCreateRoomMembershipAsyncHelper(const BatchCreateRoomMembershipRequest& request, const BatchCreateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
554 {
555 handler(this, request, BatchCreateRoomMembership(request), context);
556 }
557
BatchDeletePhoneNumber(const BatchDeletePhoneNumberRequest & request) const558 BatchDeletePhoneNumberOutcome ChimeClient::BatchDeletePhoneNumber(const BatchDeletePhoneNumberRequest& request) const
559 {
560 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
561 Aws::StringStream ss;
562 uri.AddPathSegments("/phone-numbers");
563 ss.str("?operation=batch-delete");
564 uri.SetQueryString(ss.str());
565 return BatchDeletePhoneNumberOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
566 }
567
BatchDeletePhoneNumberCallable(const BatchDeletePhoneNumberRequest & request) const568 BatchDeletePhoneNumberOutcomeCallable ChimeClient::BatchDeletePhoneNumberCallable(const BatchDeletePhoneNumberRequest& request) const
569 {
570 auto task = Aws::MakeShared< std::packaged_task< BatchDeletePhoneNumberOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchDeletePhoneNumber(request); } );
571 auto packagedFunction = [task]() { (*task)(); };
572 m_executor->Submit(packagedFunction);
573 return task->get_future();
574 }
575
BatchDeletePhoneNumberAsync(const BatchDeletePhoneNumberRequest & request,const BatchDeletePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const576 void ChimeClient::BatchDeletePhoneNumberAsync(const BatchDeletePhoneNumberRequest& request, const BatchDeletePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
577 {
578 m_executor->Submit( [this, request, handler, context](){ this->BatchDeletePhoneNumberAsyncHelper( request, handler, context ); } );
579 }
580
BatchDeletePhoneNumberAsyncHelper(const BatchDeletePhoneNumberRequest & request,const BatchDeletePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const581 void ChimeClient::BatchDeletePhoneNumberAsyncHelper(const BatchDeletePhoneNumberRequest& request, const BatchDeletePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
582 {
583 handler(this, request, BatchDeletePhoneNumber(request), context);
584 }
585
BatchSuspendUser(const BatchSuspendUserRequest & request) const586 BatchSuspendUserOutcome ChimeClient::BatchSuspendUser(const BatchSuspendUserRequest& request) const
587 {
588 if (!request.AccountIdHasBeenSet())
589 {
590 AWS_LOGSTREAM_ERROR("BatchSuspendUser", "Required field: AccountId, is not set");
591 return BatchSuspendUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
592 }
593 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
594 Aws::StringStream ss;
595 uri.AddPathSegments("/accounts/");
596 uri.AddPathSegment(request.GetAccountId());
597 uri.AddPathSegments("/users");
598 ss.str("?operation=suspend");
599 uri.SetQueryString(ss.str());
600 return BatchSuspendUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
601 }
602
BatchSuspendUserCallable(const BatchSuspendUserRequest & request) const603 BatchSuspendUserOutcomeCallable ChimeClient::BatchSuspendUserCallable(const BatchSuspendUserRequest& request) const
604 {
605 auto task = Aws::MakeShared< std::packaged_task< BatchSuspendUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchSuspendUser(request); } );
606 auto packagedFunction = [task]() { (*task)(); };
607 m_executor->Submit(packagedFunction);
608 return task->get_future();
609 }
610
BatchSuspendUserAsync(const BatchSuspendUserRequest & request,const BatchSuspendUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const611 void ChimeClient::BatchSuspendUserAsync(const BatchSuspendUserRequest& request, const BatchSuspendUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
612 {
613 m_executor->Submit( [this, request, handler, context](){ this->BatchSuspendUserAsyncHelper( request, handler, context ); } );
614 }
615
BatchSuspendUserAsyncHelper(const BatchSuspendUserRequest & request,const BatchSuspendUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const616 void ChimeClient::BatchSuspendUserAsyncHelper(const BatchSuspendUserRequest& request, const BatchSuspendUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
617 {
618 handler(this, request, BatchSuspendUser(request), context);
619 }
620
BatchUnsuspendUser(const BatchUnsuspendUserRequest & request) const621 BatchUnsuspendUserOutcome ChimeClient::BatchUnsuspendUser(const BatchUnsuspendUserRequest& request) const
622 {
623 if (!request.AccountIdHasBeenSet())
624 {
625 AWS_LOGSTREAM_ERROR("BatchUnsuspendUser", "Required field: AccountId, is not set");
626 return BatchUnsuspendUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
627 }
628 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
629 Aws::StringStream ss;
630 uri.AddPathSegments("/accounts/");
631 uri.AddPathSegment(request.GetAccountId());
632 uri.AddPathSegments("/users");
633 ss.str("?operation=unsuspend");
634 uri.SetQueryString(ss.str());
635 return BatchUnsuspendUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
636 }
637
BatchUnsuspendUserCallable(const BatchUnsuspendUserRequest & request) const638 BatchUnsuspendUserOutcomeCallable ChimeClient::BatchUnsuspendUserCallable(const BatchUnsuspendUserRequest& request) const
639 {
640 auto task = Aws::MakeShared< std::packaged_task< BatchUnsuspendUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchUnsuspendUser(request); } );
641 auto packagedFunction = [task]() { (*task)(); };
642 m_executor->Submit(packagedFunction);
643 return task->get_future();
644 }
645
BatchUnsuspendUserAsync(const BatchUnsuspendUserRequest & request,const BatchUnsuspendUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const646 void ChimeClient::BatchUnsuspendUserAsync(const BatchUnsuspendUserRequest& request, const BatchUnsuspendUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
647 {
648 m_executor->Submit( [this, request, handler, context](){ this->BatchUnsuspendUserAsyncHelper( request, handler, context ); } );
649 }
650
BatchUnsuspendUserAsyncHelper(const BatchUnsuspendUserRequest & request,const BatchUnsuspendUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const651 void ChimeClient::BatchUnsuspendUserAsyncHelper(const BatchUnsuspendUserRequest& request, const BatchUnsuspendUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
652 {
653 handler(this, request, BatchUnsuspendUser(request), context);
654 }
655
BatchUpdatePhoneNumber(const BatchUpdatePhoneNumberRequest & request) const656 BatchUpdatePhoneNumberOutcome ChimeClient::BatchUpdatePhoneNumber(const BatchUpdatePhoneNumberRequest& request) const
657 {
658 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
659 Aws::StringStream ss;
660 uri.AddPathSegments("/phone-numbers");
661 ss.str("?operation=batch-update");
662 uri.SetQueryString(ss.str());
663 return BatchUpdatePhoneNumberOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
664 }
665
BatchUpdatePhoneNumberCallable(const BatchUpdatePhoneNumberRequest & request) const666 BatchUpdatePhoneNumberOutcomeCallable ChimeClient::BatchUpdatePhoneNumberCallable(const BatchUpdatePhoneNumberRequest& request) const
667 {
668 auto task = Aws::MakeShared< std::packaged_task< BatchUpdatePhoneNumberOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchUpdatePhoneNumber(request); } );
669 auto packagedFunction = [task]() { (*task)(); };
670 m_executor->Submit(packagedFunction);
671 return task->get_future();
672 }
673
BatchUpdatePhoneNumberAsync(const BatchUpdatePhoneNumberRequest & request,const BatchUpdatePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const674 void ChimeClient::BatchUpdatePhoneNumberAsync(const BatchUpdatePhoneNumberRequest& request, const BatchUpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
675 {
676 m_executor->Submit( [this, request, handler, context](){ this->BatchUpdatePhoneNumberAsyncHelper( request, handler, context ); } );
677 }
678
BatchUpdatePhoneNumberAsyncHelper(const BatchUpdatePhoneNumberRequest & request,const BatchUpdatePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const679 void ChimeClient::BatchUpdatePhoneNumberAsyncHelper(const BatchUpdatePhoneNumberRequest& request, const BatchUpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
680 {
681 handler(this, request, BatchUpdatePhoneNumber(request), context);
682 }
683
BatchUpdateUser(const BatchUpdateUserRequest & request) const684 BatchUpdateUserOutcome ChimeClient::BatchUpdateUser(const BatchUpdateUserRequest& request) const
685 {
686 if (!request.AccountIdHasBeenSet())
687 {
688 AWS_LOGSTREAM_ERROR("BatchUpdateUser", "Required field: AccountId, is not set");
689 return BatchUpdateUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
690 }
691 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
692 uri.AddPathSegments("/accounts/");
693 uri.AddPathSegment(request.GetAccountId());
694 uri.AddPathSegments("/users");
695 return BatchUpdateUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
696 }
697
BatchUpdateUserCallable(const BatchUpdateUserRequest & request) const698 BatchUpdateUserOutcomeCallable ChimeClient::BatchUpdateUserCallable(const BatchUpdateUserRequest& request) const
699 {
700 auto task = Aws::MakeShared< std::packaged_task< BatchUpdateUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchUpdateUser(request); } );
701 auto packagedFunction = [task]() { (*task)(); };
702 m_executor->Submit(packagedFunction);
703 return task->get_future();
704 }
705
BatchUpdateUserAsync(const BatchUpdateUserRequest & request,const BatchUpdateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const706 void ChimeClient::BatchUpdateUserAsync(const BatchUpdateUserRequest& request, const BatchUpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
707 {
708 m_executor->Submit( [this, request, handler, context](){ this->BatchUpdateUserAsyncHelper( request, handler, context ); } );
709 }
710
BatchUpdateUserAsyncHelper(const BatchUpdateUserRequest & request,const BatchUpdateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const711 void ChimeClient::BatchUpdateUserAsyncHelper(const BatchUpdateUserRequest& request, const BatchUpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
712 {
713 handler(this, request, BatchUpdateUser(request), context);
714 }
715
CreateAccount(const CreateAccountRequest & request) const716 CreateAccountOutcome ChimeClient::CreateAccount(const CreateAccountRequest& request) const
717 {
718 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
719 uri.AddPathSegments("/accounts");
720 return CreateAccountOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
721 }
722
CreateAccountCallable(const CreateAccountRequest & request) const723 CreateAccountOutcomeCallable ChimeClient::CreateAccountCallable(const CreateAccountRequest& request) const
724 {
725 auto task = Aws::MakeShared< std::packaged_task< CreateAccountOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAccount(request); } );
726 auto packagedFunction = [task]() { (*task)(); };
727 m_executor->Submit(packagedFunction);
728 return task->get_future();
729 }
730
CreateAccountAsync(const CreateAccountRequest & request,const CreateAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const731 void ChimeClient::CreateAccountAsync(const CreateAccountRequest& request, const CreateAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
732 {
733 m_executor->Submit( [this, request, handler, context](){ this->CreateAccountAsyncHelper( request, handler, context ); } );
734 }
735
CreateAccountAsyncHelper(const CreateAccountRequest & request,const CreateAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const736 void ChimeClient::CreateAccountAsyncHelper(const CreateAccountRequest& request, const CreateAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
737 {
738 handler(this, request, CreateAccount(request), context);
739 }
740
CreateAppInstance(const CreateAppInstanceRequest & request) const741 CreateAppInstanceOutcome ChimeClient::CreateAppInstance(const CreateAppInstanceRequest& request) const
742 {
743 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
744 if (m_enableHostPrefixInjection)
745 {
746 uri.SetAuthority("identity-" + uri.GetAuthority());
747 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
748 {
749 AWS_LOGSTREAM_ERROR("CreateAppInstance", "Invalid DNS host: " << uri.GetAuthority());
750 return CreateAppInstanceOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
751 }
752 }
753 uri.AddPathSegments("/app-instances");
754 return CreateAppInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
755 }
756
CreateAppInstanceCallable(const CreateAppInstanceRequest & request) const757 CreateAppInstanceOutcomeCallable ChimeClient::CreateAppInstanceCallable(const CreateAppInstanceRequest& request) const
758 {
759 auto task = Aws::MakeShared< std::packaged_task< CreateAppInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAppInstance(request); } );
760 auto packagedFunction = [task]() { (*task)(); };
761 m_executor->Submit(packagedFunction);
762 return task->get_future();
763 }
764
CreateAppInstanceAsync(const CreateAppInstanceRequest & request,const CreateAppInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const765 void ChimeClient::CreateAppInstanceAsync(const CreateAppInstanceRequest& request, const CreateAppInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
766 {
767 m_executor->Submit( [this, request, handler, context](){ this->CreateAppInstanceAsyncHelper( request, handler, context ); } );
768 }
769
CreateAppInstanceAsyncHelper(const CreateAppInstanceRequest & request,const CreateAppInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const770 void ChimeClient::CreateAppInstanceAsyncHelper(const CreateAppInstanceRequest& request, const CreateAppInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
771 {
772 handler(this, request, CreateAppInstance(request), context);
773 }
774
CreateAppInstanceAdmin(const CreateAppInstanceAdminRequest & request) const775 CreateAppInstanceAdminOutcome ChimeClient::CreateAppInstanceAdmin(const CreateAppInstanceAdminRequest& request) const
776 {
777 if (!request.AppInstanceArnHasBeenSet())
778 {
779 AWS_LOGSTREAM_ERROR("CreateAppInstanceAdmin", "Required field: AppInstanceArn, is not set");
780 return CreateAppInstanceAdminOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
781 }
782 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
783 if (m_enableHostPrefixInjection)
784 {
785 uri.SetAuthority("identity-" + uri.GetAuthority());
786 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
787 {
788 AWS_LOGSTREAM_ERROR("CreateAppInstanceAdmin", "Invalid DNS host: " << uri.GetAuthority());
789 return CreateAppInstanceAdminOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
790 }
791 }
792 uri.AddPathSegments("/app-instances/");
793 uri.AddPathSegment(request.GetAppInstanceArn());
794 uri.AddPathSegments("/admins");
795 return CreateAppInstanceAdminOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
796 }
797
CreateAppInstanceAdminCallable(const CreateAppInstanceAdminRequest & request) const798 CreateAppInstanceAdminOutcomeCallable ChimeClient::CreateAppInstanceAdminCallable(const CreateAppInstanceAdminRequest& request) const
799 {
800 auto task = Aws::MakeShared< std::packaged_task< CreateAppInstanceAdminOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAppInstanceAdmin(request); } );
801 auto packagedFunction = [task]() { (*task)(); };
802 m_executor->Submit(packagedFunction);
803 return task->get_future();
804 }
805
CreateAppInstanceAdminAsync(const CreateAppInstanceAdminRequest & request,const CreateAppInstanceAdminResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const806 void ChimeClient::CreateAppInstanceAdminAsync(const CreateAppInstanceAdminRequest& request, const CreateAppInstanceAdminResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
807 {
808 m_executor->Submit( [this, request, handler, context](){ this->CreateAppInstanceAdminAsyncHelper( request, handler, context ); } );
809 }
810
CreateAppInstanceAdminAsyncHelper(const CreateAppInstanceAdminRequest & request,const CreateAppInstanceAdminResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const811 void ChimeClient::CreateAppInstanceAdminAsyncHelper(const CreateAppInstanceAdminRequest& request, const CreateAppInstanceAdminResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
812 {
813 handler(this, request, CreateAppInstanceAdmin(request), context);
814 }
815
CreateAppInstanceUser(const CreateAppInstanceUserRequest & request) const816 CreateAppInstanceUserOutcome ChimeClient::CreateAppInstanceUser(const CreateAppInstanceUserRequest& request) const
817 {
818 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
819 if (m_enableHostPrefixInjection)
820 {
821 uri.SetAuthority("identity-" + uri.GetAuthority());
822 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
823 {
824 AWS_LOGSTREAM_ERROR("CreateAppInstanceUser", "Invalid DNS host: " << uri.GetAuthority());
825 return CreateAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
826 }
827 }
828 uri.AddPathSegments("/app-instance-users");
829 return CreateAppInstanceUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
830 }
831
CreateAppInstanceUserCallable(const CreateAppInstanceUserRequest & request) const832 CreateAppInstanceUserOutcomeCallable ChimeClient::CreateAppInstanceUserCallable(const CreateAppInstanceUserRequest& request) const
833 {
834 auto task = Aws::MakeShared< std::packaged_task< CreateAppInstanceUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAppInstanceUser(request); } );
835 auto packagedFunction = [task]() { (*task)(); };
836 m_executor->Submit(packagedFunction);
837 return task->get_future();
838 }
839
CreateAppInstanceUserAsync(const CreateAppInstanceUserRequest & request,const CreateAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const840 void ChimeClient::CreateAppInstanceUserAsync(const CreateAppInstanceUserRequest& request, const CreateAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
841 {
842 m_executor->Submit( [this, request, handler, context](){ this->CreateAppInstanceUserAsyncHelper( request, handler, context ); } );
843 }
844
CreateAppInstanceUserAsyncHelper(const CreateAppInstanceUserRequest & request,const CreateAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const845 void ChimeClient::CreateAppInstanceUserAsyncHelper(const CreateAppInstanceUserRequest& request, const CreateAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
846 {
847 handler(this, request, CreateAppInstanceUser(request), context);
848 }
849
CreateAttendee(const CreateAttendeeRequest & request) const850 CreateAttendeeOutcome ChimeClient::CreateAttendee(const CreateAttendeeRequest& request) const
851 {
852 if (!request.MeetingIdHasBeenSet())
853 {
854 AWS_LOGSTREAM_ERROR("CreateAttendee", "Required field: MeetingId, is not set");
855 return CreateAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
856 }
857 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
858 uri.AddPathSegments("/meetings/");
859 uri.AddPathSegment(request.GetMeetingId());
860 uri.AddPathSegments("/attendees");
861 return CreateAttendeeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
862 }
863
CreateAttendeeCallable(const CreateAttendeeRequest & request) const864 CreateAttendeeOutcomeCallable ChimeClient::CreateAttendeeCallable(const CreateAttendeeRequest& request) const
865 {
866 auto task = Aws::MakeShared< std::packaged_task< CreateAttendeeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAttendee(request); } );
867 auto packagedFunction = [task]() { (*task)(); };
868 m_executor->Submit(packagedFunction);
869 return task->get_future();
870 }
871
CreateAttendeeAsync(const CreateAttendeeRequest & request,const CreateAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const872 void ChimeClient::CreateAttendeeAsync(const CreateAttendeeRequest& request, const CreateAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
873 {
874 m_executor->Submit( [this, request, handler, context](){ this->CreateAttendeeAsyncHelper( request, handler, context ); } );
875 }
876
CreateAttendeeAsyncHelper(const CreateAttendeeRequest & request,const CreateAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const877 void ChimeClient::CreateAttendeeAsyncHelper(const CreateAttendeeRequest& request, const CreateAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
878 {
879 handler(this, request, CreateAttendee(request), context);
880 }
881
CreateBot(const CreateBotRequest & request) const882 CreateBotOutcome ChimeClient::CreateBot(const CreateBotRequest& request) const
883 {
884 if (!request.AccountIdHasBeenSet())
885 {
886 AWS_LOGSTREAM_ERROR("CreateBot", "Required field: AccountId, is not set");
887 return CreateBotOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
888 }
889 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
890 uri.AddPathSegments("/accounts/");
891 uri.AddPathSegment(request.GetAccountId());
892 uri.AddPathSegments("/bots");
893 return CreateBotOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
894 }
895
CreateBotCallable(const CreateBotRequest & request) const896 CreateBotOutcomeCallable ChimeClient::CreateBotCallable(const CreateBotRequest& request) const
897 {
898 auto task = Aws::MakeShared< std::packaged_task< CreateBotOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateBot(request); } );
899 auto packagedFunction = [task]() { (*task)(); };
900 m_executor->Submit(packagedFunction);
901 return task->get_future();
902 }
903
CreateBotAsync(const CreateBotRequest & request,const CreateBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const904 void ChimeClient::CreateBotAsync(const CreateBotRequest& request, const CreateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
905 {
906 m_executor->Submit( [this, request, handler, context](){ this->CreateBotAsyncHelper( request, handler, context ); } );
907 }
908
CreateBotAsyncHelper(const CreateBotRequest & request,const CreateBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const909 void ChimeClient::CreateBotAsyncHelper(const CreateBotRequest& request, const CreateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
910 {
911 handler(this, request, CreateBot(request), context);
912 }
913
CreateChannel(const CreateChannelRequest & request) const914 CreateChannelOutcome ChimeClient::CreateChannel(const CreateChannelRequest& request) const
915 {
916 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
917 if (m_enableHostPrefixInjection)
918 {
919 uri.SetAuthority("messaging-" + uri.GetAuthority());
920 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
921 {
922 AWS_LOGSTREAM_ERROR("CreateChannel", "Invalid DNS host: " << uri.GetAuthority());
923 return CreateChannelOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
924 }
925 }
926 uri.AddPathSegments("/channels");
927 return CreateChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
928 }
929
CreateChannelCallable(const CreateChannelRequest & request) const930 CreateChannelOutcomeCallable ChimeClient::CreateChannelCallable(const CreateChannelRequest& request) const
931 {
932 auto task = Aws::MakeShared< std::packaged_task< CreateChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateChannel(request); } );
933 auto packagedFunction = [task]() { (*task)(); };
934 m_executor->Submit(packagedFunction);
935 return task->get_future();
936 }
937
CreateChannelAsync(const CreateChannelRequest & request,const CreateChannelResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const938 void ChimeClient::CreateChannelAsync(const CreateChannelRequest& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
939 {
940 m_executor->Submit( [this, request, handler, context](){ this->CreateChannelAsyncHelper( request, handler, context ); } );
941 }
942
CreateChannelAsyncHelper(const CreateChannelRequest & request,const CreateChannelResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const943 void ChimeClient::CreateChannelAsyncHelper(const CreateChannelRequest& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
944 {
945 handler(this, request, CreateChannel(request), context);
946 }
947
CreateChannelBan(const CreateChannelBanRequest & request) const948 CreateChannelBanOutcome ChimeClient::CreateChannelBan(const CreateChannelBanRequest& request) const
949 {
950 if (!request.ChannelArnHasBeenSet())
951 {
952 AWS_LOGSTREAM_ERROR("CreateChannelBan", "Required field: ChannelArn, is not set");
953 return CreateChannelBanOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
954 }
955 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
956 if (m_enableHostPrefixInjection)
957 {
958 uri.SetAuthority("messaging-" + uri.GetAuthority());
959 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
960 {
961 AWS_LOGSTREAM_ERROR("CreateChannelBan", "Invalid DNS host: " << uri.GetAuthority());
962 return CreateChannelBanOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
963 }
964 }
965 uri.AddPathSegments("/channels/");
966 uri.AddPathSegment(request.GetChannelArn());
967 uri.AddPathSegments("/bans");
968 return CreateChannelBanOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
969 }
970
CreateChannelBanCallable(const CreateChannelBanRequest & request) const971 CreateChannelBanOutcomeCallable ChimeClient::CreateChannelBanCallable(const CreateChannelBanRequest& request) const
972 {
973 auto task = Aws::MakeShared< std::packaged_task< CreateChannelBanOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateChannelBan(request); } );
974 auto packagedFunction = [task]() { (*task)(); };
975 m_executor->Submit(packagedFunction);
976 return task->get_future();
977 }
978
CreateChannelBanAsync(const CreateChannelBanRequest & request,const CreateChannelBanResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const979 void ChimeClient::CreateChannelBanAsync(const CreateChannelBanRequest& request, const CreateChannelBanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
980 {
981 m_executor->Submit( [this, request, handler, context](){ this->CreateChannelBanAsyncHelper( request, handler, context ); } );
982 }
983
CreateChannelBanAsyncHelper(const CreateChannelBanRequest & request,const CreateChannelBanResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const984 void ChimeClient::CreateChannelBanAsyncHelper(const CreateChannelBanRequest& request, const CreateChannelBanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
985 {
986 handler(this, request, CreateChannelBan(request), context);
987 }
988
CreateChannelMembership(const CreateChannelMembershipRequest & request) const989 CreateChannelMembershipOutcome ChimeClient::CreateChannelMembership(const CreateChannelMembershipRequest& request) const
990 {
991 if (!request.ChannelArnHasBeenSet())
992 {
993 AWS_LOGSTREAM_ERROR("CreateChannelMembership", "Required field: ChannelArn, is not set");
994 return CreateChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
995 }
996 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
997 if (m_enableHostPrefixInjection)
998 {
999 uri.SetAuthority("messaging-" + uri.GetAuthority());
1000 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1001 {
1002 AWS_LOGSTREAM_ERROR("CreateChannelMembership", "Invalid DNS host: " << uri.GetAuthority());
1003 return CreateChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1004 }
1005 }
1006 uri.AddPathSegments("/channels/");
1007 uri.AddPathSegment(request.GetChannelArn());
1008 uri.AddPathSegments("/memberships");
1009 return CreateChannelMembershipOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1010 }
1011
CreateChannelMembershipCallable(const CreateChannelMembershipRequest & request) const1012 CreateChannelMembershipOutcomeCallable ChimeClient::CreateChannelMembershipCallable(const CreateChannelMembershipRequest& request) const
1013 {
1014 auto task = Aws::MakeShared< std::packaged_task< CreateChannelMembershipOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateChannelMembership(request); } );
1015 auto packagedFunction = [task]() { (*task)(); };
1016 m_executor->Submit(packagedFunction);
1017 return task->get_future();
1018 }
1019
CreateChannelMembershipAsync(const CreateChannelMembershipRequest & request,const CreateChannelMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1020 void ChimeClient::CreateChannelMembershipAsync(const CreateChannelMembershipRequest& request, const CreateChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1021 {
1022 m_executor->Submit( [this, request, handler, context](){ this->CreateChannelMembershipAsyncHelper( request, handler, context ); } );
1023 }
1024
CreateChannelMembershipAsyncHelper(const CreateChannelMembershipRequest & request,const CreateChannelMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1025 void ChimeClient::CreateChannelMembershipAsyncHelper(const CreateChannelMembershipRequest& request, const CreateChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1026 {
1027 handler(this, request, CreateChannelMembership(request), context);
1028 }
1029
CreateChannelModerator(const CreateChannelModeratorRequest & request) const1030 CreateChannelModeratorOutcome ChimeClient::CreateChannelModerator(const CreateChannelModeratorRequest& request) const
1031 {
1032 if (!request.ChannelArnHasBeenSet())
1033 {
1034 AWS_LOGSTREAM_ERROR("CreateChannelModerator", "Required field: ChannelArn, is not set");
1035 return CreateChannelModeratorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
1036 }
1037 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1038 if (m_enableHostPrefixInjection)
1039 {
1040 uri.SetAuthority("messaging-" + uri.GetAuthority());
1041 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1042 {
1043 AWS_LOGSTREAM_ERROR("CreateChannelModerator", "Invalid DNS host: " << uri.GetAuthority());
1044 return CreateChannelModeratorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1045 }
1046 }
1047 uri.AddPathSegments("/channels/");
1048 uri.AddPathSegment(request.GetChannelArn());
1049 uri.AddPathSegments("/moderators");
1050 return CreateChannelModeratorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1051 }
1052
CreateChannelModeratorCallable(const CreateChannelModeratorRequest & request) const1053 CreateChannelModeratorOutcomeCallable ChimeClient::CreateChannelModeratorCallable(const CreateChannelModeratorRequest& request) const
1054 {
1055 auto task = Aws::MakeShared< std::packaged_task< CreateChannelModeratorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateChannelModerator(request); } );
1056 auto packagedFunction = [task]() { (*task)(); };
1057 m_executor->Submit(packagedFunction);
1058 return task->get_future();
1059 }
1060
CreateChannelModeratorAsync(const CreateChannelModeratorRequest & request,const CreateChannelModeratorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1061 void ChimeClient::CreateChannelModeratorAsync(const CreateChannelModeratorRequest& request, const CreateChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1062 {
1063 m_executor->Submit( [this, request, handler, context](){ this->CreateChannelModeratorAsyncHelper( request, handler, context ); } );
1064 }
1065
CreateChannelModeratorAsyncHelper(const CreateChannelModeratorRequest & request,const CreateChannelModeratorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1066 void ChimeClient::CreateChannelModeratorAsyncHelper(const CreateChannelModeratorRequest& request, const CreateChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1067 {
1068 handler(this, request, CreateChannelModerator(request), context);
1069 }
1070
CreateMediaCapturePipeline(const CreateMediaCapturePipelineRequest & request) const1071 CreateMediaCapturePipelineOutcome ChimeClient::CreateMediaCapturePipeline(const CreateMediaCapturePipelineRequest& request) const
1072 {
1073 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1074 uri.AddPathSegments("/media-capture-pipelines");
1075 return CreateMediaCapturePipelineOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1076 }
1077
CreateMediaCapturePipelineCallable(const CreateMediaCapturePipelineRequest & request) const1078 CreateMediaCapturePipelineOutcomeCallable ChimeClient::CreateMediaCapturePipelineCallable(const CreateMediaCapturePipelineRequest& request) const
1079 {
1080 auto task = Aws::MakeShared< std::packaged_task< CreateMediaCapturePipelineOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateMediaCapturePipeline(request); } );
1081 auto packagedFunction = [task]() { (*task)(); };
1082 m_executor->Submit(packagedFunction);
1083 return task->get_future();
1084 }
1085
CreateMediaCapturePipelineAsync(const CreateMediaCapturePipelineRequest & request,const CreateMediaCapturePipelineResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1086 void ChimeClient::CreateMediaCapturePipelineAsync(const CreateMediaCapturePipelineRequest& request, const CreateMediaCapturePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1087 {
1088 m_executor->Submit( [this, request, handler, context](){ this->CreateMediaCapturePipelineAsyncHelper( request, handler, context ); } );
1089 }
1090
CreateMediaCapturePipelineAsyncHelper(const CreateMediaCapturePipelineRequest & request,const CreateMediaCapturePipelineResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1091 void ChimeClient::CreateMediaCapturePipelineAsyncHelper(const CreateMediaCapturePipelineRequest& request, const CreateMediaCapturePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1092 {
1093 handler(this, request, CreateMediaCapturePipeline(request), context);
1094 }
1095
CreateMeeting(const CreateMeetingRequest & request) const1096 CreateMeetingOutcome ChimeClient::CreateMeeting(const CreateMeetingRequest& request) const
1097 {
1098 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1099 uri.AddPathSegments("/meetings");
1100 return CreateMeetingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1101 }
1102
CreateMeetingCallable(const CreateMeetingRequest & request) const1103 CreateMeetingOutcomeCallable ChimeClient::CreateMeetingCallable(const CreateMeetingRequest& request) const
1104 {
1105 auto task = Aws::MakeShared< std::packaged_task< CreateMeetingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateMeeting(request); } );
1106 auto packagedFunction = [task]() { (*task)(); };
1107 m_executor->Submit(packagedFunction);
1108 return task->get_future();
1109 }
1110
CreateMeetingAsync(const CreateMeetingRequest & request,const CreateMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1111 void ChimeClient::CreateMeetingAsync(const CreateMeetingRequest& request, const CreateMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1112 {
1113 m_executor->Submit( [this, request, handler, context](){ this->CreateMeetingAsyncHelper( request, handler, context ); } );
1114 }
1115
CreateMeetingAsyncHelper(const CreateMeetingRequest & request,const CreateMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1116 void ChimeClient::CreateMeetingAsyncHelper(const CreateMeetingRequest& request, const CreateMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1117 {
1118 handler(this, request, CreateMeeting(request), context);
1119 }
1120
CreateMeetingDialOut(const CreateMeetingDialOutRequest & request) const1121 CreateMeetingDialOutOutcome ChimeClient::CreateMeetingDialOut(const CreateMeetingDialOutRequest& request) const
1122 {
1123 if (!request.MeetingIdHasBeenSet())
1124 {
1125 AWS_LOGSTREAM_ERROR("CreateMeetingDialOut", "Required field: MeetingId, is not set");
1126 return CreateMeetingDialOutOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
1127 }
1128 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1129 uri.AddPathSegments("/meetings/");
1130 uri.AddPathSegment(request.GetMeetingId());
1131 uri.AddPathSegments("/dial-outs");
1132 return CreateMeetingDialOutOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1133 }
1134
CreateMeetingDialOutCallable(const CreateMeetingDialOutRequest & request) const1135 CreateMeetingDialOutOutcomeCallable ChimeClient::CreateMeetingDialOutCallable(const CreateMeetingDialOutRequest& request) const
1136 {
1137 auto task = Aws::MakeShared< std::packaged_task< CreateMeetingDialOutOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateMeetingDialOut(request); } );
1138 auto packagedFunction = [task]() { (*task)(); };
1139 m_executor->Submit(packagedFunction);
1140 return task->get_future();
1141 }
1142
CreateMeetingDialOutAsync(const CreateMeetingDialOutRequest & request,const CreateMeetingDialOutResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1143 void ChimeClient::CreateMeetingDialOutAsync(const CreateMeetingDialOutRequest& request, const CreateMeetingDialOutResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1144 {
1145 m_executor->Submit( [this, request, handler, context](){ this->CreateMeetingDialOutAsyncHelper( request, handler, context ); } );
1146 }
1147
CreateMeetingDialOutAsyncHelper(const CreateMeetingDialOutRequest & request,const CreateMeetingDialOutResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1148 void ChimeClient::CreateMeetingDialOutAsyncHelper(const CreateMeetingDialOutRequest& request, const CreateMeetingDialOutResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1149 {
1150 handler(this, request, CreateMeetingDialOut(request), context);
1151 }
1152
CreateMeetingWithAttendees(const CreateMeetingWithAttendeesRequest & request) const1153 CreateMeetingWithAttendeesOutcome ChimeClient::CreateMeetingWithAttendees(const CreateMeetingWithAttendeesRequest& request) const
1154 {
1155 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1156 Aws::StringStream ss;
1157 uri.AddPathSegments("/meetings");
1158 ss.str("?operation=create-attendees");
1159 uri.SetQueryString(ss.str());
1160 return CreateMeetingWithAttendeesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1161 }
1162
CreateMeetingWithAttendeesCallable(const CreateMeetingWithAttendeesRequest & request) const1163 CreateMeetingWithAttendeesOutcomeCallable ChimeClient::CreateMeetingWithAttendeesCallable(const CreateMeetingWithAttendeesRequest& request) const
1164 {
1165 auto task = Aws::MakeShared< std::packaged_task< CreateMeetingWithAttendeesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateMeetingWithAttendees(request); } );
1166 auto packagedFunction = [task]() { (*task)(); };
1167 m_executor->Submit(packagedFunction);
1168 return task->get_future();
1169 }
1170
CreateMeetingWithAttendeesAsync(const CreateMeetingWithAttendeesRequest & request,const CreateMeetingWithAttendeesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1171 void ChimeClient::CreateMeetingWithAttendeesAsync(const CreateMeetingWithAttendeesRequest& request, const CreateMeetingWithAttendeesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1172 {
1173 m_executor->Submit( [this, request, handler, context](){ this->CreateMeetingWithAttendeesAsyncHelper( request, handler, context ); } );
1174 }
1175
CreateMeetingWithAttendeesAsyncHelper(const CreateMeetingWithAttendeesRequest & request,const CreateMeetingWithAttendeesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1176 void ChimeClient::CreateMeetingWithAttendeesAsyncHelper(const CreateMeetingWithAttendeesRequest& request, const CreateMeetingWithAttendeesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1177 {
1178 handler(this, request, CreateMeetingWithAttendees(request), context);
1179 }
1180
CreatePhoneNumberOrder(const CreatePhoneNumberOrderRequest & request) const1181 CreatePhoneNumberOrderOutcome ChimeClient::CreatePhoneNumberOrder(const CreatePhoneNumberOrderRequest& request) const
1182 {
1183 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1184 uri.AddPathSegments("/phone-number-orders");
1185 return CreatePhoneNumberOrderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1186 }
1187
CreatePhoneNumberOrderCallable(const CreatePhoneNumberOrderRequest & request) const1188 CreatePhoneNumberOrderOutcomeCallable ChimeClient::CreatePhoneNumberOrderCallable(const CreatePhoneNumberOrderRequest& request) const
1189 {
1190 auto task = Aws::MakeShared< std::packaged_task< CreatePhoneNumberOrderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreatePhoneNumberOrder(request); } );
1191 auto packagedFunction = [task]() { (*task)(); };
1192 m_executor->Submit(packagedFunction);
1193 return task->get_future();
1194 }
1195
CreatePhoneNumberOrderAsync(const CreatePhoneNumberOrderRequest & request,const CreatePhoneNumberOrderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1196 void ChimeClient::CreatePhoneNumberOrderAsync(const CreatePhoneNumberOrderRequest& request, const CreatePhoneNumberOrderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1197 {
1198 m_executor->Submit( [this, request, handler, context](){ this->CreatePhoneNumberOrderAsyncHelper( request, handler, context ); } );
1199 }
1200
CreatePhoneNumberOrderAsyncHelper(const CreatePhoneNumberOrderRequest & request,const CreatePhoneNumberOrderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1201 void ChimeClient::CreatePhoneNumberOrderAsyncHelper(const CreatePhoneNumberOrderRequest& request, const CreatePhoneNumberOrderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1202 {
1203 handler(this, request, CreatePhoneNumberOrder(request), context);
1204 }
1205
CreateProxySession(const CreateProxySessionRequest & request) const1206 CreateProxySessionOutcome ChimeClient::CreateProxySession(const CreateProxySessionRequest& request) const
1207 {
1208 if (!request.VoiceConnectorIdHasBeenSet())
1209 {
1210 AWS_LOGSTREAM_ERROR("CreateProxySession", "Required field: VoiceConnectorId, is not set");
1211 return CreateProxySessionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
1212 }
1213 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1214 uri.AddPathSegments("/voice-connectors/");
1215 uri.AddPathSegment(request.GetVoiceConnectorId());
1216 uri.AddPathSegments("/proxy-sessions");
1217 return CreateProxySessionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1218 }
1219
CreateProxySessionCallable(const CreateProxySessionRequest & request) const1220 CreateProxySessionOutcomeCallable ChimeClient::CreateProxySessionCallable(const CreateProxySessionRequest& request) const
1221 {
1222 auto task = Aws::MakeShared< std::packaged_task< CreateProxySessionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateProxySession(request); } );
1223 auto packagedFunction = [task]() { (*task)(); };
1224 m_executor->Submit(packagedFunction);
1225 return task->get_future();
1226 }
1227
CreateProxySessionAsync(const CreateProxySessionRequest & request,const CreateProxySessionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1228 void ChimeClient::CreateProxySessionAsync(const CreateProxySessionRequest& request, const CreateProxySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1229 {
1230 m_executor->Submit( [this, request, handler, context](){ this->CreateProxySessionAsyncHelper( request, handler, context ); } );
1231 }
1232
CreateProxySessionAsyncHelper(const CreateProxySessionRequest & request,const CreateProxySessionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1233 void ChimeClient::CreateProxySessionAsyncHelper(const CreateProxySessionRequest& request, const CreateProxySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1234 {
1235 handler(this, request, CreateProxySession(request), context);
1236 }
1237
CreateRoom(const CreateRoomRequest & request) const1238 CreateRoomOutcome ChimeClient::CreateRoom(const CreateRoomRequest& request) const
1239 {
1240 if (!request.AccountIdHasBeenSet())
1241 {
1242 AWS_LOGSTREAM_ERROR("CreateRoom", "Required field: AccountId, is not set");
1243 return CreateRoomOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
1244 }
1245 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1246 uri.AddPathSegments("/accounts/");
1247 uri.AddPathSegment(request.GetAccountId());
1248 uri.AddPathSegments("/rooms");
1249 return CreateRoomOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1250 }
1251
CreateRoomCallable(const CreateRoomRequest & request) const1252 CreateRoomOutcomeCallable ChimeClient::CreateRoomCallable(const CreateRoomRequest& request) const
1253 {
1254 auto task = Aws::MakeShared< std::packaged_task< CreateRoomOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateRoom(request); } );
1255 auto packagedFunction = [task]() { (*task)(); };
1256 m_executor->Submit(packagedFunction);
1257 return task->get_future();
1258 }
1259
CreateRoomAsync(const CreateRoomRequest & request,const CreateRoomResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1260 void ChimeClient::CreateRoomAsync(const CreateRoomRequest& request, const CreateRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1261 {
1262 m_executor->Submit( [this, request, handler, context](){ this->CreateRoomAsyncHelper( request, handler, context ); } );
1263 }
1264
CreateRoomAsyncHelper(const CreateRoomRequest & request,const CreateRoomResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1265 void ChimeClient::CreateRoomAsyncHelper(const CreateRoomRequest& request, const CreateRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1266 {
1267 handler(this, request, CreateRoom(request), context);
1268 }
1269
CreateRoomMembership(const CreateRoomMembershipRequest & request) const1270 CreateRoomMembershipOutcome ChimeClient::CreateRoomMembership(const CreateRoomMembershipRequest& request) const
1271 {
1272 if (!request.AccountIdHasBeenSet())
1273 {
1274 AWS_LOGSTREAM_ERROR("CreateRoomMembership", "Required field: AccountId, is not set");
1275 return CreateRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
1276 }
1277 if (!request.RoomIdHasBeenSet())
1278 {
1279 AWS_LOGSTREAM_ERROR("CreateRoomMembership", "Required field: RoomId, is not set");
1280 return CreateRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
1281 }
1282 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1283 uri.AddPathSegments("/accounts/");
1284 uri.AddPathSegment(request.GetAccountId());
1285 uri.AddPathSegments("/rooms/");
1286 uri.AddPathSegment(request.GetRoomId());
1287 uri.AddPathSegments("/memberships");
1288 return CreateRoomMembershipOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1289 }
1290
CreateRoomMembershipCallable(const CreateRoomMembershipRequest & request) const1291 CreateRoomMembershipOutcomeCallable ChimeClient::CreateRoomMembershipCallable(const CreateRoomMembershipRequest& request) const
1292 {
1293 auto task = Aws::MakeShared< std::packaged_task< CreateRoomMembershipOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateRoomMembership(request); } );
1294 auto packagedFunction = [task]() { (*task)(); };
1295 m_executor->Submit(packagedFunction);
1296 return task->get_future();
1297 }
1298
CreateRoomMembershipAsync(const CreateRoomMembershipRequest & request,const CreateRoomMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1299 void ChimeClient::CreateRoomMembershipAsync(const CreateRoomMembershipRequest& request, const CreateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1300 {
1301 m_executor->Submit( [this, request, handler, context](){ this->CreateRoomMembershipAsyncHelper( request, handler, context ); } );
1302 }
1303
CreateRoomMembershipAsyncHelper(const CreateRoomMembershipRequest & request,const CreateRoomMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1304 void ChimeClient::CreateRoomMembershipAsyncHelper(const CreateRoomMembershipRequest& request, const CreateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1305 {
1306 handler(this, request, CreateRoomMembership(request), context);
1307 }
1308
CreateSipMediaApplication(const CreateSipMediaApplicationRequest & request) const1309 CreateSipMediaApplicationOutcome ChimeClient::CreateSipMediaApplication(const CreateSipMediaApplicationRequest& request) const
1310 {
1311 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1312 uri.AddPathSegments("/sip-media-applications");
1313 return CreateSipMediaApplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1314 }
1315
CreateSipMediaApplicationCallable(const CreateSipMediaApplicationRequest & request) const1316 CreateSipMediaApplicationOutcomeCallable ChimeClient::CreateSipMediaApplicationCallable(const CreateSipMediaApplicationRequest& request) const
1317 {
1318 auto task = Aws::MakeShared< std::packaged_task< CreateSipMediaApplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateSipMediaApplication(request); } );
1319 auto packagedFunction = [task]() { (*task)(); };
1320 m_executor->Submit(packagedFunction);
1321 return task->get_future();
1322 }
1323
CreateSipMediaApplicationAsync(const CreateSipMediaApplicationRequest & request,const CreateSipMediaApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1324 void ChimeClient::CreateSipMediaApplicationAsync(const CreateSipMediaApplicationRequest& request, const CreateSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1325 {
1326 m_executor->Submit( [this, request, handler, context](){ this->CreateSipMediaApplicationAsyncHelper( request, handler, context ); } );
1327 }
1328
CreateSipMediaApplicationAsyncHelper(const CreateSipMediaApplicationRequest & request,const CreateSipMediaApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1329 void ChimeClient::CreateSipMediaApplicationAsyncHelper(const CreateSipMediaApplicationRequest& request, const CreateSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1330 {
1331 handler(this, request, CreateSipMediaApplication(request), context);
1332 }
1333
CreateSipMediaApplicationCall(const CreateSipMediaApplicationCallRequest & request) const1334 CreateSipMediaApplicationCallOutcome ChimeClient::CreateSipMediaApplicationCall(const CreateSipMediaApplicationCallRequest& request) const
1335 {
1336 if (!request.SipMediaApplicationIdHasBeenSet())
1337 {
1338 AWS_LOGSTREAM_ERROR("CreateSipMediaApplicationCall", "Required field: SipMediaApplicationId, is not set");
1339 return CreateSipMediaApplicationCallOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipMediaApplicationId]", false));
1340 }
1341 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1342 uri.AddPathSegments("/sip-media-applications/");
1343 uri.AddPathSegment(request.GetSipMediaApplicationId());
1344 uri.AddPathSegments("/calls");
1345 return CreateSipMediaApplicationCallOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1346 }
1347
CreateSipMediaApplicationCallCallable(const CreateSipMediaApplicationCallRequest & request) const1348 CreateSipMediaApplicationCallOutcomeCallable ChimeClient::CreateSipMediaApplicationCallCallable(const CreateSipMediaApplicationCallRequest& request) const
1349 {
1350 auto task = Aws::MakeShared< std::packaged_task< CreateSipMediaApplicationCallOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateSipMediaApplicationCall(request); } );
1351 auto packagedFunction = [task]() { (*task)(); };
1352 m_executor->Submit(packagedFunction);
1353 return task->get_future();
1354 }
1355
CreateSipMediaApplicationCallAsync(const CreateSipMediaApplicationCallRequest & request,const CreateSipMediaApplicationCallResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1356 void ChimeClient::CreateSipMediaApplicationCallAsync(const CreateSipMediaApplicationCallRequest& request, const CreateSipMediaApplicationCallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1357 {
1358 m_executor->Submit( [this, request, handler, context](){ this->CreateSipMediaApplicationCallAsyncHelper( request, handler, context ); } );
1359 }
1360
CreateSipMediaApplicationCallAsyncHelper(const CreateSipMediaApplicationCallRequest & request,const CreateSipMediaApplicationCallResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1361 void ChimeClient::CreateSipMediaApplicationCallAsyncHelper(const CreateSipMediaApplicationCallRequest& request, const CreateSipMediaApplicationCallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1362 {
1363 handler(this, request, CreateSipMediaApplicationCall(request), context);
1364 }
1365
CreateSipRule(const CreateSipRuleRequest & request) const1366 CreateSipRuleOutcome ChimeClient::CreateSipRule(const CreateSipRuleRequest& request) const
1367 {
1368 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1369 uri.AddPathSegments("/sip-rules");
1370 return CreateSipRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1371 }
1372
CreateSipRuleCallable(const CreateSipRuleRequest & request) const1373 CreateSipRuleOutcomeCallable ChimeClient::CreateSipRuleCallable(const CreateSipRuleRequest& request) const
1374 {
1375 auto task = Aws::MakeShared< std::packaged_task< CreateSipRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateSipRule(request); } );
1376 auto packagedFunction = [task]() { (*task)(); };
1377 m_executor->Submit(packagedFunction);
1378 return task->get_future();
1379 }
1380
CreateSipRuleAsync(const CreateSipRuleRequest & request,const CreateSipRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1381 void ChimeClient::CreateSipRuleAsync(const CreateSipRuleRequest& request, const CreateSipRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1382 {
1383 m_executor->Submit( [this, request, handler, context](){ this->CreateSipRuleAsyncHelper( request, handler, context ); } );
1384 }
1385
CreateSipRuleAsyncHelper(const CreateSipRuleRequest & request,const CreateSipRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1386 void ChimeClient::CreateSipRuleAsyncHelper(const CreateSipRuleRequest& request, const CreateSipRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1387 {
1388 handler(this, request, CreateSipRule(request), context);
1389 }
1390
CreateUser(const CreateUserRequest & request) const1391 CreateUserOutcome ChimeClient::CreateUser(const CreateUserRequest& request) const
1392 {
1393 if (!request.AccountIdHasBeenSet())
1394 {
1395 AWS_LOGSTREAM_ERROR("CreateUser", "Required field: AccountId, is not set");
1396 return CreateUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
1397 }
1398 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1399 Aws::StringStream ss;
1400 uri.AddPathSegments("/accounts/");
1401 uri.AddPathSegment(request.GetAccountId());
1402 uri.AddPathSegments("/users");
1403 ss.str("?operation=create");
1404 uri.SetQueryString(ss.str());
1405 return CreateUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1406 }
1407
CreateUserCallable(const CreateUserRequest & request) const1408 CreateUserOutcomeCallable ChimeClient::CreateUserCallable(const CreateUserRequest& request) const
1409 {
1410 auto task = Aws::MakeShared< std::packaged_task< CreateUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateUser(request); } );
1411 auto packagedFunction = [task]() { (*task)(); };
1412 m_executor->Submit(packagedFunction);
1413 return task->get_future();
1414 }
1415
CreateUserAsync(const CreateUserRequest & request,const CreateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1416 void ChimeClient::CreateUserAsync(const CreateUserRequest& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1417 {
1418 m_executor->Submit( [this, request, handler, context](){ this->CreateUserAsyncHelper( request, handler, context ); } );
1419 }
1420
CreateUserAsyncHelper(const CreateUserRequest & request,const CreateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1421 void ChimeClient::CreateUserAsyncHelper(const CreateUserRequest& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1422 {
1423 handler(this, request, CreateUser(request), context);
1424 }
1425
CreateVoiceConnector(const CreateVoiceConnectorRequest & request) const1426 CreateVoiceConnectorOutcome ChimeClient::CreateVoiceConnector(const CreateVoiceConnectorRequest& request) const
1427 {
1428 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1429 uri.AddPathSegments("/voice-connectors");
1430 return CreateVoiceConnectorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1431 }
1432
CreateVoiceConnectorCallable(const CreateVoiceConnectorRequest & request) const1433 CreateVoiceConnectorOutcomeCallable ChimeClient::CreateVoiceConnectorCallable(const CreateVoiceConnectorRequest& request) const
1434 {
1435 auto task = Aws::MakeShared< std::packaged_task< CreateVoiceConnectorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateVoiceConnector(request); } );
1436 auto packagedFunction = [task]() { (*task)(); };
1437 m_executor->Submit(packagedFunction);
1438 return task->get_future();
1439 }
1440
CreateVoiceConnectorAsync(const CreateVoiceConnectorRequest & request,const CreateVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1441 void ChimeClient::CreateVoiceConnectorAsync(const CreateVoiceConnectorRequest& request, const CreateVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1442 {
1443 m_executor->Submit( [this, request, handler, context](){ this->CreateVoiceConnectorAsyncHelper( request, handler, context ); } );
1444 }
1445
CreateVoiceConnectorAsyncHelper(const CreateVoiceConnectorRequest & request,const CreateVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1446 void ChimeClient::CreateVoiceConnectorAsyncHelper(const CreateVoiceConnectorRequest& request, const CreateVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1447 {
1448 handler(this, request, CreateVoiceConnector(request), context);
1449 }
1450
CreateVoiceConnectorGroup(const CreateVoiceConnectorGroupRequest & request) const1451 CreateVoiceConnectorGroupOutcome ChimeClient::CreateVoiceConnectorGroup(const CreateVoiceConnectorGroupRequest& request) const
1452 {
1453 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1454 uri.AddPathSegments("/voice-connector-groups");
1455 return CreateVoiceConnectorGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1456 }
1457
CreateVoiceConnectorGroupCallable(const CreateVoiceConnectorGroupRequest & request) const1458 CreateVoiceConnectorGroupOutcomeCallable ChimeClient::CreateVoiceConnectorGroupCallable(const CreateVoiceConnectorGroupRequest& request) const
1459 {
1460 auto task = Aws::MakeShared< std::packaged_task< CreateVoiceConnectorGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateVoiceConnectorGroup(request); } );
1461 auto packagedFunction = [task]() { (*task)(); };
1462 m_executor->Submit(packagedFunction);
1463 return task->get_future();
1464 }
1465
CreateVoiceConnectorGroupAsync(const CreateVoiceConnectorGroupRequest & request,const CreateVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1466 void ChimeClient::CreateVoiceConnectorGroupAsync(const CreateVoiceConnectorGroupRequest& request, const CreateVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1467 {
1468 m_executor->Submit( [this, request, handler, context](){ this->CreateVoiceConnectorGroupAsyncHelper( request, handler, context ); } );
1469 }
1470
CreateVoiceConnectorGroupAsyncHelper(const CreateVoiceConnectorGroupRequest & request,const CreateVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1471 void ChimeClient::CreateVoiceConnectorGroupAsyncHelper(const CreateVoiceConnectorGroupRequest& request, const CreateVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1472 {
1473 handler(this, request, CreateVoiceConnectorGroup(request), context);
1474 }
1475
DeleteAccount(const DeleteAccountRequest & request) const1476 DeleteAccountOutcome ChimeClient::DeleteAccount(const DeleteAccountRequest& request) const
1477 {
1478 if (!request.AccountIdHasBeenSet())
1479 {
1480 AWS_LOGSTREAM_ERROR("DeleteAccount", "Required field: AccountId, is not set");
1481 return DeleteAccountOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
1482 }
1483 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1484 uri.AddPathSegments("/accounts/");
1485 uri.AddPathSegment(request.GetAccountId());
1486 return DeleteAccountOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1487 }
1488
DeleteAccountCallable(const DeleteAccountRequest & request) const1489 DeleteAccountOutcomeCallable ChimeClient::DeleteAccountCallable(const DeleteAccountRequest& request) const
1490 {
1491 auto task = Aws::MakeShared< std::packaged_task< DeleteAccountOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAccount(request); } );
1492 auto packagedFunction = [task]() { (*task)(); };
1493 m_executor->Submit(packagedFunction);
1494 return task->get_future();
1495 }
1496
DeleteAccountAsync(const DeleteAccountRequest & request,const DeleteAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1497 void ChimeClient::DeleteAccountAsync(const DeleteAccountRequest& request, const DeleteAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1498 {
1499 m_executor->Submit( [this, request, handler, context](){ this->DeleteAccountAsyncHelper( request, handler, context ); } );
1500 }
1501
DeleteAccountAsyncHelper(const DeleteAccountRequest & request,const DeleteAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1502 void ChimeClient::DeleteAccountAsyncHelper(const DeleteAccountRequest& request, const DeleteAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1503 {
1504 handler(this, request, DeleteAccount(request), context);
1505 }
1506
DeleteAppInstance(const DeleteAppInstanceRequest & request) const1507 DeleteAppInstanceOutcome ChimeClient::DeleteAppInstance(const DeleteAppInstanceRequest& request) const
1508 {
1509 if (!request.AppInstanceArnHasBeenSet())
1510 {
1511 AWS_LOGSTREAM_ERROR("DeleteAppInstance", "Required field: AppInstanceArn, is not set");
1512 return DeleteAppInstanceOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
1513 }
1514 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1515 if (m_enableHostPrefixInjection)
1516 {
1517 uri.SetAuthority("identity-" + uri.GetAuthority());
1518 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1519 {
1520 AWS_LOGSTREAM_ERROR("DeleteAppInstance", "Invalid DNS host: " << uri.GetAuthority());
1521 return DeleteAppInstanceOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1522 }
1523 }
1524 uri.AddPathSegments("/app-instances/");
1525 uri.AddPathSegment(request.GetAppInstanceArn());
1526 return DeleteAppInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1527 }
1528
DeleteAppInstanceCallable(const DeleteAppInstanceRequest & request) const1529 DeleteAppInstanceOutcomeCallable ChimeClient::DeleteAppInstanceCallable(const DeleteAppInstanceRequest& request) const
1530 {
1531 auto task = Aws::MakeShared< std::packaged_task< DeleteAppInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAppInstance(request); } );
1532 auto packagedFunction = [task]() { (*task)(); };
1533 m_executor->Submit(packagedFunction);
1534 return task->get_future();
1535 }
1536
DeleteAppInstanceAsync(const DeleteAppInstanceRequest & request,const DeleteAppInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1537 void ChimeClient::DeleteAppInstanceAsync(const DeleteAppInstanceRequest& request, const DeleteAppInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1538 {
1539 m_executor->Submit( [this, request, handler, context](){ this->DeleteAppInstanceAsyncHelper( request, handler, context ); } );
1540 }
1541
DeleteAppInstanceAsyncHelper(const DeleteAppInstanceRequest & request,const DeleteAppInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1542 void ChimeClient::DeleteAppInstanceAsyncHelper(const DeleteAppInstanceRequest& request, const DeleteAppInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1543 {
1544 handler(this, request, DeleteAppInstance(request), context);
1545 }
1546
DeleteAppInstanceAdmin(const DeleteAppInstanceAdminRequest & request) const1547 DeleteAppInstanceAdminOutcome ChimeClient::DeleteAppInstanceAdmin(const DeleteAppInstanceAdminRequest& request) const
1548 {
1549 if (!request.AppInstanceAdminArnHasBeenSet())
1550 {
1551 AWS_LOGSTREAM_ERROR("DeleteAppInstanceAdmin", "Required field: AppInstanceAdminArn, is not set");
1552 return DeleteAppInstanceAdminOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceAdminArn]", false));
1553 }
1554 if (!request.AppInstanceArnHasBeenSet())
1555 {
1556 AWS_LOGSTREAM_ERROR("DeleteAppInstanceAdmin", "Required field: AppInstanceArn, is not set");
1557 return DeleteAppInstanceAdminOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
1558 }
1559 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1560 if (m_enableHostPrefixInjection)
1561 {
1562 uri.SetAuthority("identity-" + uri.GetAuthority());
1563 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1564 {
1565 AWS_LOGSTREAM_ERROR("DeleteAppInstanceAdmin", "Invalid DNS host: " << uri.GetAuthority());
1566 return DeleteAppInstanceAdminOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1567 }
1568 }
1569 uri.AddPathSegments("/app-instances/");
1570 uri.AddPathSegment(request.GetAppInstanceArn());
1571 uri.AddPathSegments("/admins/");
1572 uri.AddPathSegment(request.GetAppInstanceAdminArn());
1573 return DeleteAppInstanceAdminOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1574 }
1575
DeleteAppInstanceAdminCallable(const DeleteAppInstanceAdminRequest & request) const1576 DeleteAppInstanceAdminOutcomeCallable ChimeClient::DeleteAppInstanceAdminCallable(const DeleteAppInstanceAdminRequest& request) const
1577 {
1578 auto task = Aws::MakeShared< std::packaged_task< DeleteAppInstanceAdminOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAppInstanceAdmin(request); } );
1579 auto packagedFunction = [task]() { (*task)(); };
1580 m_executor->Submit(packagedFunction);
1581 return task->get_future();
1582 }
1583
DeleteAppInstanceAdminAsync(const DeleteAppInstanceAdminRequest & request,const DeleteAppInstanceAdminResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1584 void ChimeClient::DeleteAppInstanceAdminAsync(const DeleteAppInstanceAdminRequest& request, const DeleteAppInstanceAdminResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1585 {
1586 m_executor->Submit( [this, request, handler, context](){ this->DeleteAppInstanceAdminAsyncHelper( request, handler, context ); } );
1587 }
1588
DeleteAppInstanceAdminAsyncHelper(const DeleteAppInstanceAdminRequest & request,const DeleteAppInstanceAdminResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1589 void ChimeClient::DeleteAppInstanceAdminAsyncHelper(const DeleteAppInstanceAdminRequest& request, const DeleteAppInstanceAdminResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1590 {
1591 handler(this, request, DeleteAppInstanceAdmin(request), context);
1592 }
1593
DeleteAppInstanceStreamingConfigurations(const DeleteAppInstanceStreamingConfigurationsRequest & request) const1594 DeleteAppInstanceStreamingConfigurationsOutcome ChimeClient::DeleteAppInstanceStreamingConfigurations(const DeleteAppInstanceStreamingConfigurationsRequest& request) const
1595 {
1596 if (!request.AppInstanceArnHasBeenSet())
1597 {
1598 AWS_LOGSTREAM_ERROR("DeleteAppInstanceStreamingConfigurations", "Required field: AppInstanceArn, is not set");
1599 return DeleteAppInstanceStreamingConfigurationsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
1600 }
1601 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1602 uri.AddPathSegments("/app-instances/");
1603 uri.AddPathSegment(request.GetAppInstanceArn());
1604 uri.AddPathSegments("/streaming-configurations");
1605 return DeleteAppInstanceStreamingConfigurationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1606 }
1607
DeleteAppInstanceStreamingConfigurationsCallable(const DeleteAppInstanceStreamingConfigurationsRequest & request) const1608 DeleteAppInstanceStreamingConfigurationsOutcomeCallable ChimeClient::DeleteAppInstanceStreamingConfigurationsCallable(const DeleteAppInstanceStreamingConfigurationsRequest& request) const
1609 {
1610 auto task = Aws::MakeShared< std::packaged_task< DeleteAppInstanceStreamingConfigurationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAppInstanceStreamingConfigurations(request); } );
1611 auto packagedFunction = [task]() { (*task)(); };
1612 m_executor->Submit(packagedFunction);
1613 return task->get_future();
1614 }
1615
DeleteAppInstanceStreamingConfigurationsAsync(const DeleteAppInstanceStreamingConfigurationsRequest & request,const DeleteAppInstanceStreamingConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1616 void ChimeClient::DeleteAppInstanceStreamingConfigurationsAsync(const DeleteAppInstanceStreamingConfigurationsRequest& request, const DeleteAppInstanceStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1617 {
1618 m_executor->Submit( [this, request, handler, context](){ this->DeleteAppInstanceStreamingConfigurationsAsyncHelper( request, handler, context ); } );
1619 }
1620
DeleteAppInstanceStreamingConfigurationsAsyncHelper(const DeleteAppInstanceStreamingConfigurationsRequest & request,const DeleteAppInstanceStreamingConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1621 void ChimeClient::DeleteAppInstanceStreamingConfigurationsAsyncHelper(const DeleteAppInstanceStreamingConfigurationsRequest& request, const DeleteAppInstanceStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1622 {
1623 handler(this, request, DeleteAppInstanceStreamingConfigurations(request), context);
1624 }
1625
DeleteAppInstanceUser(const DeleteAppInstanceUserRequest & request) const1626 DeleteAppInstanceUserOutcome ChimeClient::DeleteAppInstanceUser(const DeleteAppInstanceUserRequest& request) const
1627 {
1628 if (!request.AppInstanceUserArnHasBeenSet())
1629 {
1630 AWS_LOGSTREAM_ERROR("DeleteAppInstanceUser", "Required field: AppInstanceUserArn, is not set");
1631 return DeleteAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceUserArn]", false));
1632 }
1633 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1634 if (m_enableHostPrefixInjection)
1635 {
1636 uri.SetAuthority("identity-" + uri.GetAuthority());
1637 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1638 {
1639 AWS_LOGSTREAM_ERROR("DeleteAppInstanceUser", "Invalid DNS host: " << uri.GetAuthority());
1640 return DeleteAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1641 }
1642 }
1643 uri.AddPathSegments("/app-instance-users/");
1644 uri.AddPathSegment(request.GetAppInstanceUserArn());
1645 return DeleteAppInstanceUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1646 }
1647
DeleteAppInstanceUserCallable(const DeleteAppInstanceUserRequest & request) const1648 DeleteAppInstanceUserOutcomeCallable ChimeClient::DeleteAppInstanceUserCallable(const DeleteAppInstanceUserRequest& request) const
1649 {
1650 auto task = Aws::MakeShared< std::packaged_task< DeleteAppInstanceUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAppInstanceUser(request); } );
1651 auto packagedFunction = [task]() { (*task)(); };
1652 m_executor->Submit(packagedFunction);
1653 return task->get_future();
1654 }
1655
DeleteAppInstanceUserAsync(const DeleteAppInstanceUserRequest & request,const DeleteAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1656 void ChimeClient::DeleteAppInstanceUserAsync(const DeleteAppInstanceUserRequest& request, const DeleteAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1657 {
1658 m_executor->Submit( [this, request, handler, context](){ this->DeleteAppInstanceUserAsyncHelper( request, handler, context ); } );
1659 }
1660
DeleteAppInstanceUserAsyncHelper(const DeleteAppInstanceUserRequest & request,const DeleteAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1661 void ChimeClient::DeleteAppInstanceUserAsyncHelper(const DeleteAppInstanceUserRequest& request, const DeleteAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1662 {
1663 handler(this, request, DeleteAppInstanceUser(request), context);
1664 }
1665
DeleteAttendee(const DeleteAttendeeRequest & request) const1666 DeleteAttendeeOutcome ChimeClient::DeleteAttendee(const DeleteAttendeeRequest& request) const
1667 {
1668 if (!request.MeetingIdHasBeenSet())
1669 {
1670 AWS_LOGSTREAM_ERROR("DeleteAttendee", "Required field: MeetingId, is not set");
1671 return DeleteAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
1672 }
1673 if (!request.AttendeeIdHasBeenSet())
1674 {
1675 AWS_LOGSTREAM_ERROR("DeleteAttendee", "Required field: AttendeeId, is not set");
1676 return DeleteAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AttendeeId]", false));
1677 }
1678 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1679 uri.AddPathSegments("/meetings/");
1680 uri.AddPathSegment(request.GetMeetingId());
1681 uri.AddPathSegments("/attendees/");
1682 uri.AddPathSegment(request.GetAttendeeId());
1683 return DeleteAttendeeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1684 }
1685
DeleteAttendeeCallable(const DeleteAttendeeRequest & request) const1686 DeleteAttendeeOutcomeCallable ChimeClient::DeleteAttendeeCallable(const DeleteAttendeeRequest& request) const
1687 {
1688 auto task = Aws::MakeShared< std::packaged_task< DeleteAttendeeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAttendee(request); } );
1689 auto packagedFunction = [task]() { (*task)(); };
1690 m_executor->Submit(packagedFunction);
1691 return task->get_future();
1692 }
1693
DeleteAttendeeAsync(const DeleteAttendeeRequest & request,const DeleteAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1694 void ChimeClient::DeleteAttendeeAsync(const DeleteAttendeeRequest& request, const DeleteAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1695 {
1696 m_executor->Submit( [this, request, handler, context](){ this->DeleteAttendeeAsyncHelper( request, handler, context ); } );
1697 }
1698
DeleteAttendeeAsyncHelper(const DeleteAttendeeRequest & request,const DeleteAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1699 void ChimeClient::DeleteAttendeeAsyncHelper(const DeleteAttendeeRequest& request, const DeleteAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1700 {
1701 handler(this, request, DeleteAttendee(request), context);
1702 }
1703
DeleteChannel(const DeleteChannelRequest & request) const1704 DeleteChannelOutcome ChimeClient::DeleteChannel(const DeleteChannelRequest& request) const
1705 {
1706 if (!request.ChannelArnHasBeenSet())
1707 {
1708 AWS_LOGSTREAM_ERROR("DeleteChannel", "Required field: ChannelArn, is not set");
1709 return DeleteChannelOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
1710 }
1711 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1712 if (m_enableHostPrefixInjection)
1713 {
1714 uri.SetAuthority("messaging-" + uri.GetAuthority());
1715 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1716 {
1717 AWS_LOGSTREAM_ERROR("DeleteChannel", "Invalid DNS host: " << uri.GetAuthority());
1718 return DeleteChannelOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1719 }
1720 }
1721 uri.AddPathSegments("/channels/");
1722 uri.AddPathSegment(request.GetChannelArn());
1723 return DeleteChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1724 }
1725
DeleteChannelCallable(const DeleteChannelRequest & request) const1726 DeleteChannelOutcomeCallable ChimeClient::DeleteChannelCallable(const DeleteChannelRequest& request) const
1727 {
1728 auto task = Aws::MakeShared< std::packaged_task< DeleteChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteChannel(request); } );
1729 auto packagedFunction = [task]() { (*task)(); };
1730 m_executor->Submit(packagedFunction);
1731 return task->get_future();
1732 }
1733
DeleteChannelAsync(const DeleteChannelRequest & request,const DeleteChannelResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1734 void ChimeClient::DeleteChannelAsync(const DeleteChannelRequest& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1735 {
1736 m_executor->Submit( [this, request, handler, context](){ this->DeleteChannelAsyncHelper( request, handler, context ); } );
1737 }
1738
DeleteChannelAsyncHelper(const DeleteChannelRequest & request,const DeleteChannelResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1739 void ChimeClient::DeleteChannelAsyncHelper(const DeleteChannelRequest& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1740 {
1741 handler(this, request, DeleteChannel(request), context);
1742 }
1743
DeleteChannelBan(const DeleteChannelBanRequest & request) const1744 DeleteChannelBanOutcome ChimeClient::DeleteChannelBan(const DeleteChannelBanRequest& request) const
1745 {
1746 if (!request.ChannelArnHasBeenSet())
1747 {
1748 AWS_LOGSTREAM_ERROR("DeleteChannelBan", "Required field: ChannelArn, is not set");
1749 return DeleteChannelBanOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
1750 }
1751 if (!request.MemberArnHasBeenSet())
1752 {
1753 AWS_LOGSTREAM_ERROR("DeleteChannelBan", "Required field: MemberArn, is not set");
1754 return DeleteChannelBanOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MemberArn]", false));
1755 }
1756 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1757 if (m_enableHostPrefixInjection)
1758 {
1759 uri.SetAuthority("messaging-" + uri.GetAuthority());
1760 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1761 {
1762 AWS_LOGSTREAM_ERROR("DeleteChannelBan", "Invalid DNS host: " << uri.GetAuthority());
1763 return DeleteChannelBanOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1764 }
1765 }
1766 uri.AddPathSegments("/channels/");
1767 uri.AddPathSegment(request.GetChannelArn());
1768 uri.AddPathSegments("/bans/");
1769 uri.AddPathSegment(request.GetMemberArn());
1770 return DeleteChannelBanOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1771 }
1772
DeleteChannelBanCallable(const DeleteChannelBanRequest & request) const1773 DeleteChannelBanOutcomeCallable ChimeClient::DeleteChannelBanCallable(const DeleteChannelBanRequest& request) const
1774 {
1775 auto task = Aws::MakeShared< std::packaged_task< DeleteChannelBanOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteChannelBan(request); } );
1776 auto packagedFunction = [task]() { (*task)(); };
1777 m_executor->Submit(packagedFunction);
1778 return task->get_future();
1779 }
1780
DeleteChannelBanAsync(const DeleteChannelBanRequest & request,const DeleteChannelBanResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1781 void ChimeClient::DeleteChannelBanAsync(const DeleteChannelBanRequest& request, const DeleteChannelBanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1782 {
1783 m_executor->Submit( [this, request, handler, context](){ this->DeleteChannelBanAsyncHelper( request, handler, context ); } );
1784 }
1785
DeleteChannelBanAsyncHelper(const DeleteChannelBanRequest & request,const DeleteChannelBanResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1786 void ChimeClient::DeleteChannelBanAsyncHelper(const DeleteChannelBanRequest& request, const DeleteChannelBanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1787 {
1788 handler(this, request, DeleteChannelBan(request), context);
1789 }
1790
DeleteChannelMembership(const DeleteChannelMembershipRequest & request) const1791 DeleteChannelMembershipOutcome ChimeClient::DeleteChannelMembership(const DeleteChannelMembershipRequest& request) const
1792 {
1793 if (!request.ChannelArnHasBeenSet())
1794 {
1795 AWS_LOGSTREAM_ERROR("DeleteChannelMembership", "Required field: ChannelArn, is not set");
1796 return DeleteChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
1797 }
1798 if (!request.MemberArnHasBeenSet())
1799 {
1800 AWS_LOGSTREAM_ERROR("DeleteChannelMembership", "Required field: MemberArn, is not set");
1801 return DeleteChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MemberArn]", false));
1802 }
1803 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1804 if (m_enableHostPrefixInjection)
1805 {
1806 uri.SetAuthority("messaging-" + uri.GetAuthority());
1807 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1808 {
1809 AWS_LOGSTREAM_ERROR("DeleteChannelMembership", "Invalid DNS host: " << uri.GetAuthority());
1810 return DeleteChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1811 }
1812 }
1813 uri.AddPathSegments("/channels/");
1814 uri.AddPathSegment(request.GetChannelArn());
1815 uri.AddPathSegments("/memberships/");
1816 uri.AddPathSegment(request.GetMemberArn());
1817 return DeleteChannelMembershipOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1818 }
1819
DeleteChannelMembershipCallable(const DeleteChannelMembershipRequest & request) const1820 DeleteChannelMembershipOutcomeCallable ChimeClient::DeleteChannelMembershipCallable(const DeleteChannelMembershipRequest& request) const
1821 {
1822 auto task = Aws::MakeShared< std::packaged_task< DeleteChannelMembershipOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteChannelMembership(request); } );
1823 auto packagedFunction = [task]() { (*task)(); };
1824 m_executor->Submit(packagedFunction);
1825 return task->get_future();
1826 }
1827
DeleteChannelMembershipAsync(const DeleteChannelMembershipRequest & request,const DeleteChannelMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1828 void ChimeClient::DeleteChannelMembershipAsync(const DeleteChannelMembershipRequest& request, const DeleteChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1829 {
1830 m_executor->Submit( [this, request, handler, context](){ this->DeleteChannelMembershipAsyncHelper( request, handler, context ); } );
1831 }
1832
DeleteChannelMembershipAsyncHelper(const DeleteChannelMembershipRequest & request,const DeleteChannelMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1833 void ChimeClient::DeleteChannelMembershipAsyncHelper(const DeleteChannelMembershipRequest& request, const DeleteChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1834 {
1835 handler(this, request, DeleteChannelMembership(request), context);
1836 }
1837
DeleteChannelMessage(const DeleteChannelMessageRequest & request) const1838 DeleteChannelMessageOutcome ChimeClient::DeleteChannelMessage(const DeleteChannelMessageRequest& request) const
1839 {
1840 if (!request.ChannelArnHasBeenSet())
1841 {
1842 AWS_LOGSTREAM_ERROR("DeleteChannelMessage", "Required field: ChannelArn, is not set");
1843 return DeleteChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
1844 }
1845 if (!request.MessageIdHasBeenSet())
1846 {
1847 AWS_LOGSTREAM_ERROR("DeleteChannelMessage", "Required field: MessageId, is not set");
1848 return DeleteChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MessageId]", false));
1849 }
1850 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1851 if (m_enableHostPrefixInjection)
1852 {
1853 uri.SetAuthority("messaging-" + uri.GetAuthority());
1854 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1855 {
1856 AWS_LOGSTREAM_ERROR("DeleteChannelMessage", "Invalid DNS host: " << uri.GetAuthority());
1857 return DeleteChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1858 }
1859 }
1860 uri.AddPathSegments("/channels/");
1861 uri.AddPathSegment(request.GetChannelArn());
1862 uri.AddPathSegments("/messages/");
1863 uri.AddPathSegment(request.GetMessageId());
1864 return DeleteChannelMessageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1865 }
1866
DeleteChannelMessageCallable(const DeleteChannelMessageRequest & request) const1867 DeleteChannelMessageOutcomeCallable ChimeClient::DeleteChannelMessageCallable(const DeleteChannelMessageRequest& request) const
1868 {
1869 auto task = Aws::MakeShared< std::packaged_task< DeleteChannelMessageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteChannelMessage(request); } );
1870 auto packagedFunction = [task]() { (*task)(); };
1871 m_executor->Submit(packagedFunction);
1872 return task->get_future();
1873 }
1874
DeleteChannelMessageAsync(const DeleteChannelMessageRequest & request,const DeleteChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1875 void ChimeClient::DeleteChannelMessageAsync(const DeleteChannelMessageRequest& request, const DeleteChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1876 {
1877 m_executor->Submit( [this, request, handler, context](){ this->DeleteChannelMessageAsyncHelper( request, handler, context ); } );
1878 }
1879
DeleteChannelMessageAsyncHelper(const DeleteChannelMessageRequest & request,const DeleteChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1880 void ChimeClient::DeleteChannelMessageAsyncHelper(const DeleteChannelMessageRequest& request, const DeleteChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1881 {
1882 handler(this, request, DeleteChannelMessage(request), context);
1883 }
1884
DeleteChannelModerator(const DeleteChannelModeratorRequest & request) const1885 DeleteChannelModeratorOutcome ChimeClient::DeleteChannelModerator(const DeleteChannelModeratorRequest& request) const
1886 {
1887 if (!request.ChannelArnHasBeenSet())
1888 {
1889 AWS_LOGSTREAM_ERROR("DeleteChannelModerator", "Required field: ChannelArn, is not set");
1890 return DeleteChannelModeratorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
1891 }
1892 if (!request.ChannelModeratorArnHasBeenSet())
1893 {
1894 AWS_LOGSTREAM_ERROR("DeleteChannelModerator", "Required field: ChannelModeratorArn, is not set");
1895 return DeleteChannelModeratorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelModeratorArn]", false));
1896 }
1897 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1898 if (m_enableHostPrefixInjection)
1899 {
1900 uri.SetAuthority("messaging-" + uri.GetAuthority());
1901 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1902 {
1903 AWS_LOGSTREAM_ERROR("DeleteChannelModerator", "Invalid DNS host: " << uri.GetAuthority());
1904 return DeleteChannelModeratorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1905 }
1906 }
1907 uri.AddPathSegments("/channels/");
1908 uri.AddPathSegment(request.GetChannelArn());
1909 uri.AddPathSegments("/moderators/");
1910 uri.AddPathSegment(request.GetChannelModeratorArn());
1911 return DeleteChannelModeratorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1912 }
1913
DeleteChannelModeratorCallable(const DeleteChannelModeratorRequest & request) const1914 DeleteChannelModeratorOutcomeCallable ChimeClient::DeleteChannelModeratorCallable(const DeleteChannelModeratorRequest& request) const
1915 {
1916 auto task = Aws::MakeShared< std::packaged_task< DeleteChannelModeratorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteChannelModerator(request); } );
1917 auto packagedFunction = [task]() { (*task)(); };
1918 m_executor->Submit(packagedFunction);
1919 return task->get_future();
1920 }
1921
DeleteChannelModeratorAsync(const DeleteChannelModeratorRequest & request,const DeleteChannelModeratorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1922 void ChimeClient::DeleteChannelModeratorAsync(const DeleteChannelModeratorRequest& request, const DeleteChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1923 {
1924 m_executor->Submit( [this, request, handler, context](){ this->DeleteChannelModeratorAsyncHelper( request, handler, context ); } );
1925 }
1926
DeleteChannelModeratorAsyncHelper(const DeleteChannelModeratorRequest & request,const DeleteChannelModeratorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1927 void ChimeClient::DeleteChannelModeratorAsyncHelper(const DeleteChannelModeratorRequest& request, const DeleteChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1928 {
1929 handler(this, request, DeleteChannelModerator(request), context);
1930 }
1931
DeleteEventsConfiguration(const DeleteEventsConfigurationRequest & request) const1932 DeleteEventsConfigurationOutcome ChimeClient::DeleteEventsConfiguration(const DeleteEventsConfigurationRequest& request) const
1933 {
1934 if (!request.AccountIdHasBeenSet())
1935 {
1936 AWS_LOGSTREAM_ERROR("DeleteEventsConfiguration", "Required field: AccountId, is not set");
1937 return DeleteEventsConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
1938 }
1939 if (!request.BotIdHasBeenSet())
1940 {
1941 AWS_LOGSTREAM_ERROR("DeleteEventsConfiguration", "Required field: BotId, is not set");
1942 return DeleteEventsConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [BotId]", false));
1943 }
1944 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1945 uri.AddPathSegments("/accounts/");
1946 uri.AddPathSegment(request.GetAccountId());
1947 uri.AddPathSegments("/bots/");
1948 uri.AddPathSegment(request.GetBotId());
1949 uri.AddPathSegments("/events-configuration");
1950 return DeleteEventsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1951 }
1952
DeleteEventsConfigurationCallable(const DeleteEventsConfigurationRequest & request) const1953 DeleteEventsConfigurationOutcomeCallable ChimeClient::DeleteEventsConfigurationCallable(const DeleteEventsConfigurationRequest& request) const
1954 {
1955 auto task = Aws::MakeShared< std::packaged_task< DeleteEventsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteEventsConfiguration(request); } );
1956 auto packagedFunction = [task]() { (*task)(); };
1957 m_executor->Submit(packagedFunction);
1958 return task->get_future();
1959 }
1960
DeleteEventsConfigurationAsync(const DeleteEventsConfigurationRequest & request,const DeleteEventsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1961 void ChimeClient::DeleteEventsConfigurationAsync(const DeleteEventsConfigurationRequest& request, const DeleteEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1962 {
1963 m_executor->Submit( [this, request, handler, context](){ this->DeleteEventsConfigurationAsyncHelper( request, handler, context ); } );
1964 }
1965
DeleteEventsConfigurationAsyncHelper(const DeleteEventsConfigurationRequest & request,const DeleteEventsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1966 void ChimeClient::DeleteEventsConfigurationAsyncHelper(const DeleteEventsConfigurationRequest& request, const DeleteEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1967 {
1968 handler(this, request, DeleteEventsConfiguration(request), context);
1969 }
1970
DeleteMediaCapturePipeline(const DeleteMediaCapturePipelineRequest & request) const1971 DeleteMediaCapturePipelineOutcome ChimeClient::DeleteMediaCapturePipeline(const DeleteMediaCapturePipelineRequest& request) const
1972 {
1973 if (!request.MediaPipelineIdHasBeenSet())
1974 {
1975 AWS_LOGSTREAM_ERROR("DeleteMediaCapturePipeline", "Required field: MediaPipelineId, is not set");
1976 return DeleteMediaCapturePipelineOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MediaPipelineId]", false));
1977 }
1978 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1979 uri.AddPathSegments("/media-capture-pipelines/");
1980 uri.AddPathSegment(request.GetMediaPipelineId());
1981 return DeleteMediaCapturePipelineOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1982 }
1983
DeleteMediaCapturePipelineCallable(const DeleteMediaCapturePipelineRequest & request) const1984 DeleteMediaCapturePipelineOutcomeCallable ChimeClient::DeleteMediaCapturePipelineCallable(const DeleteMediaCapturePipelineRequest& request) const
1985 {
1986 auto task = Aws::MakeShared< std::packaged_task< DeleteMediaCapturePipelineOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteMediaCapturePipeline(request); } );
1987 auto packagedFunction = [task]() { (*task)(); };
1988 m_executor->Submit(packagedFunction);
1989 return task->get_future();
1990 }
1991
DeleteMediaCapturePipelineAsync(const DeleteMediaCapturePipelineRequest & request,const DeleteMediaCapturePipelineResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1992 void ChimeClient::DeleteMediaCapturePipelineAsync(const DeleteMediaCapturePipelineRequest& request, const DeleteMediaCapturePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1993 {
1994 m_executor->Submit( [this, request, handler, context](){ this->DeleteMediaCapturePipelineAsyncHelper( request, handler, context ); } );
1995 }
1996
DeleteMediaCapturePipelineAsyncHelper(const DeleteMediaCapturePipelineRequest & request,const DeleteMediaCapturePipelineResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1997 void ChimeClient::DeleteMediaCapturePipelineAsyncHelper(const DeleteMediaCapturePipelineRequest& request, const DeleteMediaCapturePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1998 {
1999 handler(this, request, DeleteMediaCapturePipeline(request), context);
2000 }
2001
DeleteMeeting(const DeleteMeetingRequest & request) const2002 DeleteMeetingOutcome ChimeClient::DeleteMeeting(const DeleteMeetingRequest& request) const
2003 {
2004 if (!request.MeetingIdHasBeenSet())
2005 {
2006 AWS_LOGSTREAM_ERROR("DeleteMeeting", "Required field: MeetingId, is not set");
2007 return DeleteMeetingOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
2008 }
2009 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2010 uri.AddPathSegments("/meetings/");
2011 uri.AddPathSegment(request.GetMeetingId());
2012 return DeleteMeetingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2013 }
2014
DeleteMeetingCallable(const DeleteMeetingRequest & request) const2015 DeleteMeetingOutcomeCallable ChimeClient::DeleteMeetingCallable(const DeleteMeetingRequest& request) const
2016 {
2017 auto task = Aws::MakeShared< std::packaged_task< DeleteMeetingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteMeeting(request); } );
2018 auto packagedFunction = [task]() { (*task)(); };
2019 m_executor->Submit(packagedFunction);
2020 return task->get_future();
2021 }
2022
DeleteMeetingAsync(const DeleteMeetingRequest & request,const DeleteMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2023 void ChimeClient::DeleteMeetingAsync(const DeleteMeetingRequest& request, const DeleteMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2024 {
2025 m_executor->Submit( [this, request, handler, context](){ this->DeleteMeetingAsyncHelper( request, handler, context ); } );
2026 }
2027
DeleteMeetingAsyncHelper(const DeleteMeetingRequest & request,const DeleteMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2028 void ChimeClient::DeleteMeetingAsyncHelper(const DeleteMeetingRequest& request, const DeleteMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2029 {
2030 handler(this, request, DeleteMeeting(request), context);
2031 }
2032
DeletePhoneNumber(const DeletePhoneNumberRequest & request) const2033 DeletePhoneNumberOutcome ChimeClient::DeletePhoneNumber(const DeletePhoneNumberRequest& request) const
2034 {
2035 if (!request.PhoneNumberIdHasBeenSet())
2036 {
2037 AWS_LOGSTREAM_ERROR("DeletePhoneNumber", "Required field: PhoneNumberId, is not set");
2038 return DeletePhoneNumberOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PhoneNumberId]", false));
2039 }
2040 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2041 uri.AddPathSegments("/phone-numbers/");
2042 uri.AddPathSegment(request.GetPhoneNumberId());
2043 return DeletePhoneNumberOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2044 }
2045
DeletePhoneNumberCallable(const DeletePhoneNumberRequest & request) const2046 DeletePhoneNumberOutcomeCallable ChimeClient::DeletePhoneNumberCallable(const DeletePhoneNumberRequest& request) const
2047 {
2048 auto task = Aws::MakeShared< std::packaged_task< DeletePhoneNumberOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePhoneNumber(request); } );
2049 auto packagedFunction = [task]() { (*task)(); };
2050 m_executor->Submit(packagedFunction);
2051 return task->get_future();
2052 }
2053
DeletePhoneNumberAsync(const DeletePhoneNumberRequest & request,const DeletePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2054 void ChimeClient::DeletePhoneNumberAsync(const DeletePhoneNumberRequest& request, const DeletePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2055 {
2056 m_executor->Submit( [this, request, handler, context](){ this->DeletePhoneNumberAsyncHelper( request, handler, context ); } );
2057 }
2058
DeletePhoneNumberAsyncHelper(const DeletePhoneNumberRequest & request,const DeletePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2059 void ChimeClient::DeletePhoneNumberAsyncHelper(const DeletePhoneNumberRequest& request, const DeletePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2060 {
2061 handler(this, request, DeletePhoneNumber(request), context);
2062 }
2063
DeleteProxySession(const DeleteProxySessionRequest & request) const2064 DeleteProxySessionOutcome ChimeClient::DeleteProxySession(const DeleteProxySessionRequest& request) const
2065 {
2066 if (!request.VoiceConnectorIdHasBeenSet())
2067 {
2068 AWS_LOGSTREAM_ERROR("DeleteProxySession", "Required field: VoiceConnectorId, is not set");
2069 return DeleteProxySessionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2070 }
2071 if (!request.ProxySessionIdHasBeenSet())
2072 {
2073 AWS_LOGSTREAM_ERROR("DeleteProxySession", "Required field: ProxySessionId, is not set");
2074 return DeleteProxySessionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ProxySessionId]", false));
2075 }
2076 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2077 uri.AddPathSegments("/voice-connectors/");
2078 uri.AddPathSegment(request.GetVoiceConnectorId());
2079 uri.AddPathSegments("/proxy-sessions/");
2080 uri.AddPathSegment(request.GetProxySessionId());
2081 return DeleteProxySessionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2082 }
2083
DeleteProxySessionCallable(const DeleteProxySessionRequest & request) const2084 DeleteProxySessionOutcomeCallable ChimeClient::DeleteProxySessionCallable(const DeleteProxySessionRequest& request) const
2085 {
2086 auto task = Aws::MakeShared< std::packaged_task< DeleteProxySessionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteProxySession(request); } );
2087 auto packagedFunction = [task]() { (*task)(); };
2088 m_executor->Submit(packagedFunction);
2089 return task->get_future();
2090 }
2091
DeleteProxySessionAsync(const DeleteProxySessionRequest & request,const DeleteProxySessionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2092 void ChimeClient::DeleteProxySessionAsync(const DeleteProxySessionRequest& request, const DeleteProxySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2093 {
2094 m_executor->Submit( [this, request, handler, context](){ this->DeleteProxySessionAsyncHelper( request, handler, context ); } );
2095 }
2096
DeleteProxySessionAsyncHelper(const DeleteProxySessionRequest & request,const DeleteProxySessionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2097 void ChimeClient::DeleteProxySessionAsyncHelper(const DeleteProxySessionRequest& request, const DeleteProxySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2098 {
2099 handler(this, request, DeleteProxySession(request), context);
2100 }
2101
DeleteRoom(const DeleteRoomRequest & request) const2102 DeleteRoomOutcome ChimeClient::DeleteRoom(const DeleteRoomRequest& request) const
2103 {
2104 if (!request.AccountIdHasBeenSet())
2105 {
2106 AWS_LOGSTREAM_ERROR("DeleteRoom", "Required field: AccountId, is not set");
2107 return DeleteRoomOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
2108 }
2109 if (!request.RoomIdHasBeenSet())
2110 {
2111 AWS_LOGSTREAM_ERROR("DeleteRoom", "Required field: RoomId, is not set");
2112 return DeleteRoomOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
2113 }
2114 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2115 uri.AddPathSegments("/accounts/");
2116 uri.AddPathSegment(request.GetAccountId());
2117 uri.AddPathSegments("/rooms/");
2118 uri.AddPathSegment(request.GetRoomId());
2119 return DeleteRoomOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2120 }
2121
DeleteRoomCallable(const DeleteRoomRequest & request) const2122 DeleteRoomOutcomeCallable ChimeClient::DeleteRoomCallable(const DeleteRoomRequest& request) const
2123 {
2124 auto task = Aws::MakeShared< std::packaged_task< DeleteRoomOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteRoom(request); } );
2125 auto packagedFunction = [task]() { (*task)(); };
2126 m_executor->Submit(packagedFunction);
2127 return task->get_future();
2128 }
2129
DeleteRoomAsync(const DeleteRoomRequest & request,const DeleteRoomResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2130 void ChimeClient::DeleteRoomAsync(const DeleteRoomRequest& request, const DeleteRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2131 {
2132 m_executor->Submit( [this, request, handler, context](){ this->DeleteRoomAsyncHelper( request, handler, context ); } );
2133 }
2134
DeleteRoomAsyncHelper(const DeleteRoomRequest & request,const DeleteRoomResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2135 void ChimeClient::DeleteRoomAsyncHelper(const DeleteRoomRequest& request, const DeleteRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2136 {
2137 handler(this, request, DeleteRoom(request), context);
2138 }
2139
DeleteRoomMembership(const DeleteRoomMembershipRequest & request) const2140 DeleteRoomMembershipOutcome ChimeClient::DeleteRoomMembership(const DeleteRoomMembershipRequest& request) const
2141 {
2142 if (!request.AccountIdHasBeenSet())
2143 {
2144 AWS_LOGSTREAM_ERROR("DeleteRoomMembership", "Required field: AccountId, is not set");
2145 return DeleteRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
2146 }
2147 if (!request.RoomIdHasBeenSet())
2148 {
2149 AWS_LOGSTREAM_ERROR("DeleteRoomMembership", "Required field: RoomId, is not set");
2150 return DeleteRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
2151 }
2152 if (!request.MemberIdHasBeenSet())
2153 {
2154 AWS_LOGSTREAM_ERROR("DeleteRoomMembership", "Required field: MemberId, is not set");
2155 return DeleteRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MemberId]", false));
2156 }
2157 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2158 uri.AddPathSegments("/accounts/");
2159 uri.AddPathSegment(request.GetAccountId());
2160 uri.AddPathSegments("/rooms/");
2161 uri.AddPathSegment(request.GetRoomId());
2162 uri.AddPathSegments("/memberships/");
2163 uri.AddPathSegment(request.GetMemberId());
2164 return DeleteRoomMembershipOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2165 }
2166
DeleteRoomMembershipCallable(const DeleteRoomMembershipRequest & request) const2167 DeleteRoomMembershipOutcomeCallable ChimeClient::DeleteRoomMembershipCallable(const DeleteRoomMembershipRequest& request) const
2168 {
2169 auto task = Aws::MakeShared< std::packaged_task< DeleteRoomMembershipOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteRoomMembership(request); } );
2170 auto packagedFunction = [task]() { (*task)(); };
2171 m_executor->Submit(packagedFunction);
2172 return task->get_future();
2173 }
2174
DeleteRoomMembershipAsync(const DeleteRoomMembershipRequest & request,const DeleteRoomMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2175 void ChimeClient::DeleteRoomMembershipAsync(const DeleteRoomMembershipRequest& request, const DeleteRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2176 {
2177 m_executor->Submit( [this, request, handler, context](){ this->DeleteRoomMembershipAsyncHelper( request, handler, context ); } );
2178 }
2179
DeleteRoomMembershipAsyncHelper(const DeleteRoomMembershipRequest & request,const DeleteRoomMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2180 void ChimeClient::DeleteRoomMembershipAsyncHelper(const DeleteRoomMembershipRequest& request, const DeleteRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2181 {
2182 handler(this, request, DeleteRoomMembership(request), context);
2183 }
2184
DeleteSipMediaApplication(const DeleteSipMediaApplicationRequest & request) const2185 DeleteSipMediaApplicationOutcome ChimeClient::DeleteSipMediaApplication(const DeleteSipMediaApplicationRequest& request) const
2186 {
2187 if (!request.SipMediaApplicationIdHasBeenSet())
2188 {
2189 AWS_LOGSTREAM_ERROR("DeleteSipMediaApplication", "Required field: SipMediaApplicationId, is not set");
2190 return DeleteSipMediaApplicationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipMediaApplicationId]", false));
2191 }
2192 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2193 uri.AddPathSegments("/sip-media-applications/");
2194 uri.AddPathSegment(request.GetSipMediaApplicationId());
2195 return DeleteSipMediaApplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2196 }
2197
DeleteSipMediaApplicationCallable(const DeleteSipMediaApplicationRequest & request) const2198 DeleteSipMediaApplicationOutcomeCallable ChimeClient::DeleteSipMediaApplicationCallable(const DeleteSipMediaApplicationRequest& request) const
2199 {
2200 auto task = Aws::MakeShared< std::packaged_task< DeleteSipMediaApplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteSipMediaApplication(request); } );
2201 auto packagedFunction = [task]() { (*task)(); };
2202 m_executor->Submit(packagedFunction);
2203 return task->get_future();
2204 }
2205
DeleteSipMediaApplicationAsync(const DeleteSipMediaApplicationRequest & request,const DeleteSipMediaApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2206 void ChimeClient::DeleteSipMediaApplicationAsync(const DeleteSipMediaApplicationRequest& request, const DeleteSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2207 {
2208 m_executor->Submit( [this, request, handler, context](){ this->DeleteSipMediaApplicationAsyncHelper( request, handler, context ); } );
2209 }
2210
DeleteSipMediaApplicationAsyncHelper(const DeleteSipMediaApplicationRequest & request,const DeleteSipMediaApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2211 void ChimeClient::DeleteSipMediaApplicationAsyncHelper(const DeleteSipMediaApplicationRequest& request, const DeleteSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2212 {
2213 handler(this, request, DeleteSipMediaApplication(request), context);
2214 }
2215
DeleteSipRule(const DeleteSipRuleRequest & request) const2216 DeleteSipRuleOutcome ChimeClient::DeleteSipRule(const DeleteSipRuleRequest& request) const
2217 {
2218 if (!request.SipRuleIdHasBeenSet())
2219 {
2220 AWS_LOGSTREAM_ERROR("DeleteSipRule", "Required field: SipRuleId, is not set");
2221 return DeleteSipRuleOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipRuleId]", false));
2222 }
2223 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2224 uri.AddPathSegments("/sip-rules/");
2225 uri.AddPathSegment(request.GetSipRuleId());
2226 return DeleteSipRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2227 }
2228
DeleteSipRuleCallable(const DeleteSipRuleRequest & request) const2229 DeleteSipRuleOutcomeCallable ChimeClient::DeleteSipRuleCallable(const DeleteSipRuleRequest& request) const
2230 {
2231 auto task = Aws::MakeShared< std::packaged_task< DeleteSipRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteSipRule(request); } );
2232 auto packagedFunction = [task]() { (*task)(); };
2233 m_executor->Submit(packagedFunction);
2234 return task->get_future();
2235 }
2236
DeleteSipRuleAsync(const DeleteSipRuleRequest & request,const DeleteSipRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2237 void ChimeClient::DeleteSipRuleAsync(const DeleteSipRuleRequest& request, const DeleteSipRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2238 {
2239 m_executor->Submit( [this, request, handler, context](){ this->DeleteSipRuleAsyncHelper( request, handler, context ); } );
2240 }
2241
DeleteSipRuleAsyncHelper(const DeleteSipRuleRequest & request,const DeleteSipRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2242 void ChimeClient::DeleteSipRuleAsyncHelper(const DeleteSipRuleRequest& request, const DeleteSipRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2243 {
2244 handler(this, request, DeleteSipRule(request), context);
2245 }
2246
DeleteVoiceConnector(const DeleteVoiceConnectorRequest & request) const2247 DeleteVoiceConnectorOutcome ChimeClient::DeleteVoiceConnector(const DeleteVoiceConnectorRequest& request) const
2248 {
2249 if (!request.VoiceConnectorIdHasBeenSet())
2250 {
2251 AWS_LOGSTREAM_ERROR("DeleteVoiceConnector", "Required field: VoiceConnectorId, is not set");
2252 return DeleteVoiceConnectorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2253 }
2254 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2255 uri.AddPathSegments("/voice-connectors/");
2256 uri.AddPathSegment(request.GetVoiceConnectorId());
2257 return DeleteVoiceConnectorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2258 }
2259
DeleteVoiceConnectorCallable(const DeleteVoiceConnectorRequest & request) const2260 DeleteVoiceConnectorOutcomeCallable ChimeClient::DeleteVoiceConnectorCallable(const DeleteVoiceConnectorRequest& request) const
2261 {
2262 auto task = Aws::MakeShared< std::packaged_task< DeleteVoiceConnectorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVoiceConnector(request); } );
2263 auto packagedFunction = [task]() { (*task)(); };
2264 m_executor->Submit(packagedFunction);
2265 return task->get_future();
2266 }
2267
DeleteVoiceConnectorAsync(const DeleteVoiceConnectorRequest & request,const DeleteVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2268 void ChimeClient::DeleteVoiceConnectorAsync(const DeleteVoiceConnectorRequest& request, const DeleteVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2269 {
2270 m_executor->Submit( [this, request, handler, context](){ this->DeleteVoiceConnectorAsyncHelper( request, handler, context ); } );
2271 }
2272
DeleteVoiceConnectorAsyncHelper(const DeleteVoiceConnectorRequest & request,const DeleteVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2273 void ChimeClient::DeleteVoiceConnectorAsyncHelper(const DeleteVoiceConnectorRequest& request, const DeleteVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2274 {
2275 handler(this, request, DeleteVoiceConnector(request), context);
2276 }
2277
DeleteVoiceConnectorEmergencyCallingConfiguration(const DeleteVoiceConnectorEmergencyCallingConfigurationRequest & request) const2278 DeleteVoiceConnectorEmergencyCallingConfigurationOutcome ChimeClient::DeleteVoiceConnectorEmergencyCallingConfiguration(const DeleteVoiceConnectorEmergencyCallingConfigurationRequest& request) const
2279 {
2280 if (!request.VoiceConnectorIdHasBeenSet())
2281 {
2282 AWS_LOGSTREAM_ERROR("DeleteVoiceConnectorEmergencyCallingConfiguration", "Required field: VoiceConnectorId, is not set");
2283 return DeleteVoiceConnectorEmergencyCallingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2284 }
2285 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2286 uri.AddPathSegments("/voice-connectors/");
2287 uri.AddPathSegment(request.GetVoiceConnectorId());
2288 uri.AddPathSegments("/emergency-calling-configuration");
2289 return DeleteVoiceConnectorEmergencyCallingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2290 }
2291
DeleteVoiceConnectorEmergencyCallingConfigurationCallable(const DeleteVoiceConnectorEmergencyCallingConfigurationRequest & request) const2292 DeleteVoiceConnectorEmergencyCallingConfigurationOutcomeCallable ChimeClient::DeleteVoiceConnectorEmergencyCallingConfigurationCallable(const DeleteVoiceConnectorEmergencyCallingConfigurationRequest& request) const
2293 {
2294 auto task = Aws::MakeShared< std::packaged_task< DeleteVoiceConnectorEmergencyCallingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVoiceConnectorEmergencyCallingConfiguration(request); } );
2295 auto packagedFunction = [task]() { (*task)(); };
2296 m_executor->Submit(packagedFunction);
2297 return task->get_future();
2298 }
2299
DeleteVoiceConnectorEmergencyCallingConfigurationAsync(const DeleteVoiceConnectorEmergencyCallingConfigurationRequest & request,const DeleteVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2300 void ChimeClient::DeleteVoiceConnectorEmergencyCallingConfigurationAsync(const DeleteVoiceConnectorEmergencyCallingConfigurationRequest& request, const DeleteVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2301 {
2302 m_executor->Submit( [this, request, handler, context](){ this->DeleteVoiceConnectorEmergencyCallingConfigurationAsyncHelper( request, handler, context ); } );
2303 }
2304
DeleteVoiceConnectorEmergencyCallingConfigurationAsyncHelper(const DeleteVoiceConnectorEmergencyCallingConfigurationRequest & request,const DeleteVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2305 void ChimeClient::DeleteVoiceConnectorEmergencyCallingConfigurationAsyncHelper(const DeleteVoiceConnectorEmergencyCallingConfigurationRequest& request, const DeleteVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2306 {
2307 handler(this, request, DeleteVoiceConnectorEmergencyCallingConfiguration(request), context);
2308 }
2309
DeleteVoiceConnectorGroup(const DeleteVoiceConnectorGroupRequest & request) const2310 DeleteVoiceConnectorGroupOutcome ChimeClient::DeleteVoiceConnectorGroup(const DeleteVoiceConnectorGroupRequest& request) const
2311 {
2312 if (!request.VoiceConnectorGroupIdHasBeenSet())
2313 {
2314 AWS_LOGSTREAM_ERROR("DeleteVoiceConnectorGroup", "Required field: VoiceConnectorGroupId, is not set");
2315 return DeleteVoiceConnectorGroupOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorGroupId]", false));
2316 }
2317 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2318 uri.AddPathSegments("/voice-connector-groups/");
2319 uri.AddPathSegment(request.GetVoiceConnectorGroupId());
2320 return DeleteVoiceConnectorGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2321 }
2322
DeleteVoiceConnectorGroupCallable(const DeleteVoiceConnectorGroupRequest & request) const2323 DeleteVoiceConnectorGroupOutcomeCallable ChimeClient::DeleteVoiceConnectorGroupCallable(const DeleteVoiceConnectorGroupRequest& request) const
2324 {
2325 auto task = Aws::MakeShared< std::packaged_task< DeleteVoiceConnectorGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVoiceConnectorGroup(request); } );
2326 auto packagedFunction = [task]() { (*task)(); };
2327 m_executor->Submit(packagedFunction);
2328 return task->get_future();
2329 }
2330
DeleteVoiceConnectorGroupAsync(const DeleteVoiceConnectorGroupRequest & request,const DeleteVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2331 void ChimeClient::DeleteVoiceConnectorGroupAsync(const DeleteVoiceConnectorGroupRequest& request, const DeleteVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2332 {
2333 m_executor->Submit( [this, request, handler, context](){ this->DeleteVoiceConnectorGroupAsyncHelper( request, handler, context ); } );
2334 }
2335
DeleteVoiceConnectorGroupAsyncHelper(const DeleteVoiceConnectorGroupRequest & request,const DeleteVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2336 void ChimeClient::DeleteVoiceConnectorGroupAsyncHelper(const DeleteVoiceConnectorGroupRequest& request, const DeleteVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2337 {
2338 handler(this, request, DeleteVoiceConnectorGroup(request), context);
2339 }
2340
DeleteVoiceConnectorOrigination(const DeleteVoiceConnectorOriginationRequest & request) const2341 DeleteVoiceConnectorOriginationOutcome ChimeClient::DeleteVoiceConnectorOrigination(const DeleteVoiceConnectorOriginationRequest& request) const
2342 {
2343 if (!request.VoiceConnectorIdHasBeenSet())
2344 {
2345 AWS_LOGSTREAM_ERROR("DeleteVoiceConnectorOrigination", "Required field: VoiceConnectorId, is not set");
2346 return DeleteVoiceConnectorOriginationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2347 }
2348 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2349 uri.AddPathSegments("/voice-connectors/");
2350 uri.AddPathSegment(request.GetVoiceConnectorId());
2351 uri.AddPathSegments("/origination");
2352 return DeleteVoiceConnectorOriginationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2353 }
2354
DeleteVoiceConnectorOriginationCallable(const DeleteVoiceConnectorOriginationRequest & request) const2355 DeleteVoiceConnectorOriginationOutcomeCallable ChimeClient::DeleteVoiceConnectorOriginationCallable(const DeleteVoiceConnectorOriginationRequest& request) const
2356 {
2357 auto task = Aws::MakeShared< std::packaged_task< DeleteVoiceConnectorOriginationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVoiceConnectorOrigination(request); } );
2358 auto packagedFunction = [task]() { (*task)(); };
2359 m_executor->Submit(packagedFunction);
2360 return task->get_future();
2361 }
2362
DeleteVoiceConnectorOriginationAsync(const DeleteVoiceConnectorOriginationRequest & request,const DeleteVoiceConnectorOriginationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2363 void ChimeClient::DeleteVoiceConnectorOriginationAsync(const DeleteVoiceConnectorOriginationRequest& request, const DeleteVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2364 {
2365 m_executor->Submit( [this, request, handler, context](){ this->DeleteVoiceConnectorOriginationAsyncHelper( request, handler, context ); } );
2366 }
2367
DeleteVoiceConnectorOriginationAsyncHelper(const DeleteVoiceConnectorOriginationRequest & request,const DeleteVoiceConnectorOriginationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2368 void ChimeClient::DeleteVoiceConnectorOriginationAsyncHelper(const DeleteVoiceConnectorOriginationRequest& request, const DeleteVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2369 {
2370 handler(this, request, DeleteVoiceConnectorOrigination(request), context);
2371 }
2372
DeleteVoiceConnectorProxy(const DeleteVoiceConnectorProxyRequest & request) const2373 DeleteVoiceConnectorProxyOutcome ChimeClient::DeleteVoiceConnectorProxy(const DeleteVoiceConnectorProxyRequest& request) const
2374 {
2375 if (!request.VoiceConnectorIdHasBeenSet())
2376 {
2377 AWS_LOGSTREAM_ERROR("DeleteVoiceConnectorProxy", "Required field: VoiceConnectorId, is not set");
2378 return DeleteVoiceConnectorProxyOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2379 }
2380 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2381 uri.AddPathSegments("/voice-connectors/");
2382 uri.AddPathSegment(request.GetVoiceConnectorId());
2383 uri.AddPathSegments("/programmable-numbers/proxy");
2384 return DeleteVoiceConnectorProxyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2385 }
2386
DeleteVoiceConnectorProxyCallable(const DeleteVoiceConnectorProxyRequest & request) const2387 DeleteVoiceConnectorProxyOutcomeCallable ChimeClient::DeleteVoiceConnectorProxyCallable(const DeleteVoiceConnectorProxyRequest& request) const
2388 {
2389 auto task = Aws::MakeShared< std::packaged_task< DeleteVoiceConnectorProxyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVoiceConnectorProxy(request); } );
2390 auto packagedFunction = [task]() { (*task)(); };
2391 m_executor->Submit(packagedFunction);
2392 return task->get_future();
2393 }
2394
DeleteVoiceConnectorProxyAsync(const DeleteVoiceConnectorProxyRequest & request,const DeleteVoiceConnectorProxyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2395 void ChimeClient::DeleteVoiceConnectorProxyAsync(const DeleteVoiceConnectorProxyRequest& request, const DeleteVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2396 {
2397 m_executor->Submit( [this, request, handler, context](){ this->DeleteVoiceConnectorProxyAsyncHelper( request, handler, context ); } );
2398 }
2399
DeleteVoiceConnectorProxyAsyncHelper(const DeleteVoiceConnectorProxyRequest & request,const DeleteVoiceConnectorProxyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2400 void ChimeClient::DeleteVoiceConnectorProxyAsyncHelper(const DeleteVoiceConnectorProxyRequest& request, const DeleteVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2401 {
2402 handler(this, request, DeleteVoiceConnectorProxy(request), context);
2403 }
2404
DeleteVoiceConnectorStreamingConfiguration(const DeleteVoiceConnectorStreamingConfigurationRequest & request) const2405 DeleteVoiceConnectorStreamingConfigurationOutcome ChimeClient::DeleteVoiceConnectorStreamingConfiguration(const DeleteVoiceConnectorStreamingConfigurationRequest& request) const
2406 {
2407 if (!request.VoiceConnectorIdHasBeenSet())
2408 {
2409 AWS_LOGSTREAM_ERROR("DeleteVoiceConnectorStreamingConfiguration", "Required field: VoiceConnectorId, is not set");
2410 return DeleteVoiceConnectorStreamingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2411 }
2412 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2413 uri.AddPathSegments("/voice-connectors/");
2414 uri.AddPathSegment(request.GetVoiceConnectorId());
2415 uri.AddPathSegments("/streaming-configuration");
2416 return DeleteVoiceConnectorStreamingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2417 }
2418
DeleteVoiceConnectorStreamingConfigurationCallable(const DeleteVoiceConnectorStreamingConfigurationRequest & request) const2419 DeleteVoiceConnectorStreamingConfigurationOutcomeCallable ChimeClient::DeleteVoiceConnectorStreamingConfigurationCallable(const DeleteVoiceConnectorStreamingConfigurationRequest& request) const
2420 {
2421 auto task = Aws::MakeShared< std::packaged_task< DeleteVoiceConnectorStreamingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVoiceConnectorStreamingConfiguration(request); } );
2422 auto packagedFunction = [task]() { (*task)(); };
2423 m_executor->Submit(packagedFunction);
2424 return task->get_future();
2425 }
2426
DeleteVoiceConnectorStreamingConfigurationAsync(const DeleteVoiceConnectorStreamingConfigurationRequest & request,const DeleteVoiceConnectorStreamingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2427 void ChimeClient::DeleteVoiceConnectorStreamingConfigurationAsync(const DeleteVoiceConnectorStreamingConfigurationRequest& request, const DeleteVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2428 {
2429 m_executor->Submit( [this, request, handler, context](){ this->DeleteVoiceConnectorStreamingConfigurationAsyncHelper( request, handler, context ); } );
2430 }
2431
DeleteVoiceConnectorStreamingConfigurationAsyncHelper(const DeleteVoiceConnectorStreamingConfigurationRequest & request,const DeleteVoiceConnectorStreamingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2432 void ChimeClient::DeleteVoiceConnectorStreamingConfigurationAsyncHelper(const DeleteVoiceConnectorStreamingConfigurationRequest& request, const DeleteVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2433 {
2434 handler(this, request, DeleteVoiceConnectorStreamingConfiguration(request), context);
2435 }
2436
DeleteVoiceConnectorTermination(const DeleteVoiceConnectorTerminationRequest & request) const2437 DeleteVoiceConnectorTerminationOutcome ChimeClient::DeleteVoiceConnectorTermination(const DeleteVoiceConnectorTerminationRequest& request) const
2438 {
2439 if (!request.VoiceConnectorIdHasBeenSet())
2440 {
2441 AWS_LOGSTREAM_ERROR("DeleteVoiceConnectorTermination", "Required field: VoiceConnectorId, is not set");
2442 return DeleteVoiceConnectorTerminationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2443 }
2444 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2445 uri.AddPathSegments("/voice-connectors/");
2446 uri.AddPathSegment(request.GetVoiceConnectorId());
2447 uri.AddPathSegments("/termination");
2448 return DeleteVoiceConnectorTerminationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
2449 }
2450
DeleteVoiceConnectorTerminationCallable(const DeleteVoiceConnectorTerminationRequest & request) const2451 DeleteVoiceConnectorTerminationOutcomeCallable ChimeClient::DeleteVoiceConnectorTerminationCallable(const DeleteVoiceConnectorTerminationRequest& request) const
2452 {
2453 auto task = Aws::MakeShared< std::packaged_task< DeleteVoiceConnectorTerminationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVoiceConnectorTermination(request); } );
2454 auto packagedFunction = [task]() { (*task)(); };
2455 m_executor->Submit(packagedFunction);
2456 return task->get_future();
2457 }
2458
DeleteVoiceConnectorTerminationAsync(const DeleteVoiceConnectorTerminationRequest & request,const DeleteVoiceConnectorTerminationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2459 void ChimeClient::DeleteVoiceConnectorTerminationAsync(const DeleteVoiceConnectorTerminationRequest& request, const DeleteVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2460 {
2461 m_executor->Submit( [this, request, handler, context](){ this->DeleteVoiceConnectorTerminationAsyncHelper( request, handler, context ); } );
2462 }
2463
DeleteVoiceConnectorTerminationAsyncHelper(const DeleteVoiceConnectorTerminationRequest & request,const DeleteVoiceConnectorTerminationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2464 void ChimeClient::DeleteVoiceConnectorTerminationAsyncHelper(const DeleteVoiceConnectorTerminationRequest& request, const DeleteVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2465 {
2466 handler(this, request, DeleteVoiceConnectorTermination(request), context);
2467 }
2468
DeleteVoiceConnectorTerminationCredentials(const DeleteVoiceConnectorTerminationCredentialsRequest & request) const2469 DeleteVoiceConnectorTerminationCredentialsOutcome ChimeClient::DeleteVoiceConnectorTerminationCredentials(const DeleteVoiceConnectorTerminationCredentialsRequest& request) const
2470 {
2471 if (!request.VoiceConnectorIdHasBeenSet())
2472 {
2473 AWS_LOGSTREAM_ERROR("DeleteVoiceConnectorTerminationCredentials", "Required field: VoiceConnectorId, is not set");
2474 return DeleteVoiceConnectorTerminationCredentialsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2475 }
2476 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2477 Aws::StringStream ss;
2478 uri.AddPathSegments("/voice-connectors/");
2479 uri.AddPathSegment(request.GetVoiceConnectorId());
2480 uri.AddPathSegments("/termination/credentials");
2481 ss.str("?operation=delete");
2482 uri.SetQueryString(ss.str());
2483 return DeleteVoiceConnectorTerminationCredentialsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2484 }
2485
DeleteVoiceConnectorTerminationCredentialsCallable(const DeleteVoiceConnectorTerminationCredentialsRequest & request) const2486 DeleteVoiceConnectorTerminationCredentialsOutcomeCallable ChimeClient::DeleteVoiceConnectorTerminationCredentialsCallable(const DeleteVoiceConnectorTerminationCredentialsRequest& request) const
2487 {
2488 auto task = Aws::MakeShared< std::packaged_task< DeleteVoiceConnectorTerminationCredentialsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVoiceConnectorTerminationCredentials(request); } );
2489 auto packagedFunction = [task]() { (*task)(); };
2490 m_executor->Submit(packagedFunction);
2491 return task->get_future();
2492 }
2493
DeleteVoiceConnectorTerminationCredentialsAsync(const DeleteVoiceConnectorTerminationCredentialsRequest & request,const DeleteVoiceConnectorTerminationCredentialsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2494 void ChimeClient::DeleteVoiceConnectorTerminationCredentialsAsync(const DeleteVoiceConnectorTerminationCredentialsRequest& request, const DeleteVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2495 {
2496 m_executor->Submit( [this, request, handler, context](){ this->DeleteVoiceConnectorTerminationCredentialsAsyncHelper( request, handler, context ); } );
2497 }
2498
DeleteVoiceConnectorTerminationCredentialsAsyncHelper(const DeleteVoiceConnectorTerminationCredentialsRequest & request,const DeleteVoiceConnectorTerminationCredentialsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2499 void ChimeClient::DeleteVoiceConnectorTerminationCredentialsAsyncHelper(const DeleteVoiceConnectorTerminationCredentialsRequest& request, const DeleteVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2500 {
2501 handler(this, request, DeleteVoiceConnectorTerminationCredentials(request), context);
2502 }
2503
DescribeAppInstance(const DescribeAppInstanceRequest & request) const2504 DescribeAppInstanceOutcome ChimeClient::DescribeAppInstance(const DescribeAppInstanceRequest& request) const
2505 {
2506 if (!request.AppInstanceArnHasBeenSet())
2507 {
2508 AWS_LOGSTREAM_ERROR("DescribeAppInstance", "Required field: AppInstanceArn, is not set");
2509 return DescribeAppInstanceOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
2510 }
2511 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2512 if (m_enableHostPrefixInjection)
2513 {
2514 uri.SetAuthority("identity-" + uri.GetAuthority());
2515 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2516 {
2517 AWS_LOGSTREAM_ERROR("DescribeAppInstance", "Invalid DNS host: " << uri.GetAuthority());
2518 return DescribeAppInstanceOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2519 }
2520 }
2521 uri.AddPathSegments("/app-instances/");
2522 uri.AddPathSegment(request.GetAppInstanceArn());
2523 return DescribeAppInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2524 }
2525
DescribeAppInstanceCallable(const DescribeAppInstanceRequest & request) const2526 DescribeAppInstanceOutcomeCallable ChimeClient::DescribeAppInstanceCallable(const DescribeAppInstanceRequest& request) const
2527 {
2528 auto task = Aws::MakeShared< std::packaged_task< DescribeAppInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeAppInstance(request); } );
2529 auto packagedFunction = [task]() { (*task)(); };
2530 m_executor->Submit(packagedFunction);
2531 return task->get_future();
2532 }
2533
DescribeAppInstanceAsync(const DescribeAppInstanceRequest & request,const DescribeAppInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2534 void ChimeClient::DescribeAppInstanceAsync(const DescribeAppInstanceRequest& request, const DescribeAppInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2535 {
2536 m_executor->Submit( [this, request, handler, context](){ this->DescribeAppInstanceAsyncHelper( request, handler, context ); } );
2537 }
2538
DescribeAppInstanceAsyncHelper(const DescribeAppInstanceRequest & request,const DescribeAppInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2539 void ChimeClient::DescribeAppInstanceAsyncHelper(const DescribeAppInstanceRequest& request, const DescribeAppInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2540 {
2541 handler(this, request, DescribeAppInstance(request), context);
2542 }
2543
DescribeAppInstanceAdmin(const DescribeAppInstanceAdminRequest & request) const2544 DescribeAppInstanceAdminOutcome ChimeClient::DescribeAppInstanceAdmin(const DescribeAppInstanceAdminRequest& request) const
2545 {
2546 if (!request.AppInstanceAdminArnHasBeenSet())
2547 {
2548 AWS_LOGSTREAM_ERROR("DescribeAppInstanceAdmin", "Required field: AppInstanceAdminArn, is not set");
2549 return DescribeAppInstanceAdminOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceAdminArn]", false));
2550 }
2551 if (!request.AppInstanceArnHasBeenSet())
2552 {
2553 AWS_LOGSTREAM_ERROR("DescribeAppInstanceAdmin", "Required field: AppInstanceArn, is not set");
2554 return DescribeAppInstanceAdminOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
2555 }
2556 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2557 if (m_enableHostPrefixInjection)
2558 {
2559 uri.SetAuthority("identity-" + uri.GetAuthority());
2560 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2561 {
2562 AWS_LOGSTREAM_ERROR("DescribeAppInstanceAdmin", "Invalid DNS host: " << uri.GetAuthority());
2563 return DescribeAppInstanceAdminOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2564 }
2565 }
2566 uri.AddPathSegments("/app-instances/");
2567 uri.AddPathSegment(request.GetAppInstanceArn());
2568 uri.AddPathSegments("/admins/");
2569 uri.AddPathSegment(request.GetAppInstanceAdminArn());
2570 return DescribeAppInstanceAdminOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2571 }
2572
DescribeAppInstanceAdminCallable(const DescribeAppInstanceAdminRequest & request) const2573 DescribeAppInstanceAdminOutcomeCallable ChimeClient::DescribeAppInstanceAdminCallable(const DescribeAppInstanceAdminRequest& request) const
2574 {
2575 auto task = Aws::MakeShared< std::packaged_task< DescribeAppInstanceAdminOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeAppInstanceAdmin(request); } );
2576 auto packagedFunction = [task]() { (*task)(); };
2577 m_executor->Submit(packagedFunction);
2578 return task->get_future();
2579 }
2580
DescribeAppInstanceAdminAsync(const DescribeAppInstanceAdminRequest & request,const DescribeAppInstanceAdminResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2581 void ChimeClient::DescribeAppInstanceAdminAsync(const DescribeAppInstanceAdminRequest& request, const DescribeAppInstanceAdminResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2582 {
2583 m_executor->Submit( [this, request, handler, context](){ this->DescribeAppInstanceAdminAsyncHelper( request, handler, context ); } );
2584 }
2585
DescribeAppInstanceAdminAsyncHelper(const DescribeAppInstanceAdminRequest & request,const DescribeAppInstanceAdminResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2586 void ChimeClient::DescribeAppInstanceAdminAsyncHelper(const DescribeAppInstanceAdminRequest& request, const DescribeAppInstanceAdminResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2587 {
2588 handler(this, request, DescribeAppInstanceAdmin(request), context);
2589 }
2590
DescribeAppInstanceUser(const DescribeAppInstanceUserRequest & request) const2591 DescribeAppInstanceUserOutcome ChimeClient::DescribeAppInstanceUser(const DescribeAppInstanceUserRequest& request) const
2592 {
2593 if (!request.AppInstanceUserArnHasBeenSet())
2594 {
2595 AWS_LOGSTREAM_ERROR("DescribeAppInstanceUser", "Required field: AppInstanceUserArn, is not set");
2596 return DescribeAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceUserArn]", false));
2597 }
2598 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2599 if (m_enableHostPrefixInjection)
2600 {
2601 uri.SetAuthority("identity-" + uri.GetAuthority());
2602 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2603 {
2604 AWS_LOGSTREAM_ERROR("DescribeAppInstanceUser", "Invalid DNS host: " << uri.GetAuthority());
2605 return DescribeAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2606 }
2607 }
2608 uri.AddPathSegments("/app-instance-users/");
2609 uri.AddPathSegment(request.GetAppInstanceUserArn());
2610 return DescribeAppInstanceUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2611 }
2612
DescribeAppInstanceUserCallable(const DescribeAppInstanceUserRequest & request) const2613 DescribeAppInstanceUserOutcomeCallable ChimeClient::DescribeAppInstanceUserCallable(const DescribeAppInstanceUserRequest& request) const
2614 {
2615 auto task = Aws::MakeShared< std::packaged_task< DescribeAppInstanceUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeAppInstanceUser(request); } );
2616 auto packagedFunction = [task]() { (*task)(); };
2617 m_executor->Submit(packagedFunction);
2618 return task->get_future();
2619 }
2620
DescribeAppInstanceUserAsync(const DescribeAppInstanceUserRequest & request,const DescribeAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2621 void ChimeClient::DescribeAppInstanceUserAsync(const DescribeAppInstanceUserRequest& request, const DescribeAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2622 {
2623 m_executor->Submit( [this, request, handler, context](){ this->DescribeAppInstanceUserAsyncHelper( request, handler, context ); } );
2624 }
2625
DescribeAppInstanceUserAsyncHelper(const DescribeAppInstanceUserRequest & request,const DescribeAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2626 void ChimeClient::DescribeAppInstanceUserAsyncHelper(const DescribeAppInstanceUserRequest& request, const DescribeAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2627 {
2628 handler(this, request, DescribeAppInstanceUser(request), context);
2629 }
2630
DescribeChannel(const DescribeChannelRequest & request) const2631 DescribeChannelOutcome ChimeClient::DescribeChannel(const DescribeChannelRequest& request) const
2632 {
2633 if (!request.ChannelArnHasBeenSet())
2634 {
2635 AWS_LOGSTREAM_ERROR("DescribeChannel", "Required field: ChannelArn, is not set");
2636 return DescribeChannelOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
2637 }
2638 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2639 if (m_enableHostPrefixInjection)
2640 {
2641 uri.SetAuthority("messaging-" + uri.GetAuthority());
2642 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2643 {
2644 AWS_LOGSTREAM_ERROR("DescribeChannel", "Invalid DNS host: " << uri.GetAuthority());
2645 return DescribeChannelOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2646 }
2647 }
2648 uri.AddPathSegments("/channels/");
2649 uri.AddPathSegment(request.GetChannelArn());
2650 return DescribeChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2651 }
2652
DescribeChannelCallable(const DescribeChannelRequest & request) const2653 DescribeChannelOutcomeCallable ChimeClient::DescribeChannelCallable(const DescribeChannelRequest& request) const
2654 {
2655 auto task = Aws::MakeShared< std::packaged_task< DescribeChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeChannel(request); } );
2656 auto packagedFunction = [task]() { (*task)(); };
2657 m_executor->Submit(packagedFunction);
2658 return task->get_future();
2659 }
2660
DescribeChannelAsync(const DescribeChannelRequest & request,const DescribeChannelResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2661 void ChimeClient::DescribeChannelAsync(const DescribeChannelRequest& request, const DescribeChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2662 {
2663 m_executor->Submit( [this, request, handler, context](){ this->DescribeChannelAsyncHelper( request, handler, context ); } );
2664 }
2665
DescribeChannelAsyncHelper(const DescribeChannelRequest & request,const DescribeChannelResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2666 void ChimeClient::DescribeChannelAsyncHelper(const DescribeChannelRequest& request, const DescribeChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2667 {
2668 handler(this, request, DescribeChannel(request), context);
2669 }
2670
DescribeChannelBan(const DescribeChannelBanRequest & request) const2671 DescribeChannelBanOutcome ChimeClient::DescribeChannelBan(const DescribeChannelBanRequest& request) const
2672 {
2673 if (!request.ChannelArnHasBeenSet())
2674 {
2675 AWS_LOGSTREAM_ERROR("DescribeChannelBan", "Required field: ChannelArn, is not set");
2676 return DescribeChannelBanOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
2677 }
2678 if (!request.MemberArnHasBeenSet())
2679 {
2680 AWS_LOGSTREAM_ERROR("DescribeChannelBan", "Required field: MemberArn, is not set");
2681 return DescribeChannelBanOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MemberArn]", false));
2682 }
2683 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2684 if (m_enableHostPrefixInjection)
2685 {
2686 uri.SetAuthority("messaging-" + uri.GetAuthority());
2687 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2688 {
2689 AWS_LOGSTREAM_ERROR("DescribeChannelBan", "Invalid DNS host: " << uri.GetAuthority());
2690 return DescribeChannelBanOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2691 }
2692 }
2693 uri.AddPathSegments("/channels/");
2694 uri.AddPathSegment(request.GetChannelArn());
2695 uri.AddPathSegments("/bans/");
2696 uri.AddPathSegment(request.GetMemberArn());
2697 return DescribeChannelBanOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2698 }
2699
DescribeChannelBanCallable(const DescribeChannelBanRequest & request) const2700 DescribeChannelBanOutcomeCallable ChimeClient::DescribeChannelBanCallable(const DescribeChannelBanRequest& request) const
2701 {
2702 auto task = Aws::MakeShared< std::packaged_task< DescribeChannelBanOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeChannelBan(request); } );
2703 auto packagedFunction = [task]() { (*task)(); };
2704 m_executor->Submit(packagedFunction);
2705 return task->get_future();
2706 }
2707
DescribeChannelBanAsync(const DescribeChannelBanRequest & request,const DescribeChannelBanResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2708 void ChimeClient::DescribeChannelBanAsync(const DescribeChannelBanRequest& request, const DescribeChannelBanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2709 {
2710 m_executor->Submit( [this, request, handler, context](){ this->DescribeChannelBanAsyncHelper( request, handler, context ); } );
2711 }
2712
DescribeChannelBanAsyncHelper(const DescribeChannelBanRequest & request,const DescribeChannelBanResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2713 void ChimeClient::DescribeChannelBanAsyncHelper(const DescribeChannelBanRequest& request, const DescribeChannelBanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2714 {
2715 handler(this, request, DescribeChannelBan(request), context);
2716 }
2717
DescribeChannelMembership(const DescribeChannelMembershipRequest & request) const2718 DescribeChannelMembershipOutcome ChimeClient::DescribeChannelMembership(const DescribeChannelMembershipRequest& request) const
2719 {
2720 if (!request.ChannelArnHasBeenSet())
2721 {
2722 AWS_LOGSTREAM_ERROR("DescribeChannelMembership", "Required field: ChannelArn, is not set");
2723 return DescribeChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
2724 }
2725 if (!request.MemberArnHasBeenSet())
2726 {
2727 AWS_LOGSTREAM_ERROR("DescribeChannelMembership", "Required field: MemberArn, is not set");
2728 return DescribeChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MemberArn]", false));
2729 }
2730 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2731 if (m_enableHostPrefixInjection)
2732 {
2733 uri.SetAuthority("messaging-" + uri.GetAuthority());
2734 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2735 {
2736 AWS_LOGSTREAM_ERROR("DescribeChannelMembership", "Invalid DNS host: " << uri.GetAuthority());
2737 return DescribeChannelMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2738 }
2739 }
2740 uri.AddPathSegments("/channels/");
2741 uri.AddPathSegment(request.GetChannelArn());
2742 uri.AddPathSegments("/memberships/");
2743 uri.AddPathSegment(request.GetMemberArn());
2744 return DescribeChannelMembershipOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2745 }
2746
DescribeChannelMembershipCallable(const DescribeChannelMembershipRequest & request) const2747 DescribeChannelMembershipOutcomeCallable ChimeClient::DescribeChannelMembershipCallable(const DescribeChannelMembershipRequest& request) const
2748 {
2749 auto task = Aws::MakeShared< std::packaged_task< DescribeChannelMembershipOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeChannelMembership(request); } );
2750 auto packagedFunction = [task]() { (*task)(); };
2751 m_executor->Submit(packagedFunction);
2752 return task->get_future();
2753 }
2754
DescribeChannelMembershipAsync(const DescribeChannelMembershipRequest & request,const DescribeChannelMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2755 void ChimeClient::DescribeChannelMembershipAsync(const DescribeChannelMembershipRequest& request, const DescribeChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2756 {
2757 m_executor->Submit( [this, request, handler, context](){ this->DescribeChannelMembershipAsyncHelper( request, handler, context ); } );
2758 }
2759
DescribeChannelMembershipAsyncHelper(const DescribeChannelMembershipRequest & request,const DescribeChannelMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2760 void ChimeClient::DescribeChannelMembershipAsyncHelper(const DescribeChannelMembershipRequest& request, const DescribeChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2761 {
2762 handler(this, request, DescribeChannelMembership(request), context);
2763 }
2764
DescribeChannelMembershipForAppInstanceUser(const DescribeChannelMembershipForAppInstanceUserRequest & request) const2765 DescribeChannelMembershipForAppInstanceUserOutcome ChimeClient::DescribeChannelMembershipForAppInstanceUser(const DescribeChannelMembershipForAppInstanceUserRequest& request) const
2766 {
2767 if (!request.ChannelArnHasBeenSet())
2768 {
2769 AWS_LOGSTREAM_ERROR("DescribeChannelMembershipForAppInstanceUser", "Required field: ChannelArn, is not set");
2770 return DescribeChannelMembershipForAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
2771 }
2772 if (!request.AppInstanceUserArnHasBeenSet())
2773 {
2774 AWS_LOGSTREAM_ERROR("DescribeChannelMembershipForAppInstanceUser", "Required field: AppInstanceUserArn, is not set");
2775 return DescribeChannelMembershipForAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceUserArn]", false));
2776 }
2777 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2778 if (m_enableHostPrefixInjection)
2779 {
2780 uri.SetAuthority("messaging-" + uri.GetAuthority());
2781 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2782 {
2783 AWS_LOGSTREAM_ERROR("DescribeChannelMembershipForAppInstanceUser", "Invalid DNS host: " << uri.GetAuthority());
2784 return DescribeChannelMembershipForAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2785 }
2786 }
2787 Aws::StringStream ss;
2788 uri.AddPathSegments("/channels/");
2789 uri.AddPathSegment(request.GetChannelArn());
2790 ss.str("?scope=app-instance-user-membership");
2791 uri.SetQueryString(ss.str());
2792 return DescribeChannelMembershipForAppInstanceUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2793 }
2794
DescribeChannelMembershipForAppInstanceUserCallable(const DescribeChannelMembershipForAppInstanceUserRequest & request) const2795 DescribeChannelMembershipForAppInstanceUserOutcomeCallable ChimeClient::DescribeChannelMembershipForAppInstanceUserCallable(const DescribeChannelMembershipForAppInstanceUserRequest& request) const
2796 {
2797 auto task = Aws::MakeShared< std::packaged_task< DescribeChannelMembershipForAppInstanceUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeChannelMembershipForAppInstanceUser(request); } );
2798 auto packagedFunction = [task]() { (*task)(); };
2799 m_executor->Submit(packagedFunction);
2800 return task->get_future();
2801 }
2802
DescribeChannelMembershipForAppInstanceUserAsync(const DescribeChannelMembershipForAppInstanceUserRequest & request,const DescribeChannelMembershipForAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2803 void ChimeClient::DescribeChannelMembershipForAppInstanceUserAsync(const DescribeChannelMembershipForAppInstanceUserRequest& request, const DescribeChannelMembershipForAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2804 {
2805 m_executor->Submit( [this, request, handler, context](){ this->DescribeChannelMembershipForAppInstanceUserAsyncHelper( request, handler, context ); } );
2806 }
2807
DescribeChannelMembershipForAppInstanceUserAsyncHelper(const DescribeChannelMembershipForAppInstanceUserRequest & request,const DescribeChannelMembershipForAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2808 void ChimeClient::DescribeChannelMembershipForAppInstanceUserAsyncHelper(const DescribeChannelMembershipForAppInstanceUserRequest& request, const DescribeChannelMembershipForAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2809 {
2810 handler(this, request, DescribeChannelMembershipForAppInstanceUser(request), context);
2811 }
2812
DescribeChannelModeratedByAppInstanceUser(const DescribeChannelModeratedByAppInstanceUserRequest & request) const2813 DescribeChannelModeratedByAppInstanceUserOutcome ChimeClient::DescribeChannelModeratedByAppInstanceUser(const DescribeChannelModeratedByAppInstanceUserRequest& request) const
2814 {
2815 if (!request.ChannelArnHasBeenSet())
2816 {
2817 AWS_LOGSTREAM_ERROR("DescribeChannelModeratedByAppInstanceUser", "Required field: ChannelArn, is not set");
2818 return DescribeChannelModeratedByAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
2819 }
2820 if (!request.AppInstanceUserArnHasBeenSet())
2821 {
2822 AWS_LOGSTREAM_ERROR("DescribeChannelModeratedByAppInstanceUser", "Required field: AppInstanceUserArn, is not set");
2823 return DescribeChannelModeratedByAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceUserArn]", false));
2824 }
2825 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2826 if (m_enableHostPrefixInjection)
2827 {
2828 uri.SetAuthority("messaging-" + uri.GetAuthority());
2829 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2830 {
2831 AWS_LOGSTREAM_ERROR("DescribeChannelModeratedByAppInstanceUser", "Invalid DNS host: " << uri.GetAuthority());
2832 return DescribeChannelModeratedByAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2833 }
2834 }
2835 Aws::StringStream ss;
2836 uri.AddPathSegments("/channels/");
2837 uri.AddPathSegment(request.GetChannelArn());
2838 ss.str("?scope=app-instance-user-moderated-channel");
2839 uri.SetQueryString(ss.str());
2840 return DescribeChannelModeratedByAppInstanceUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2841 }
2842
DescribeChannelModeratedByAppInstanceUserCallable(const DescribeChannelModeratedByAppInstanceUserRequest & request) const2843 DescribeChannelModeratedByAppInstanceUserOutcomeCallable ChimeClient::DescribeChannelModeratedByAppInstanceUserCallable(const DescribeChannelModeratedByAppInstanceUserRequest& request) const
2844 {
2845 auto task = Aws::MakeShared< std::packaged_task< DescribeChannelModeratedByAppInstanceUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeChannelModeratedByAppInstanceUser(request); } );
2846 auto packagedFunction = [task]() { (*task)(); };
2847 m_executor->Submit(packagedFunction);
2848 return task->get_future();
2849 }
2850
DescribeChannelModeratedByAppInstanceUserAsync(const DescribeChannelModeratedByAppInstanceUserRequest & request,const DescribeChannelModeratedByAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2851 void ChimeClient::DescribeChannelModeratedByAppInstanceUserAsync(const DescribeChannelModeratedByAppInstanceUserRequest& request, const DescribeChannelModeratedByAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2852 {
2853 m_executor->Submit( [this, request, handler, context](){ this->DescribeChannelModeratedByAppInstanceUserAsyncHelper( request, handler, context ); } );
2854 }
2855
DescribeChannelModeratedByAppInstanceUserAsyncHelper(const DescribeChannelModeratedByAppInstanceUserRequest & request,const DescribeChannelModeratedByAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2856 void ChimeClient::DescribeChannelModeratedByAppInstanceUserAsyncHelper(const DescribeChannelModeratedByAppInstanceUserRequest& request, const DescribeChannelModeratedByAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2857 {
2858 handler(this, request, DescribeChannelModeratedByAppInstanceUser(request), context);
2859 }
2860
DescribeChannelModerator(const DescribeChannelModeratorRequest & request) const2861 DescribeChannelModeratorOutcome ChimeClient::DescribeChannelModerator(const DescribeChannelModeratorRequest& request) const
2862 {
2863 if (!request.ChannelArnHasBeenSet())
2864 {
2865 AWS_LOGSTREAM_ERROR("DescribeChannelModerator", "Required field: ChannelArn, is not set");
2866 return DescribeChannelModeratorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
2867 }
2868 if (!request.ChannelModeratorArnHasBeenSet())
2869 {
2870 AWS_LOGSTREAM_ERROR("DescribeChannelModerator", "Required field: ChannelModeratorArn, is not set");
2871 return DescribeChannelModeratorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelModeratorArn]", false));
2872 }
2873 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2874 if (m_enableHostPrefixInjection)
2875 {
2876 uri.SetAuthority("messaging-" + uri.GetAuthority());
2877 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2878 {
2879 AWS_LOGSTREAM_ERROR("DescribeChannelModerator", "Invalid DNS host: " << uri.GetAuthority());
2880 return DescribeChannelModeratorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2881 }
2882 }
2883 uri.AddPathSegments("/channels/");
2884 uri.AddPathSegment(request.GetChannelArn());
2885 uri.AddPathSegments("/moderators/");
2886 uri.AddPathSegment(request.GetChannelModeratorArn());
2887 return DescribeChannelModeratorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
2888 }
2889
DescribeChannelModeratorCallable(const DescribeChannelModeratorRequest & request) const2890 DescribeChannelModeratorOutcomeCallable ChimeClient::DescribeChannelModeratorCallable(const DescribeChannelModeratorRequest& request) const
2891 {
2892 auto task = Aws::MakeShared< std::packaged_task< DescribeChannelModeratorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeChannelModerator(request); } );
2893 auto packagedFunction = [task]() { (*task)(); };
2894 m_executor->Submit(packagedFunction);
2895 return task->get_future();
2896 }
2897
DescribeChannelModeratorAsync(const DescribeChannelModeratorRequest & request,const DescribeChannelModeratorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2898 void ChimeClient::DescribeChannelModeratorAsync(const DescribeChannelModeratorRequest& request, const DescribeChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2899 {
2900 m_executor->Submit( [this, request, handler, context](){ this->DescribeChannelModeratorAsyncHelper( request, handler, context ); } );
2901 }
2902
DescribeChannelModeratorAsyncHelper(const DescribeChannelModeratorRequest & request,const DescribeChannelModeratorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2903 void ChimeClient::DescribeChannelModeratorAsyncHelper(const DescribeChannelModeratorRequest& request, const DescribeChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2904 {
2905 handler(this, request, DescribeChannelModerator(request), context);
2906 }
2907
DisassociatePhoneNumberFromUser(const DisassociatePhoneNumberFromUserRequest & request) const2908 DisassociatePhoneNumberFromUserOutcome ChimeClient::DisassociatePhoneNumberFromUser(const DisassociatePhoneNumberFromUserRequest& request) const
2909 {
2910 if (!request.AccountIdHasBeenSet())
2911 {
2912 AWS_LOGSTREAM_ERROR("DisassociatePhoneNumberFromUser", "Required field: AccountId, is not set");
2913 return DisassociatePhoneNumberFromUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
2914 }
2915 if (!request.UserIdHasBeenSet())
2916 {
2917 AWS_LOGSTREAM_ERROR("DisassociatePhoneNumberFromUser", "Required field: UserId, is not set");
2918 return DisassociatePhoneNumberFromUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
2919 }
2920 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2921 Aws::StringStream ss;
2922 uri.AddPathSegments("/accounts/");
2923 uri.AddPathSegment(request.GetAccountId());
2924 uri.AddPathSegments("/users/");
2925 uri.AddPathSegment(request.GetUserId());
2926 ss.str("?operation=disassociate-phone-number");
2927 uri.SetQueryString(ss.str());
2928 return DisassociatePhoneNumberFromUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2929 }
2930
DisassociatePhoneNumberFromUserCallable(const DisassociatePhoneNumberFromUserRequest & request) const2931 DisassociatePhoneNumberFromUserOutcomeCallable ChimeClient::DisassociatePhoneNumberFromUserCallable(const DisassociatePhoneNumberFromUserRequest& request) const
2932 {
2933 auto task = Aws::MakeShared< std::packaged_task< DisassociatePhoneNumberFromUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociatePhoneNumberFromUser(request); } );
2934 auto packagedFunction = [task]() { (*task)(); };
2935 m_executor->Submit(packagedFunction);
2936 return task->get_future();
2937 }
2938
DisassociatePhoneNumberFromUserAsync(const DisassociatePhoneNumberFromUserRequest & request,const DisassociatePhoneNumberFromUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2939 void ChimeClient::DisassociatePhoneNumberFromUserAsync(const DisassociatePhoneNumberFromUserRequest& request, const DisassociatePhoneNumberFromUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2940 {
2941 m_executor->Submit( [this, request, handler, context](){ this->DisassociatePhoneNumberFromUserAsyncHelper( request, handler, context ); } );
2942 }
2943
DisassociatePhoneNumberFromUserAsyncHelper(const DisassociatePhoneNumberFromUserRequest & request,const DisassociatePhoneNumberFromUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2944 void ChimeClient::DisassociatePhoneNumberFromUserAsyncHelper(const DisassociatePhoneNumberFromUserRequest& request, const DisassociatePhoneNumberFromUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2945 {
2946 handler(this, request, DisassociatePhoneNumberFromUser(request), context);
2947 }
2948
DisassociatePhoneNumbersFromVoiceConnector(const DisassociatePhoneNumbersFromVoiceConnectorRequest & request) const2949 DisassociatePhoneNumbersFromVoiceConnectorOutcome ChimeClient::DisassociatePhoneNumbersFromVoiceConnector(const DisassociatePhoneNumbersFromVoiceConnectorRequest& request) const
2950 {
2951 if (!request.VoiceConnectorIdHasBeenSet())
2952 {
2953 AWS_LOGSTREAM_ERROR("DisassociatePhoneNumbersFromVoiceConnector", "Required field: VoiceConnectorId, is not set");
2954 return DisassociatePhoneNumbersFromVoiceConnectorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
2955 }
2956 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2957 Aws::StringStream ss;
2958 uri.AddPathSegments("/voice-connectors/");
2959 uri.AddPathSegment(request.GetVoiceConnectorId());
2960 ss.str("?operation=disassociate-phone-numbers");
2961 uri.SetQueryString(ss.str());
2962 return DisassociatePhoneNumbersFromVoiceConnectorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2963 }
2964
DisassociatePhoneNumbersFromVoiceConnectorCallable(const DisassociatePhoneNumbersFromVoiceConnectorRequest & request) const2965 DisassociatePhoneNumbersFromVoiceConnectorOutcomeCallable ChimeClient::DisassociatePhoneNumbersFromVoiceConnectorCallable(const DisassociatePhoneNumbersFromVoiceConnectorRequest& request) const
2966 {
2967 auto task = Aws::MakeShared< std::packaged_task< DisassociatePhoneNumbersFromVoiceConnectorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociatePhoneNumbersFromVoiceConnector(request); } );
2968 auto packagedFunction = [task]() { (*task)(); };
2969 m_executor->Submit(packagedFunction);
2970 return task->get_future();
2971 }
2972
DisassociatePhoneNumbersFromVoiceConnectorAsync(const DisassociatePhoneNumbersFromVoiceConnectorRequest & request,const DisassociatePhoneNumbersFromVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2973 void ChimeClient::DisassociatePhoneNumbersFromVoiceConnectorAsync(const DisassociatePhoneNumbersFromVoiceConnectorRequest& request, const DisassociatePhoneNumbersFromVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2974 {
2975 m_executor->Submit( [this, request, handler, context](){ this->DisassociatePhoneNumbersFromVoiceConnectorAsyncHelper( request, handler, context ); } );
2976 }
2977
DisassociatePhoneNumbersFromVoiceConnectorAsyncHelper(const DisassociatePhoneNumbersFromVoiceConnectorRequest & request,const DisassociatePhoneNumbersFromVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2978 void ChimeClient::DisassociatePhoneNumbersFromVoiceConnectorAsyncHelper(const DisassociatePhoneNumbersFromVoiceConnectorRequest& request, const DisassociatePhoneNumbersFromVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2979 {
2980 handler(this, request, DisassociatePhoneNumbersFromVoiceConnector(request), context);
2981 }
2982
DisassociatePhoneNumbersFromVoiceConnectorGroup(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequest & request) const2983 DisassociatePhoneNumbersFromVoiceConnectorGroupOutcome ChimeClient::DisassociatePhoneNumbersFromVoiceConnectorGroup(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequest& request) const
2984 {
2985 if (!request.VoiceConnectorGroupIdHasBeenSet())
2986 {
2987 AWS_LOGSTREAM_ERROR("DisassociatePhoneNumbersFromVoiceConnectorGroup", "Required field: VoiceConnectorGroupId, is not set");
2988 return DisassociatePhoneNumbersFromVoiceConnectorGroupOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorGroupId]", false));
2989 }
2990 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2991 Aws::StringStream ss;
2992 uri.AddPathSegments("/voice-connector-groups/");
2993 uri.AddPathSegment(request.GetVoiceConnectorGroupId());
2994 ss.str("?operation=disassociate-phone-numbers");
2995 uri.SetQueryString(ss.str());
2996 return DisassociatePhoneNumbersFromVoiceConnectorGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
2997 }
2998
DisassociatePhoneNumbersFromVoiceConnectorGroupCallable(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequest & request) const2999 DisassociatePhoneNumbersFromVoiceConnectorGroupOutcomeCallable ChimeClient::DisassociatePhoneNumbersFromVoiceConnectorGroupCallable(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequest& request) const
3000 {
3001 auto task = Aws::MakeShared< std::packaged_task< DisassociatePhoneNumbersFromVoiceConnectorGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociatePhoneNumbersFromVoiceConnectorGroup(request); } );
3002 auto packagedFunction = [task]() { (*task)(); };
3003 m_executor->Submit(packagedFunction);
3004 return task->get_future();
3005 }
3006
DisassociatePhoneNumbersFromVoiceConnectorGroupAsync(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequest & request,const DisassociatePhoneNumbersFromVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3007 void ChimeClient::DisassociatePhoneNumbersFromVoiceConnectorGroupAsync(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequest& request, const DisassociatePhoneNumbersFromVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3008 {
3009 m_executor->Submit( [this, request, handler, context](){ this->DisassociatePhoneNumbersFromVoiceConnectorGroupAsyncHelper( request, handler, context ); } );
3010 }
3011
DisassociatePhoneNumbersFromVoiceConnectorGroupAsyncHelper(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequest & request,const DisassociatePhoneNumbersFromVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3012 void ChimeClient::DisassociatePhoneNumbersFromVoiceConnectorGroupAsyncHelper(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequest& request, const DisassociatePhoneNumbersFromVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3013 {
3014 handler(this, request, DisassociatePhoneNumbersFromVoiceConnectorGroup(request), context);
3015 }
3016
DisassociateSigninDelegateGroupsFromAccount(const DisassociateSigninDelegateGroupsFromAccountRequest & request) const3017 DisassociateSigninDelegateGroupsFromAccountOutcome ChimeClient::DisassociateSigninDelegateGroupsFromAccount(const DisassociateSigninDelegateGroupsFromAccountRequest& request) const
3018 {
3019 if (!request.AccountIdHasBeenSet())
3020 {
3021 AWS_LOGSTREAM_ERROR("DisassociateSigninDelegateGroupsFromAccount", "Required field: AccountId, is not set");
3022 return DisassociateSigninDelegateGroupsFromAccountOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3023 }
3024 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3025 Aws::StringStream ss;
3026 uri.AddPathSegments("/accounts/");
3027 uri.AddPathSegment(request.GetAccountId());
3028 ss.str("?operation=disassociate-signin-delegate-groups");
3029 uri.SetQueryString(ss.str());
3030 return DisassociateSigninDelegateGroupsFromAccountOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
3031 }
3032
DisassociateSigninDelegateGroupsFromAccountCallable(const DisassociateSigninDelegateGroupsFromAccountRequest & request) const3033 DisassociateSigninDelegateGroupsFromAccountOutcomeCallable ChimeClient::DisassociateSigninDelegateGroupsFromAccountCallable(const DisassociateSigninDelegateGroupsFromAccountRequest& request) const
3034 {
3035 auto task = Aws::MakeShared< std::packaged_task< DisassociateSigninDelegateGroupsFromAccountOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateSigninDelegateGroupsFromAccount(request); } );
3036 auto packagedFunction = [task]() { (*task)(); };
3037 m_executor->Submit(packagedFunction);
3038 return task->get_future();
3039 }
3040
DisassociateSigninDelegateGroupsFromAccountAsync(const DisassociateSigninDelegateGroupsFromAccountRequest & request,const DisassociateSigninDelegateGroupsFromAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3041 void ChimeClient::DisassociateSigninDelegateGroupsFromAccountAsync(const DisassociateSigninDelegateGroupsFromAccountRequest& request, const DisassociateSigninDelegateGroupsFromAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3042 {
3043 m_executor->Submit( [this, request, handler, context](){ this->DisassociateSigninDelegateGroupsFromAccountAsyncHelper( request, handler, context ); } );
3044 }
3045
DisassociateSigninDelegateGroupsFromAccountAsyncHelper(const DisassociateSigninDelegateGroupsFromAccountRequest & request,const DisassociateSigninDelegateGroupsFromAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3046 void ChimeClient::DisassociateSigninDelegateGroupsFromAccountAsyncHelper(const DisassociateSigninDelegateGroupsFromAccountRequest& request, const DisassociateSigninDelegateGroupsFromAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3047 {
3048 handler(this, request, DisassociateSigninDelegateGroupsFromAccount(request), context);
3049 }
3050
GetAccount(const GetAccountRequest & request) const3051 GetAccountOutcome ChimeClient::GetAccount(const GetAccountRequest& request) const
3052 {
3053 if (!request.AccountIdHasBeenSet())
3054 {
3055 AWS_LOGSTREAM_ERROR("GetAccount", "Required field: AccountId, is not set");
3056 return GetAccountOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3057 }
3058 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3059 uri.AddPathSegments("/accounts/");
3060 uri.AddPathSegment(request.GetAccountId());
3061 return GetAccountOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3062 }
3063
GetAccountCallable(const GetAccountRequest & request) const3064 GetAccountOutcomeCallable ChimeClient::GetAccountCallable(const GetAccountRequest& request) const
3065 {
3066 auto task = Aws::MakeShared< std::packaged_task< GetAccountOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAccount(request); } );
3067 auto packagedFunction = [task]() { (*task)(); };
3068 m_executor->Submit(packagedFunction);
3069 return task->get_future();
3070 }
3071
GetAccountAsync(const GetAccountRequest & request,const GetAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3072 void ChimeClient::GetAccountAsync(const GetAccountRequest& request, const GetAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3073 {
3074 m_executor->Submit( [this, request, handler, context](){ this->GetAccountAsyncHelper( request, handler, context ); } );
3075 }
3076
GetAccountAsyncHelper(const GetAccountRequest & request,const GetAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3077 void ChimeClient::GetAccountAsyncHelper(const GetAccountRequest& request, const GetAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3078 {
3079 handler(this, request, GetAccount(request), context);
3080 }
3081
GetAccountSettings(const GetAccountSettingsRequest & request) const3082 GetAccountSettingsOutcome ChimeClient::GetAccountSettings(const GetAccountSettingsRequest& request) const
3083 {
3084 if (!request.AccountIdHasBeenSet())
3085 {
3086 AWS_LOGSTREAM_ERROR("GetAccountSettings", "Required field: AccountId, is not set");
3087 return GetAccountSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3088 }
3089 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3090 uri.AddPathSegments("/accounts/");
3091 uri.AddPathSegment(request.GetAccountId());
3092 uri.AddPathSegments("/settings");
3093 return GetAccountSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3094 }
3095
GetAccountSettingsCallable(const GetAccountSettingsRequest & request) const3096 GetAccountSettingsOutcomeCallable ChimeClient::GetAccountSettingsCallable(const GetAccountSettingsRequest& request) const
3097 {
3098 auto task = Aws::MakeShared< std::packaged_task< GetAccountSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAccountSettings(request); } );
3099 auto packagedFunction = [task]() { (*task)(); };
3100 m_executor->Submit(packagedFunction);
3101 return task->get_future();
3102 }
3103
GetAccountSettingsAsync(const GetAccountSettingsRequest & request,const GetAccountSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3104 void ChimeClient::GetAccountSettingsAsync(const GetAccountSettingsRequest& request, const GetAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3105 {
3106 m_executor->Submit( [this, request, handler, context](){ this->GetAccountSettingsAsyncHelper( request, handler, context ); } );
3107 }
3108
GetAccountSettingsAsyncHelper(const GetAccountSettingsRequest & request,const GetAccountSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3109 void ChimeClient::GetAccountSettingsAsyncHelper(const GetAccountSettingsRequest& request, const GetAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3110 {
3111 handler(this, request, GetAccountSettings(request), context);
3112 }
3113
GetAppInstanceRetentionSettings(const GetAppInstanceRetentionSettingsRequest & request) const3114 GetAppInstanceRetentionSettingsOutcome ChimeClient::GetAppInstanceRetentionSettings(const GetAppInstanceRetentionSettingsRequest& request) const
3115 {
3116 if (!request.AppInstanceArnHasBeenSet())
3117 {
3118 AWS_LOGSTREAM_ERROR("GetAppInstanceRetentionSettings", "Required field: AppInstanceArn, is not set");
3119 return GetAppInstanceRetentionSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
3120 }
3121 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3122 if (m_enableHostPrefixInjection)
3123 {
3124 uri.SetAuthority("identity-" + uri.GetAuthority());
3125 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
3126 {
3127 AWS_LOGSTREAM_ERROR("GetAppInstanceRetentionSettings", "Invalid DNS host: " << uri.GetAuthority());
3128 return GetAppInstanceRetentionSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
3129 }
3130 }
3131 uri.AddPathSegments("/app-instances/");
3132 uri.AddPathSegment(request.GetAppInstanceArn());
3133 uri.AddPathSegments("/retention-settings");
3134 return GetAppInstanceRetentionSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3135 }
3136
GetAppInstanceRetentionSettingsCallable(const GetAppInstanceRetentionSettingsRequest & request) const3137 GetAppInstanceRetentionSettingsOutcomeCallable ChimeClient::GetAppInstanceRetentionSettingsCallable(const GetAppInstanceRetentionSettingsRequest& request) const
3138 {
3139 auto task = Aws::MakeShared< std::packaged_task< GetAppInstanceRetentionSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAppInstanceRetentionSettings(request); } );
3140 auto packagedFunction = [task]() { (*task)(); };
3141 m_executor->Submit(packagedFunction);
3142 return task->get_future();
3143 }
3144
GetAppInstanceRetentionSettingsAsync(const GetAppInstanceRetentionSettingsRequest & request,const GetAppInstanceRetentionSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3145 void ChimeClient::GetAppInstanceRetentionSettingsAsync(const GetAppInstanceRetentionSettingsRequest& request, const GetAppInstanceRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3146 {
3147 m_executor->Submit( [this, request, handler, context](){ this->GetAppInstanceRetentionSettingsAsyncHelper( request, handler, context ); } );
3148 }
3149
GetAppInstanceRetentionSettingsAsyncHelper(const GetAppInstanceRetentionSettingsRequest & request,const GetAppInstanceRetentionSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3150 void ChimeClient::GetAppInstanceRetentionSettingsAsyncHelper(const GetAppInstanceRetentionSettingsRequest& request, const GetAppInstanceRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3151 {
3152 handler(this, request, GetAppInstanceRetentionSettings(request), context);
3153 }
3154
GetAppInstanceStreamingConfigurations(const GetAppInstanceStreamingConfigurationsRequest & request) const3155 GetAppInstanceStreamingConfigurationsOutcome ChimeClient::GetAppInstanceStreamingConfigurations(const GetAppInstanceStreamingConfigurationsRequest& request) const
3156 {
3157 if (!request.AppInstanceArnHasBeenSet())
3158 {
3159 AWS_LOGSTREAM_ERROR("GetAppInstanceStreamingConfigurations", "Required field: AppInstanceArn, is not set");
3160 return GetAppInstanceStreamingConfigurationsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
3161 }
3162 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3163 uri.AddPathSegments("/app-instances/");
3164 uri.AddPathSegment(request.GetAppInstanceArn());
3165 uri.AddPathSegments("/streaming-configurations");
3166 return GetAppInstanceStreamingConfigurationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3167 }
3168
GetAppInstanceStreamingConfigurationsCallable(const GetAppInstanceStreamingConfigurationsRequest & request) const3169 GetAppInstanceStreamingConfigurationsOutcomeCallable ChimeClient::GetAppInstanceStreamingConfigurationsCallable(const GetAppInstanceStreamingConfigurationsRequest& request) const
3170 {
3171 auto task = Aws::MakeShared< std::packaged_task< GetAppInstanceStreamingConfigurationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAppInstanceStreamingConfigurations(request); } );
3172 auto packagedFunction = [task]() { (*task)(); };
3173 m_executor->Submit(packagedFunction);
3174 return task->get_future();
3175 }
3176
GetAppInstanceStreamingConfigurationsAsync(const GetAppInstanceStreamingConfigurationsRequest & request,const GetAppInstanceStreamingConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3177 void ChimeClient::GetAppInstanceStreamingConfigurationsAsync(const GetAppInstanceStreamingConfigurationsRequest& request, const GetAppInstanceStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3178 {
3179 m_executor->Submit( [this, request, handler, context](){ this->GetAppInstanceStreamingConfigurationsAsyncHelper( request, handler, context ); } );
3180 }
3181
GetAppInstanceStreamingConfigurationsAsyncHelper(const GetAppInstanceStreamingConfigurationsRequest & request,const GetAppInstanceStreamingConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3182 void ChimeClient::GetAppInstanceStreamingConfigurationsAsyncHelper(const GetAppInstanceStreamingConfigurationsRequest& request, const GetAppInstanceStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3183 {
3184 handler(this, request, GetAppInstanceStreamingConfigurations(request), context);
3185 }
3186
GetAttendee(const GetAttendeeRequest & request) const3187 GetAttendeeOutcome ChimeClient::GetAttendee(const GetAttendeeRequest& request) const
3188 {
3189 if (!request.MeetingIdHasBeenSet())
3190 {
3191 AWS_LOGSTREAM_ERROR("GetAttendee", "Required field: MeetingId, is not set");
3192 return GetAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
3193 }
3194 if (!request.AttendeeIdHasBeenSet())
3195 {
3196 AWS_LOGSTREAM_ERROR("GetAttendee", "Required field: AttendeeId, is not set");
3197 return GetAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AttendeeId]", false));
3198 }
3199 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3200 uri.AddPathSegments("/meetings/");
3201 uri.AddPathSegment(request.GetMeetingId());
3202 uri.AddPathSegments("/attendees/");
3203 uri.AddPathSegment(request.GetAttendeeId());
3204 return GetAttendeeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3205 }
3206
GetAttendeeCallable(const GetAttendeeRequest & request) const3207 GetAttendeeOutcomeCallable ChimeClient::GetAttendeeCallable(const GetAttendeeRequest& request) const
3208 {
3209 auto task = Aws::MakeShared< std::packaged_task< GetAttendeeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAttendee(request); } );
3210 auto packagedFunction = [task]() { (*task)(); };
3211 m_executor->Submit(packagedFunction);
3212 return task->get_future();
3213 }
3214
GetAttendeeAsync(const GetAttendeeRequest & request,const GetAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3215 void ChimeClient::GetAttendeeAsync(const GetAttendeeRequest& request, const GetAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3216 {
3217 m_executor->Submit( [this, request, handler, context](){ this->GetAttendeeAsyncHelper( request, handler, context ); } );
3218 }
3219
GetAttendeeAsyncHelper(const GetAttendeeRequest & request,const GetAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3220 void ChimeClient::GetAttendeeAsyncHelper(const GetAttendeeRequest& request, const GetAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3221 {
3222 handler(this, request, GetAttendee(request), context);
3223 }
3224
GetBot(const GetBotRequest & request) const3225 GetBotOutcome ChimeClient::GetBot(const GetBotRequest& request) const
3226 {
3227 if (!request.AccountIdHasBeenSet())
3228 {
3229 AWS_LOGSTREAM_ERROR("GetBot", "Required field: AccountId, is not set");
3230 return GetBotOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3231 }
3232 if (!request.BotIdHasBeenSet())
3233 {
3234 AWS_LOGSTREAM_ERROR("GetBot", "Required field: BotId, is not set");
3235 return GetBotOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [BotId]", false));
3236 }
3237 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3238 uri.AddPathSegments("/accounts/");
3239 uri.AddPathSegment(request.GetAccountId());
3240 uri.AddPathSegments("/bots/");
3241 uri.AddPathSegment(request.GetBotId());
3242 return GetBotOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3243 }
3244
GetBotCallable(const GetBotRequest & request) const3245 GetBotOutcomeCallable ChimeClient::GetBotCallable(const GetBotRequest& request) const
3246 {
3247 auto task = Aws::MakeShared< std::packaged_task< GetBotOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetBot(request); } );
3248 auto packagedFunction = [task]() { (*task)(); };
3249 m_executor->Submit(packagedFunction);
3250 return task->get_future();
3251 }
3252
GetBotAsync(const GetBotRequest & request,const GetBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3253 void ChimeClient::GetBotAsync(const GetBotRequest& request, const GetBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3254 {
3255 m_executor->Submit( [this, request, handler, context](){ this->GetBotAsyncHelper( request, handler, context ); } );
3256 }
3257
GetBotAsyncHelper(const GetBotRequest & request,const GetBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3258 void ChimeClient::GetBotAsyncHelper(const GetBotRequest& request, const GetBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3259 {
3260 handler(this, request, GetBot(request), context);
3261 }
3262
GetChannelMessage(const GetChannelMessageRequest & request) const3263 GetChannelMessageOutcome ChimeClient::GetChannelMessage(const GetChannelMessageRequest& request) const
3264 {
3265 if (!request.ChannelArnHasBeenSet())
3266 {
3267 AWS_LOGSTREAM_ERROR("GetChannelMessage", "Required field: ChannelArn, is not set");
3268 return GetChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
3269 }
3270 if (!request.MessageIdHasBeenSet())
3271 {
3272 AWS_LOGSTREAM_ERROR("GetChannelMessage", "Required field: MessageId, is not set");
3273 return GetChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MessageId]", false));
3274 }
3275 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3276 if (m_enableHostPrefixInjection)
3277 {
3278 uri.SetAuthority("messaging-" + uri.GetAuthority());
3279 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
3280 {
3281 AWS_LOGSTREAM_ERROR("GetChannelMessage", "Invalid DNS host: " << uri.GetAuthority());
3282 return GetChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
3283 }
3284 }
3285 uri.AddPathSegments("/channels/");
3286 uri.AddPathSegment(request.GetChannelArn());
3287 uri.AddPathSegments("/messages/");
3288 uri.AddPathSegment(request.GetMessageId());
3289 return GetChannelMessageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3290 }
3291
GetChannelMessageCallable(const GetChannelMessageRequest & request) const3292 GetChannelMessageOutcomeCallable ChimeClient::GetChannelMessageCallable(const GetChannelMessageRequest& request) const
3293 {
3294 auto task = Aws::MakeShared< std::packaged_task< GetChannelMessageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetChannelMessage(request); } );
3295 auto packagedFunction = [task]() { (*task)(); };
3296 m_executor->Submit(packagedFunction);
3297 return task->get_future();
3298 }
3299
GetChannelMessageAsync(const GetChannelMessageRequest & request,const GetChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3300 void ChimeClient::GetChannelMessageAsync(const GetChannelMessageRequest& request, const GetChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3301 {
3302 m_executor->Submit( [this, request, handler, context](){ this->GetChannelMessageAsyncHelper( request, handler, context ); } );
3303 }
3304
GetChannelMessageAsyncHelper(const GetChannelMessageRequest & request,const GetChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3305 void ChimeClient::GetChannelMessageAsyncHelper(const GetChannelMessageRequest& request, const GetChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3306 {
3307 handler(this, request, GetChannelMessage(request), context);
3308 }
3309
GetEventsConfiguration(const GetEventsConfigurationRequest & request) const3310 GetEventsConfigurationOutcome ChimeClient::GetEventsConfiguration(const GetEventsConfigurationRequest& request) const
3311 {
3312 if (!request.AccountIdHasBeenSet())
3313 {
3314 AWS_LOGSTREAM_ERROR("GetEventsConfiguration", "Required field: AccountId, is not set");
3315 return GetEventsConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3316 }
3317 if (!request.BotIdHasBeenSet())
3318 {
3319 AWS_LOGSTREAM_ERROR("GetEventsConfiguration", "Required field: BotId, is not set");
3320 return GetEventsConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [BotId]", false));
3321 }
3322 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3323 uri.AddPathSegments("/accounts/");
3324 uri.AddPathSegment(request.GetAccountId());
3325 uri.AddPathSegments("/bots/");
3326 uri.AddPathSegment(request.GetBotId());
3327 uri.AddPathSegments("/events-configuration");
3328 return GetEventsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3329 }
3330
GetEventsConfigurationCallable(const GetEventsConfigurationRequest & request) const3331 GetEventsConfigurationOutcomeCallable ChimeClient::GetEventsConfigurationCallable(const GetEventsConfigurationRequest& request) const
3332 {
3333 auto task = Aws::MakeShared< std::packaged_task< GetEventsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetEventsConfiguration(request); } );
3334 auto packagedFunction = [task]() { (*task)(); };
3335 m_executor->Submit(packagedFunction);
3336 return task->get_future();
3337 }
3338
GetEventsConfigurationAsync(const GetEventsConfigurationRequest & request,const GetEventsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3339 void ChimeClient::GetEventsConfigurationAsync(const GetEventsConfigurationRequest& request, const GetEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3340 {
3341 m_executor->Submit( [this, request, handler, context](){ this->GetEventsConfigurationAsyncHelper( request, handler, context ); } );
3342 }
3343
GetEventsConfigurationAsyncHelper(const GetEventsConfigurationRequest & request,const GetEventsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3344 void ChimeClient::GetEventsConfigurationAsyncHelper(const GetEventsConfigurationRequest& request, const GetEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3345 {
3346 handler(this, request, GetEventsConfiguration(request), context);
3347 }
3348
GetGlobalSettings() const3349 GetGlobalSettingsOutcome ChimeClient::GetGlobalSettings() const
3350 {
3351 Aws::StringStream ss;
3352 ss << m_baseUri << "/settings";
3353 return GetGlobalSettingsOutcome(MakeRequest(ss.str(), Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, "GetGlobalSettings"));
3354 }
3355
GetGlobalSettingsCallable() const3356 GetGlobalSettingsOutcomeCallable ChimeClient::GetGlobalSettingsCallable() const
3357 {
3358 auto task = Aws::MakeShared< std::packaged_task< GetGlobalSettingsOutcome() > >(ALLOCATION_TAG, [this](){ return this->GetGlobalSettings(); } );
3359 auto packagedFunction = [task]() { (*task)(); };
3360 m_executor->Submit(packagedFunction);
3361 return task->get_future();
3362 }
3363
GetGlobalSettingsAsync(const GetGlobalSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3364 void ChimeClient::GetGlobalSettingsAsync(const GetGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3365 {
3366 m_executor->Submit( [this, handler, context](){ this->GetGlobalSettingsAsyncHelper( handler, context ); } );
3367 }
3368
GetGlobalSettingsAsyncHelper(const GetGlobalSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3369 void ChimeClient::GetGlobalSettingsAsyncHelper(const GetGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3370 {
3371 handler(this, GetGlobalSettings(), context);
3372 }
3373
GetMediaCapturePipeline(const GetMediaCapturePipelineRequest & request) const3374 GetMediaCapturePipelineOutcome ChimeClient::GetMediaCapturePipeline(const GetMediaCapturePipelineRequest& request) const
3375 {
3376 if (!request.MediaPipelineIdHasBeenSet())
3377 {
3378 AWS_LOGSTREAM_ERROR("GetMediaCapturePipeline", "Required field: MediaPipelineId, is not set");
3379 return GetMediaCapturePipelineOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MediaPipelineId]", false));
3380 }
3381 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3382 uri.AddPathSegments("/media-capture-pipelines/");
3383 uri.AddPathSegment(request.GetMediaPipelineId());
3384 return GetMediaCapturePipelineOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3385 }
3386
GetMediaCapturePipelineCallable(const GetMediaCapturePipelineRequest & request) const3387 GetMediaCapturePipelineOutcomeCallable ChimeClient::GetMediaCapturePipelineCallable(const GetMediaCapturePipelineRequest& request) const
3388 {
3389 auto task = Aws::MakeShared< std::packaged_task< GetMediaCapturePipelineOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetMediaCapturePipeline(request); } );
3390 auto packagedFunction = [task]() { (*task)(); };
3391 m_executor->Submit(packagedFunction);
3392 return task->get_future();
3393 }
3394
GetMediaCapturePipelineAsync(const GetMediaCapturePipelineRequest & request,const GetMediaCapturePipelineResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3395 void ChimeClient::GetMediaCapturePipelineAsync(const GetMediaCapturePipelineRequest& request, const GetMediaCapturePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3396 {
3397 m_executor->Submit( [this, request, handler, context](){ this->GetMediaCapturePipelineAsyncHelper( request, handler, context ); } );
3398 }
3399
GetMediaCapturePipelineAsyncHelper(const GetMediaCapturePipelineRequest & request,const GetMediaCapturePipelineResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3400 void ChimeClient::GetMediaCapturePipelineAsyncHelper(const GetMediaCapturePipelineRequest& request, const GetMediaCapturePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3401 {
3402 handler(this, request, GetMediaCapturePipeline(request), context);
3403 }
3404
GetMeeting(const GetMeetingRequest & request) const3405 GetMeetingOutcome ChimeClient::GetMeeting(const GetMeetingRequest& request) const
3406 {
3407 if (!request.MeetingIdHasBeenSet())
3408 {
3409 AWS_LOGSTREAM_ERROR("GetMeeting", "Required field: MeetingId, is not set");
3410 return GetMeetingOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
3411 }
3412 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3413 uri.AddPathSegments("/meetings/");
3414 uri.AddPathSegment(request.GetMeetingId());
3415 return GetMeetingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3416 }
3417
GetMeetingCallable(const GetMeetingRequest & request) const3418 GetMeetingOutcomeCallable ChimeClient::GetMeetingCallable(const GetMeetingRequest& request) const
3419 {
3420 auto task = Aws::MakeShared< std::packaged_task< GetMeetingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetMeeting(request); } );
3421 auto packagedFunction = [task]() { (*task)(); };
3422 m_executor->Submit(packagedFunction);
3423 return task->get_future();
3424 }
3425
GetMeetingAsync(const GetMeetingRequest & request,const GetMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3426 void ChimeClient::GetMeetingAsync(const GetMeetingRequest& request, const GetMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3427 {
3428 m_executor->Submit( [this, request, handler, context](){ this->GetMeetingAsyncHelper( request, handler, context ); } );
3429 }
3430
GetMeetingAsyncHelper(const GetMeetingRequest & request,const GetMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3431 void ChimeClient::GetMeetingAsyncHelper(const GetMeetingRequest& request, const GetMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3432 {
3433 handler(this, request, GetMeeting(request), context);
3434 }
3435
GetMessagingSessionEndpoint(const GetMessagingSessionEndpointRequest & request) const3436 GetMessagingSessionEndpointOutcome ChimeClient::GetMessagingSessionEndpoint(const GetMessagingSessionEndpointRequest& request) const
3437 {
3438 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3439 if (m_enableHostPrefixInjection)
3440 {
3441 uri.SetAuthority("messaging-" + uri.GetAuthority());
3442 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
3443 {
3444 AWS_LOGSTREAM_ERROR("GetMessagingSessionEndpoint", "Invalid DNS host: " << uri.GetAuthority());
3445 return GetMessagingSessionEndpointOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
3446 }
3447 }
3448 uri.AddPathSegments("/endpoints/messaging-session");
3449 return GetMessagingSessionEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3450 }
3451
GetMessagingSessionEndpointCallable(const GetMessagingSessionEndpointRequest & request) const3452 GetMessagingSessionEndpointOutcomeCallable ChimeClient::GetMessagingSessionEndpointCallable(const GetMessagingSessionEndpointRequest& request) const
3453 {
3454 auto task = Aws::MakeShared< std::packaged_task< GetMessagingSessionEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetMessagingSessionEndpoint(request); } );
3455 auto packagedFunction = [task]() { (*task)(); };
3456 m_executor->Submit(packagedFunction);
3457 return task->get_future();
3458 }
3459
GetMessagingSessionEndpointAsync(const GetMessagingSessionEndpointRequest & request,const GetMessagingSessionEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3460 void ChimeClient::GetMessagingSessionEndpointAsync(const GetMessagingSessionEndpointRequest& request, const GetMessagingSessionEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3461 {
3462 m_executor->Submit( [this, request, handler, context](){ this->GetMessagingSessionEndpointAsyncHelper( request, handler, context ); } );
3463 }
3464
GetMessagingSessionEndpointAsyncHelper(const GetMessagingSessionEndpointRequest & request,const GetMessagingSessionEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3465 void ChimeClient::GetMessagingSessionEndpointAsyncHelper(const GetMessagingSessionEndpointRequest& request, const GetMessagingSessionEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3466 {
3467 handler(this, request, GetMessagingSessionEndpoint(request), context);
3468 }
3469
GetPhoneNumber(const GetPhoneNumberRequest & request) const3470 GetPhoneNumberOutcome ChimeClient::GetPhoneNumber(const GetPhoneNumberRequest& request) const
3471 {
3472 if (!request.PhoneNumberIdHasBeenSet())
3473 {
3474 AWS_LOGSTREAM_ERROR("GetPhoneNumber", "Required field: PhoneNumberId, is not set");
3475 return GetPhoneNumberOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PhoneNumberId]", false));
3476 }
3477 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3478 uri.AddPathSegments("/phone-numbers/");
3479 uri.AddPathSegment(request.GetPhoneNumberId());
3480 return GetPhoneNumberOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3481 }
3482
GetPhoneNumberCallable(const GetPhoneNumberRequest & request) const3483 GetPhoneNumberOutcomeCallable ChimeClient::GetPhoneNumberCallable(const GetPhoneNumberRequest& request) const
3484 {
3485 auto task = Aws::MakeShared< std::packaged_task< GetPhoneNumberOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPhoneNumber(request); } );
3486 auto packagedFunction = [task]() { (*task)(); };
3487 m_executor->Submit(packagedFunction);
3488 return task->get_future();
3489 }
3490
GetPhoneNumberAsync(const GetPhoneNumberRequest & request,const GetPhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3491 void ChimeClient::GetPhoneNumberAsync(const GetPhoneNumberRequest& request, const GetPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3492 {
3493 m_executor->Submit( [this, request, handler, context](){ this->GetPhoneNumberAsyncHelper( request, handler, context ); } );
3494 }
3495
GetPhoneNumberAsyncHelper(const GetPhoneNumberRequest & request,const GetPhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3496 void ChimeClient::GetPhoneNumberAsyncHelper(const GetPhoneNumberRequest& request, const GetPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3497 {
3498 handler(this, request, GetPhoneNumber(request), context);
3499 }
3500
GetPhoneNumberOrder(const GetPhoneNumberOrderRequest & request) const3501 GetPhoneNumberOrderOutcome ChimeClient::GetPhoneNumberOrder(const GetPhoneNumberOrderRequest& request) const
3502 {
3503 if (!request.PhoneNumberOrderIdHasBeenSet())
3504 {
3505 AWS_LOGSTREAM_ERROR("GetPhoneNumberOrder", "Required field: PhoneNumberOrderId, is not set");
3506 return GetPhoneNumberOrderOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PhoneNumberOrderId]", false));
3507 }
3508 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3509 uri.AddPathSegments("/phone-number-orders/");
3510 uri.AddPathSegment(request.GetPhoneNumberOrderId());
3511 return GetPhoneNumberOrderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3512 }
3513
GetPhoneNumberOrderCallable(const GetPhoneNumberOrderRequest & request) const3514 GetPhoneNumberOrderOutcomeCallable ChimeClient::GetPhoneNumberOrderCallable(const GetPhoneNumberOrderRequest& request) const
3515 {
3516 auto task = Aws::MakeShared< std::packaged_task< GetPhoneNumberOrderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPhoneNumberOrder(request); } );
3517 auto packagedFunction = [task]() { (*task)(); };
3518 m_executor->Submit(packagedFunction);
3519 return task->get_future();
3520 }
3521
GetPhoneNumberOrderAsync(const GetPhoneNumberOrderRequest & request,const GetPhoneNumberOrderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3522 void ChimeClient::GetPhoneNumberOrderAsync(const GetPhoneNumberOrderRequest& request, const GetPhoneNumberOrderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3523 {
3524 m_executor->Submit( [this, request, handler, context](){ this->GetPhoneNumberOrderAsyncHelper( request, handler, context ); } );
3525 }
3526
GetPhoneNumberOrderAsyncHelper(const GetPhoneNumberOrderRequest & request,const GetPhoneNumberOrderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3527 void ChimeClient::GetPhoneNumberOrderAsyncHelper(const GetPhoneNumberOrderRequest& request, const GetPhoneNumberOrderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3528 {
3529 handler(this, request, GetPhoneNumberOrder(request), context);
3530 }
3531
GetPhoneNumberSettings() const3532 GetPhoneNumberSettingsOutcome ChimeClient::GetPhoneNumberSettings() const
3533 {
3534 Aws::StringStream ss;
3535 ss << m_baseUri << "/settings/phone-number";
3536 return GetPhoneNumberSettingsOutcome(MakeRequest(ss.str(), Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER, "GetPhoneNumberSettings"));
3537 }
3538
GetPhoneNumberSettingsCallable() const3539 GetPhoneNumberSettingsOutcomeCallable ChimeClient::GetPhoneNumberSettingsCallable() const
3540 {
3541 auto task = Aws::MakeShared< std::packaged_task< GetPhoneNumberSettingsOutcome() > >(ALLOCATION_TAG, [this](){ return this->GetPhoneNumberSettings(); } );
3542 auto packagedFunction = [task]() { (*task)(); };
3543 m_executor->Submit(packagedFunction);
3544 return task->get_future();
3545 }
3546
GetPhoneNumberSettingsAsync(const GetPhoneNumberSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3547 void ChimeClient::GetPhoneNumberSettingsAsync(const GetPhoneNumberSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3548 {
3549 m_executor->Submit( [this, handler, context](){ this->GetPhoneNumberSettingsAsyncHelper( handler, context ); } );
3550 }
3551
GetPhoneNumberSettingsAsyncHelper(const GetPhoneNumberSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3552 void ChimeClient::GetPhoneNumberSettingsAsyncHelper(const GetPhoneNumberSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3553 {
3554 handler(this, GetPhoneNumberSettings(), context);
3555 }
3556
GetProxySession(const GetProxySessionRequest & request) const3557 GetProxySessionOutcome ChimeClient::GetProxySession(const GetProxySessionRequest& request) const
3558 {
3559 if (!request.VoiceConnectorIdHasBeenSet())
3560 {
3561 AWS_LOGSTREAM_ERROR("GetProxySession", "Required field: VoiceConnectorId, is not set");
3562 return GetProxySessionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
3563 }
3564 if (!request.ProxySessionIdHasBeenSet())
3565 {
3566 AWS_LOGSTREAM_ERROR("GetProxySession", "Required field: ProxySessionId, is not set");
3567 return GetProxySessionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ProxySessionId]", false));
3568 }
3569 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3570 uri.AddPathSegments("/voice-connectors/");
3571 uri.AddPathSegment(request.GetVoiceConnectorId());
3572 uri.AddPathSegments("/proxy-sessions/");
3573 uri.AddPathSegment(request.GetProxySessionId());
3574 return GetProxySessionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3575 }
3576
GetProxySessionCallable(const GetProxySessionRequest & request) const3577 GetProxySessionOutcomeCallable ChimeClient::GetProxySessionCallable(const GetProxySessionRequest& request) const
3578 {
3579 auto task = Aws::MakeShared< std::packaged_task< GetProxySessionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetProxySession(request); } );
3580 auto packagedFunction = [task]() { (*task)(); };
3581 m_executor->Submit(packagedFunction);
3582 return task->get_future();
3583 }
3584
GetProxySessionAsync(const GetProxySessionRequest & request,const GetProxySessionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3585 void ChimeClient::GetProxySessionAsync(const GetProxySessionRequest& request, const GetProxySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3586 {
3587 m_executor->Submit( [this, request, handler, context](){ this->GetProxySessionAsyncHelper( request, handler, context ); } );
3588 }
3589
GetProxySessionAsyncHelper(const GetProxySessionRequest & request,const GetProxySessionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3590 void ChimeClient::GetProxySessionAsyncHelper(const GetProxySessionRequest& request, const GetProxySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3591 {
3592 handler(this, request, GetProxySession(request), context);
3593 }
3594
GetRetentionSettings(const GetRetentionSettingsRequest & request) const3595 GetRetentionSettingsOutcome ChimeClient::GetRetentionSettings(const GetRetentionSettingsRequest& request) const
3596 {
3597 if (!request.AccountIdHasBeenSet())
3598 {
3599 AWS_LOGSTREAM_ERROR("GetRetentionSettings", "Required field: AccountId, is not set");
3600 return GetRetentionSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3601 }
3602 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3603 uri.AddPathSegments("/accounts/");
3604 uri.AddPathSegment(request.GetAccountId());
3605 uri.AddPathSegments("/retention-settings");
3606 return GetRetentionSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3607 }
3608
GetRetentionSettingsCallable(const GetRetentionSettingsRequest & request) const3609 GetRetentionSettingsOutcomeCallable ChimeClient::GetRetentionSettingsCallable(const GetRetentionSettingsRequest& request) const
3610 {
3611 auto task = Aws::MakeShared< std::packaged_task< GetRetentionSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetRetentionSettings(request); } );
3612 auto packagedFunction = [task]() { (*task)(); };
3613 m_executor->Submit(packagedFunction);
3614 return task->get_future();
3615 }
3616
GetRetentionSettingsAsync(const GetRetentionSettingsRequest & request,const GetRetentionSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3617 void ChimeClient::GetRetentionSettingsAsync(const GetRetentionSettingsRequest& request, const GetRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3618 {
3619 m_executor->Submit( [this, request, handler, context](){ this->GetRetentionSettingsAsyncHelper( request, handler, context ); } );
3620 }
3621
GetRetentionSettingsAsyncHelper(const GetRetentionSettingsRequest & request,const GetRetentionSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3622 void ChimeClient::GetRetentionSettingsAsyncHelper(const GetRetentionSettingsRequest& request, const GetRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3623 {
3624 handler(this, request, GetRetentionSettings(request), context);
3625 }
3626
GetRoom(const GetRoomRequest & request) const3627 GetRoomOutcome ChimeClient::GetRoom(const GetRoomRequest& request) const
3628 {
3629 if (!request.AccountIdHasBeenSet())
3630 {
3631 AWS_LOGSTREAM_ERROR("GetRoom", "Required field: AccountId, is not set");
3632 return GetRoomOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3633 }
3634 if (!request.RoomIdHasBeenSet())
3635 {
3636 AWS_LOGSTREAM_ERROR("GetRoom", "Required field: RoomId, is not set");
3637 return GetRoomOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
3638 }
3639 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3640 uri.AddPathSegments("/accounts/");
3641 uri.AddPathSegment(request.GetAccountId());
3642 uri.AddPathSegments("/rooms/");
3643 uri.AddPathSegment(request.GetRoomId());
3644 return GetRoomOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3645 }
3646
GetRoomCallable(const GetRoomRequest & request) const3647 GetRoomOutcomeCallable ChimeClient::GetRoomCallable(const GetRoomRequest& request) const
3648 {
3649 auto task = Aws::MakeShared< std::packaged_task< GetRoomOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetRoom(request); } );
3650 auto packagedFunction = [task]() { (*task)(); };
3651 m_executor->Submit(packagedFunction);
3652 return task->get_future();
3653 }
3654
GetRoomAsync(const GetRoomRequest & request,const GetRoomResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3655 void ChimeClient::GetRoomAsync(const GetRoomRequest& request, const GetRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3656 {
3657 m_executor->Submit( [this, request, handler, context](){ this->GetRoomAsyncHelper( request, handler, context ); } );
3658 }
3659
GetRoomAsyncHelper(const GetRoomRequest & request,const GetRoomResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3660 void ChimeClient::GetRoomAsyncHelper(const GetRoomRequest& request, const GetRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3661 {
3662 handler(this, request, GetRoom(request), context);
3663 }
3664
GetSipMediaApplication(const GetSipMediaApplicationRequest & request) const3665 GetSipMediaApplicationOutcome ChimeClient::GetSipMediaApplication(const GetSipMediaApplicationRequest& request) const
3666 {
3667 if (!request.SipMediaApplicationIdHasBeenSet())
3668 {
3669 AWS_LOGSTREAM_ERROR("GetSipMediaApplication", "Required field: SipMediaApplicationId, is not set");
3670 return GetSipMediaApplicationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipMediaApplicationId]", false));
3671 }
3672 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3673 uri.AddPathSegments("/sip-media-applications/");
3674 uri.AddPathSegment(request.GetSipMediaApplicationId());
3675 return GetSipMediaApplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3676 }
3677
GetSipMediaApplicationCallable(const GetSipMediaApplicationRequest & request) const3678 GetSipMediaApplicationOutcomeCallable ChimeClient::GetSipMediaApplicationCallable(const GetSipMediaApplicationRequest& request) const
3679 {
3680 auto task = Aws::MakeShared< std::packaged_task< GetSipMediaApplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetSipMediaApplication(request); } );
3681 auto packagedFunction = [task]() { (*task)(); };
3682 m_executor->Submit(packagedFunction);
3683 return task->get_future();
3684 }
3685
GetSipMediaApplicationAsync(const GetSipMediaApplicationRequest & request,const GetSipMediaApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3686 void ChimeClient::GetSipMediaApplicationAsync(const GetSipMediaApplicationRequest& request, const GetSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3687 {
3688 m_executor->Submit( [this, request, handler, context](){ this->GetSipMediaApplicationAsyncHelper( request, handler, context ); } );
3689 }
3690
GetSipMediaApplicationAsyncHelper(const GetSipMediaApplicationRequest & request,const GetSipMediaApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3691 void ChimeClient::GetSipMediaApplicationAsyncHelper(const GetSipMediaApplicationRequest& request, const GetSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3692 {
3693 handler(this, request, GetSipMediaApplication(request), context);
3694 }
3695
GetSipMediaApplicationLoggingConfiguration(const GetSipMediaApplicationLoggingConfigurationRequest & request) const3696 GetSipMediaApplicationLoggingConfigurationOutcome ChimeClient::GetSipMediaApplicationLoggingConfiguration(const GetSipMediaApplicationLoggingConfigurationRequest& request) const
3697 {
3698 if (!request.SipMediaApplicationIdHasBeenSet())
3699 {
3700 AWS_LOGSTREAM_ERROR("GetSipMediaApplicationLoggingConfiguration", "Required field: SipMediaApplicationId, is not set");
3701 return GetSipMediaApplicationLoggingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipMediaApplicationId]", false));
3702 }
3703 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3704 uri.AddPathSegments("/sip-media-applications/");
3705 uri.AddPathSegment(request.GetSipMediaApplicationId());
3706 uri.AddPathSegments("/logging-configuration");
3707 return GetSipMediaApplicationLoggingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3708 }
3709
GetSipMediaApplicationLoggingConfigurationCallable(const GetSipMediaApplicationLoggingConfigurationRequest & request) const3710 GetSipMediaApplicationLoggingConfigurationOutcomeCallable ChimeClient::GetSipMediaApplicationLoggingConfigurationCallable(const GetSipMediaApplicationLoggingConfigurationRequest& request) const
3711 {
3712 auto task = Aws::MakeShared< std::packaged_task< GetSipMediaApplicationLoggingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetSipMediaApplicationLoggingConfiguration(request); } );
3713 auto packagedFunction = [task]() { (*task)(); };
3714 m_executor->Submit(packagedFunction);
3715 return task->get_future();
3716 }
3717
GetSipMediaApplicationLoggingConfigurationAsync(const GetSipMediaApplicationLoggingConfigurationRequest & request,const GetSipMediaApplicationLoggingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3718 void ChimeClient::GetSipMediaApplicationLoggingConfigurationAsync(const GetSipMediaApplicationLoggingConfigurationRequest& request, const GetSipMediaApplicationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3719 {
3720 m_executor->Submit( [this, request, handler, context](){ this->GetSipMediaApplicationLoggingConfigurationAsyncHelper( request, handler, context ); } );
3721 }
3722
GetSipMediaApplicationLoggingConfigurationAsyncHelper(const GetSipMediaApplicationLoggingConfigurationRequest & request,const GetSipMediaApplicationLoggingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3723 void ChimeClient::GetSipMediaApplicationLoggingConfigurationAsyncHelper(const GetSipMediaApplicationLoggingConfigurationRequest& request, const GetSipMediaApplicationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3724 {
3725 handler(this, request, GetSipMediaApplicationLoggingConfiguration(request), context);
3726 }
3727
GetSipRule(const GetSipRuleRequest & request) const3728 GetSipRuleOutcome ChimeClient::GetSipRule(const GetSipRuleRequest& request) const
3729 {
3730 if (!request.SipRuleIdHasBeenSet())
3731 {
3732 AWS_LOGSTREAM_ERROR("GetSipRule", "Required field: SipRuleId, is not set");
3733 return GetSipRuleOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipRuleId]", false));
3734 }
3735 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3736 uri.AddPathSegments("/sip-rules/");
3737 uri.AddPathSegment(request.GetSipRuleId());
3738 return GetSipRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3739 }
3740
GetSipRuleCallable(const GetSipRuleRequest & request) const3741 GetSipRuleOutcomeCallable ChimeClient::GetSipRuleCallable(const GetSipRuleRequest& request) const
3742 {
3743 auto task = Aws::MakeShared< std::packaged_task< GetSipRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetSipRule(request); } );
3744 auto packagedFunction = [task]() { (*task)(); };
3745 m_executor->Submit(packagedFunction);
3746 return task->get_future();
3747 }
3748
GetSipRuleAsync(const GetSipRuleRequest & request,const GetSipRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3749 void ChimeClient::GetSipRuleAsync(const GetSipRuleRequest& request, const GetSipRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3750 {
3751 m_executor->Submit( [this, request, handler, context](){ this->GetSipRuleAsyncHelper( request, handler, context ); } );
3752 }
3753
GetSipRuleAsyncHelper(const GetSipRuleRequest & request,const GetSipRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3754 void ChimeClient::GetSipRuleAsyncHelper(const GetSipRuleRequest& request, const GetSipRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3755 {
3756 handler(this, request, GetSipRule(request), context);
3757 }
3758
GetUser(const GetUserRequest & request) const3759 GetUserOutcome ChimeClient::GetUser(const GetUserRequest& request) const
3760 {
3761 if (!request.AccountIdHasBeenSet())
3762 {
3763 AWS_LOGSTREAM_ERROR("GetUser", "Required field: AccountId, is not set");
3764 return GetUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3765 }
3766 if (!request.UserIdHasBeenSet())
3767 {
3768 AWS_LOGSTREAM_ERROR("GetUser", "Required field: UserId, is not set");
3769 return GetUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
3770 }
3771 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3772 uri.AddPathSegments("/accounts/");
3773 uri.AddPathSegment(request.GetAccountId());
3774 uri.AddPathSegments("/users/");
3775 uri.AddPathSegment(request.GetUserId());
3776 return GetUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3777 }
3778
GetUserCallable(const GetUserRequest & request) const3779 GetUserOutcomeCallable ChimeClient::GetUserCallable(const GetUserRequest& request) const
3780 {
3781 auto task = Aws::MakeShared< std::packaged_task< GetUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetUser(request); } );
3782 auto packagedFunction = [task]() { (*task)(); };
3783 m_executor->Submit(packagedFunction);
3784 return task->get_future();
3785 }
3786
GetUserAsync(const GetUserRequest & request,const GetUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3787 void ChimeClient::GetUserAsync(const GetUserRequest& request, const GetUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3788 {
3789 m_executor->Submit( [this, request, handler, context](){ this->GetUserAsyncHelper( request, handler, context ); } );
3790 }
3791
GetUserAsyncHelper(const GetUserRequest & request,const GetUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3792 void ChimeClient::GetUserAsyncHelper(const GetUserRequest& request, const GetUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3793 {
3794 handler(this, request, GetUser(request), context);
3795 }
3796
GetUserSettings(const GetUserSettingsRequest & request) const3797 GetUserSettingsOutcome ChimeClient::GetUserSettings(const GetUserSettingsRequest& request) const
3798 {
3799 if (!request.AccountIdHasBeenSet())
3800 {
3801 AWS_LOGSTREAM_ERROR("GetUserSettings", "Required field: AccountId, is not set");
3802 return GetUserSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
3803 }
3804 if (!request.UserIdHasBeenSet())
3805 {
3806 AWS_LOGSTREAM_ERROR("GetUserSettings", "Required field: UserId, is not set");
3807 return GetUserSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
3808 }
3809 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3810 uri.AddPathSegments("/accounts/");
3811 uri.AddPathSegment(request.GetAccountId());
3812 uri.AddPathSegments("/users/");
3813 uri.AddPathSegment(request.GetUserId());
3814 uri.AddPathSegments("/settings");
3815 return GetUserSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3816 }
3817
GetUserSettingsCallable(const GetUserSettingsRequest & request) const3818 GetUserSettingsOutcomeCallable ChimeClient::GetUserSettingsCallable(const GetUserSettingsRequest& request) const
3819 {
3820 auto task = Aws::MakeShared< std::packaged_task< GetUserSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetUserSettings(request); } );
3821 auto packagedFunction = [task]() { (*task)(); };
3822 m_executor->Submit(packagedFunction);
3823 return task->get_future();
3824 }
3825
GetUserSettingsAsync(const GetUserSettingsRequest & request,const GetUserSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3826 void ChimeClient::GetUserSettingsAsync(const GetUserSettingsRequest& request, const GetUserSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3827 {
3828 m_executor->Submit( [this, request, handler, context](){ this->GetUserSettingsAsyncHelper( request, handler, context ); } );
3829 }
3830
GetUserSettingsAsyncHelper(const GetUserSettingsRequest & request,const GetUserSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3831 void ChimeClient::GetUserSettingsAsyncHelper(const GetUserSettingsRequest& request, const GetUserSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3832 {
3833 handler(this, request, GetUserSettings(request), context);
3834 }
3835
GetVoiceConnector(const GetVoiceConnectorRequest & request) const3836 GetVoiceConnectorOutcome ChimeClient::GetVoiceConnector(const GetVoiceConnectorRequest& request) const
3837 {
3838 if (!request.VoiceConnectorIdHasBeenSet())
3839 {
3840 AWS_LOGSTREAM_ERROR("GetVoiceConnector", "Required field: VoiceConnectorId, is not set");
3841 return GetVoiceConnectorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
3842 }
3843 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3844 uri.AddPathSegments("/voice-connectors/");
3845 uri.AddPathSegment(request.GetVoiceConnectorId());
3846 return GetVoiceConnectorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3847 }
3848
GetVoiceConnectorCallable(const GetVoiceConnectorRequest & request) const3849 GetVoiceConnectorOutcomeCallable ChimeClient::GetVoiceConnectorCallable(const GetVoiceConnectorRequest& request) const
3850 {
3851 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnector(request); } );
3852 auto packagedFunction = [task]() { (*task)(); };
3853 m_executor->Submit(packagedFunction);
3854 return task->get_future();
3855 }
3856
GetVoiceConnectorAsync(const GetVoiceConnectorRequest & request,const GetVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3857 void ChimeClient::GetVoiceConnectorAsync(const GetVoiceConnectorRequest& request, const GetVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3858 {
3859 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorAsyncHelper( request, handler, context ); } );
3860 }
3861
GetVoiceConnectorAsyncHelper(const GetVoiceConnectorRequest & request,const GetVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3862 void ChimeClient::GetVoiceConnectorAsyncHelper(const GetVoiceConnectorRequest& request, const GetVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3863 {
3864 handler(this, request, GetVoiceConnector(request), context);
3865 }
3866
GetVoiceConnectorEmergencyCallingConfiguration(const GetVoiceConnectorEmergencyCallingConfigurationRequest & request) const3867 GetVoiceConnectorEmergencyCallingConfigurationOutcome ChimeClient::GetVoiceConnectorEmergencyCallingConfiguration(const GetVoiceConnectorEmergencyCallingConfigurationRequest& request) const
3868 {
3869 if (!request.VoiceConnectorIdHasBeenSet())
3870 {
3871 AWS_LOGSTREAM_ERROR("GetVoiceConnectorEmergencyCallingConfiguration", "Required field: VoiceConnectorId, is not set");
3872 return GetVoiceConnectorEmergencyCallingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
3873 }
3874 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3875 uri.AddPathSegments("/voice-connectors/");
3876 uri.AddPathSegment(request.GetVoiceConnectorId());
3877 uri.AddPathSegments("/emergency-calling-configuration");
3878 return GetVoiceConnectorEmergencyCallingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3879 }
3880
GetVoiceConnectorEmergencyCallingConfigurationCallable(const GetVoiceConnectorEmergencyCallingConfigurationRequest & request) const3881 GetVoiceConnectorEmergencyCallingConfigurationOutcomeCallable ChimeClient::GetVoiceConnectorEmergencyCallingConfigurationCallable(const GetVoiceConnectorEmergencyCallingConfigurationRequest& request) const
3882 {
3883 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorEmergencyCallingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnectorEmergencyCallingConfiguration(request); } );
3884 auto packagedFunction = [task]() { (*task)(); };
3885 m_executor->Submit(packagedFunction);
3886 return task->get_future();
3887 }
3888
GetVoiceConnectorEmergencyCallingConfigurationAsync(const GetVoiceConnectorEmergencyCallingConfigurationRequest & request,const GetVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3889 void ChimeClient::GetVoiceConnectorEmergencyCallingConfigurationAsync(const GetVoiceConnectorEmergencyCallingConfigurationRequest& request, const GetVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3890 {
3891 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorEmergencyCallingConfigurationAsyncHelper( request, handler, context ); } );
3892 }
3893
GetVoiceConnectorEmergencyCallingConfigurationAsyncHelper(const GetVoiceConnectorEmergencyCallingConfigurationRequest & request,const GetVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3894 void ChimeClient::GetVoiceConnectorEmergencyCallingConfigurationAsyncHelper(const GetVoiceConnectorEmergencyCallingConfigurationRequest& request, const GetVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3895 {
3896 handler(this, request, GetVoiceConnectorEmergencyCallingConfiguration(request), context);
3897 }
3898
GetVoiceConnectorGroup(const GetVoiceConnectorGroupRequest & request) const3899 GetVoiceConnectorGroupOutcome ChimeClient::GetVoiceConnectorGroup(const GetVoiceConnectorGroupRequest& request) const
3900 {
3901 if (!request.VoiceConnectorGroupIdHasBeenSet())
3902 {
3903 AWS_LOGSTREAM_ERROR("GetVoiceConnectorGroup", "Required field: VoiceConnectorGroupId, is not set");
3904 return GetVoiceConnectorGroupOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorGroupId]", false));
3905 }
3906 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3907 uri.AddPathSegments("/voice-connector-groups/");
3908 uri.AddPathSegment(request.GetVoiceConnectorGroupId());
3909 return GetVoiceConnectorGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3910 }
3911
GetVoiceConnectorGroupCallable(const GetVoiceConnectorGroupRequest & request) const3912 GetVoiceConnectorGroupOutcomeCallable ChimeClient::GetVoiceConnectorGroupCallable(const GetVoiceConnectorGroupRequest& request) const
3913 {
3914 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnectorGroup(request); } );
3915 auto packagedFunction = [task]() { (*task)(); };
3916 m_executor->Submit(packagedFunction);
3917 return task->get_future();
3918 }
3919
GetVoiceConnectorGroupAsync(const GetVoiceConnectorGroupRequest & request,const GetVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3920 void ChimeClient::GetVoiceConnectorGroupAsync(const GetVoiceConnectorGroupRequest& request, const GetVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3921 {
3922 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorGroupAsyncHelper( request, handler, context ); } );
3923 }
3924
GetVoiceConnectorGroupAsyncHelper(const GetVoiceConnectorGroupRequest & request,const GetVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3925 void ChimeClient::GetVoiceConnectorGroupAsyncHelper(const GetVoiceConnectorGroupRequest& request, const GetVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3926 {
3927 handler(this, request, GetVoiceConnectorGroup(request), context);
3928 }
3929
GetVoiceConnectorLoggingConfiguration(const GetVoiceConnectorLoggingConfigurationRequest & request) const3930 GetVoiceConnectorLoggingConfigurationOutcome ChimeClient::GetVoiceConnectorLoggingConfiguration(const GetVoiceConnectorLoggingConfigurationRequest& request) const
3931 {
3932 if (!request.VoiceConnectorIdHasBeenSet())
3933 {
3934 AWS_LOGSTREAM_ERROR("GetVoiceConnectorLoggingConfiguration", "Required field: VoiceConnectorId, is not set");
3935 return GetVoiceConnectorLoggingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
3936 }
3937 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3938 uri.AddPathSegments("/voice-connectors/");
3939 uri.AddPathSegment(request.GetVoiceConnectorId());
3940 uri.AddPathSegments("/logging-configuration");
3941 return GetVoiceConnectorLoggingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3942 }
3943
GetVoiceConnectorLoggingConfigurationCallable(const GetVoiceConnectorLoggingConfigurationRequest & request) const3944 GetVoiceConnectorLoggingConfigurationOutcomeCallable ChimeClient::GetVoiceConnectorLoggingConfigurationCallable(const GetVoiceConnectorLoggingConfigurationRequest& request) const
3945 {
3946 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorLoggingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnectorLoggingConfiguration(request); } );
3947 auto packagedFunction = [task]() { (*task)(); };
3948 m_executor->Submit(packagedFunction);
3949 return task->get_future();
3950 }
3951
GetVoiceConnectorLoggingConfigurationAsync(const GetVoiceConnectorLoggingConfigurationRequest & request,const GetVoiceConnectorLoggingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3952 void ChimeClient::GetVoiceConnectorLoggingConfigurationAsync(const GetVoiceConnectorLoggingConfigurationRequest& request, const GetVoiceConnectorLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3953 {
3954 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorLoggingConfigurationAsyncHelper( request, handler, context ); } );
3955 }
3956
GetVoiceConnectorLoggingConfigurationAsyncHelper(const GetVoiceConnectorLoggingConfigurationRequest & request,const GetVoiceConnectorLoggingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3957 void ChimeClient::GetVoiceConnectorLoggingConfigurationAsyncHelper(const GetVoiceConnectorLoggingConfigurationRequest& request, const GetVoiceConnectorLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3958 {
3959 handler(this, request, GetVoiceConnectorLoggingConfiguration(request), context);
3960 }
3961
GetVoiceConnectorOrigination(const GetVoiceConnectorOriginationRequest & request) const3962 GetVoiceConnectorOriginationOutcome ChimeClient::GetVoiceConnectorOrigination(const GetVoiceConnectorOriginationRequest& request) const
3963 {
3964 if (!request.VoiceConnectorIdHasBeenSet())
3965 {
3966 AWS_LOGSTREAM_ERROR("GetVoiceConnectorOrigination", "Required field: VoiceConnectorId, is not set");
3967 return GetVoiceConnectorOriginationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
3968 }
3969 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
3970 uri.AddPathSegments("/voice-connectors/");
3971 uri.AddPathSegment(request.GetVoiceConnectorId());
3972 uri.AddPathSegments("/origination");
3973 return GetVoiceConnectorOriginationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
3974 }
3975
GetVoiceConnectorOriginationCallable(const GetVoiceConnectorOriginationRequest & request) const3976 GetVoiceConnectorOriginationOutcomeCallable ChimeClient::GetVoiceConnectorOriginationCallable(const GetVoiceConnectorOriginationRequest& request) const
3977 {
3978 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorOriginationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnectorOrigination(request); } );
3979 auto packagedFunction = [task]() { (*task)(); };
3980 m_executor->Submit(packagedFunction);
3981 return task->get_future();
3982 }
3983
GetVoiceConnectorOriginationAsync(const GetVoiceConnectorOriginationRequest & request,const GetVoiceConnectorOriginationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3984 void ChimeClient::GetVoiceConnectorOriginationAsync(const GetVoiceConnectorOriginationRequest& request, const GetVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3985 {
3986 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorOriginationAsyncHelper( request, handler, context ); } );
3987 }
3988
GetVoiceConnectorOriginationAsyncHelper(const GetVoiceConnectorOriginationRequest & request,const GetVoiceConnectorOriginationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3989 void ChimeClient::GetVoiceConnectorOriginationAsyncHelper(const GetVoiceConnectorOriginationRequest& request, const GetVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3990 {
3991 handler(this, request, GetVoiceConnectorOrigination(request), context);
3992 }
3993
GetVoiceConnectorProxy(const GetVoiceConnectorProxyRequest & request) const3994 GetVoiceConnectorProxyOutcome ChimeClient::GetVoiceConnectorProxy(const GetVoiceConnectorProxyRequest& request) const
3995 {
3996 if (!request.VoiceConnectorIdHasBeenSet())
3997 {
3998 AWS_LOGSTREAM_ERROR("GetVoiceConnectorProxy", "Required field: VoiceConnectorId, is not set");
3999 return GetVoiceConnectorProxyOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
4000 }
4001 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4002 uri.AddPathSegments("/voice-connectors/");
4003 uri.AddPathSegment(request.GetVoiceConnectorId());
4004 uri.AddPathSegments("/programmable-numbers/proxy");
4005 return GetVoiceConnectorProxyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4006 }
4007
GetVoiceConnectorProxyCallable(const GetVoiceConnectorProxyRequest & request) const4008 GetVoiceConnectorProxyOutcomeCallable ChimeClient::GetVoiceConnectorProxyCallable(const GetVoiceConnectorProxyRequest& request) const
4009 {
4010 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorProxyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnectorProxy(request); } );
4011 auto packagedFunction = [task]() { (*task)(); };
4012 m_executor->Submit(packagedFunction);
4013 return task->get_future();
4014 }
4015
GetVoiceConnectorProxyAsync(const GetVoiceConnectorProxyRequest & request,const GetVoiceConnectorProxyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4016 void ChimeClient::GetVoiceConnectorProxyAsync(const GetVoiceConnectorProxyRequest& request, const GetVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4017 {
4018 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorProxyAsyncHelper( request, handler, context ); } );
4019 }
4020
GetVoiceConnectorProxyAsyncHelper(const GetVoiceConnectorProxyRequest & request,const GetVoiceConnectorProxyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4021 void ChimeClient::GetVoiceConnectorProxyAsyncHelper(const GetVoiceConnectorProxyRequest& request, const GetVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4022 {
4023 handler(this, request, GetVoiceConnectorProxy(request), context);
4024 }
4025
GetVoiceConnectorStreamingConfiguration(const GetVoiceConnectorStreamingConfigurationRequest & request) const4026 GetVoiceConnectorStreamingConfigurationOutcome ChimeClient::GetVoiceConnectorStreamingConfiguration(const GetVoiceConnectorStreamingConfigurationRequest& request) const
4027 {
4028 if (!request.VoiceConnectorIdHasBeenSet())
4029 {
4030 AWS_LOGSTREAM_ERROR("GetVoiceConnectorStreamingConfiguration", "Required field: VoiceConnectorId, is not set");
4031 return GetVoiceConnectorStreamingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
4032 }
4033 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4034 uri.AddPathSegments("/voice-connectors/");
4035 uri.AddPathSegment(request.GetVoiceConnectorId());
4036 uri.AddPathSegments("/streaming-configuration");
4037 return GetVoiceConnectorStreamingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4038 }
4039
GetVoiceConnectorStreamingConfigurationCallable(const GetVoiceConnectorStreamingConfigurationRequest & request) const4040 GetVoiceConnectorStreamingConfigurationOutcomeCallable ChimeClient::GetVoiceConnectorStreamingConfigurationCallable(const GetVoiceConnectorStreamingConfigurationRequest& request) const
4041 {
4042 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorStreamingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnectorStreamingConfiguration(request); } );
4043 auto packagedFunction = [task]() { (*task)(); };
4044 m_executor->Submit(packagedFunction);
4045 return task->get_future();
4046 }
4047
GetVoiceConnectorStreamingConfigurationAsync(const GetVoiceConnectorStreamingConfigurationRequest & request,const GetVoiceConnectorStreamingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4048 void ChimeClient::GetVoiceConnectorStreamingConfigurationAsync(const GetVoiceConnectorStreamingConfigurationRequest& request, const GetVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4049 {
4050 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorStreamingConfigurationAsyncHelper( request, handler, context ); } );
4051 }
4052
GetVoiceConnectorStreamingConfigurationAsyncHelper(const GetVoiceConnectorStreamingConfigurationRequest & request,const GetVoiceConnectorStreamingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4053 void ChimeClient::GetVoiceConnectorStreamingConfigurationAsyncHelper(const GetVoiceConnectorStreamingConfigurationRequest& request, const GetVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4054 {
4055 handler(this, request, GetVoiceConnectorStreamingConfiguration(request), context);
4056 }
4057
GetVoiceConnectorTermination(const GetVoiceConnectorTerminationRequest & request) const4058 GetVoiceConnectorTerminationOutcome ChimeClient::GetVoiceConnectorTermination(const GetVoiceConnectorTerminationRequest& request) const
4059 {
4060 if (!request.VoiceConnectorIdHasBeenSet())
4061 {
4062 AWS_LOGSTREAM_ERROR("GetVoiceConnectorTermination", "Required field: VoiceConnectorId, is not set");
4063 return GetVoiceConnectorTerminationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
4064 }
4065 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4066 uri.AddPathSegments("/voice-connectors/");
4067 uri.AddPathSegment(request.GetVoiceConnectorId());
4068 uri.AddPathSegments("/termination");
4069 return GetVoiceConnectorTerminationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4070 }
4071
GetVoiceConnectorTerminationCallable(const GetVoiceConnectorTerminationRequest & request) const4072 GetVoiceConnectorTerminationOutcomeCallable ChimeClient::GetVoiceConnectorTerminationCallable(const GetVoiceConnectorTerminationRequest& request) const
4073 {
4074 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorTerminationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnectorTermination(request); } );
4075 auto packagedFunction = [task]() { (*task)(); };
4076 m_executor->Submit(packagedFunction);
4077 return task->get_future();
4078 }
4079
GetVoiceConnectorTerminationAsync(const GetVoiceConnectorTerminationRequest & request,const GetVoiceConnectorTerminationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4080 void ChimeClient::GetVoiceConnectorTerminationAsync(const GetVoiceConnectorTerminationRequest& request, const GetVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4081 {
4082 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorTerminationAsyncHelper( request, handler, context ); } );
4083 }
4084
GetVoiceConnectorTerminationAsyncHelper(const GetVoiceConnectorTerminationRequest & request,const GetVoiceConnectorTerminationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4085 void ChimeClient::GetVoiceConnectorTerminationAsyncHelper(const GetVoiceConnectorTerminationRequest& request, const GetVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4086 {
4087 handler(this, request, GetVoiceConnectorTermination(request), context);
4088 }
4089
GetVoiceConnectorTerminationHealth(const GetVoiceConnectorTerminationHealthRequest & request) const4090 GetVoiceConnectorTerminationHealthOutcome ChimeClient::GetVoiceConnectorTerminationHealth(const GetVoiceConnectorTerminationHealthRequest& request) const
4091 {
4092 if (!request.VoiceConnectorIdHasBeenSet())
4093 {
4094 AWS_LOGSTREAM_ERROR("GetVoiceConnectorTerminationHealth", "Required field: VoiceConnectorId, is not set");
4095 return GetVoiceConnectorTerminationHealthOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
4096 }
4097 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4098 uri.AddPathSegments("/voice-connectors/");
4099 uri.AddPathSegment(request.GetVoiceConnectorId());
4100 uri.AddPathSegments("/termination/health");
4101 return GetVoiceConnectorTerminationHealthOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4102 }
4103
GetVoiceConnectorTerminationHealthCallable(const GetVoiceConnectorTerminationHealthRequest & request) const4104 GetVoiceConnectorTerminationHealthOutcomeCallable ChimeClient::GetVoiceConnectorTerminationHealthCallable(const GetVoiceConnectorTerminationHealthRequest& request) const
4105 {
4106 auto task = Aws::MakeShared< std::packaged_task< GetVoiceConnectorTerminationHealthOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetVoiceConnectorTerminationHealth(request); } );
4107 auto packagedFunction = [task]() { (*task)(); };
4108 m_executor->Submit(packagedFunction);
4109 return task->get_future();
4110 }
4111
GetVoiceConnectorTerminationHealthAsync(const GetVoiceConnectorTerminationHealthRequest & request,const GetVoiceConnectorTerminationHealthResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4112 void ChimeClient::GetVoiceConnectorTerminationHealthAsync(const GetVoiceConnectorTerminationHealthRequest& request, const GetVoiceConnectorTerminationHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4113 {
4114 m_executor->Submit( [this, request, handler, context](){ this->GetVoiceConnectorTerminationHealthAsyncHelper( request, handler, context ); } );
4115 }
4116
GetVoiceConnectorTerminationHealthAsyncHelper(const GetVoiceConnectorTerminationHealthRequest & request,const GetVoiceConnectorTerminationHealthResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4117 void ChimeClient::GetVoiceConnectorTerminationHealthAsyncHelper(const GetVoiceConnectorTerminationHealthRequest& request, const GetVoiceConnectorTerminationHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4118 {
4119 handler(this, request, GetVoiceConnectorTerminationHealth(request), context);
4120 }
4121
InviteUsers(const InviteUsersRequest & request) const4122 InviteUsersOutcome ChimeClient::InviteUsers(const InviteUsersRequest& request) const
4123 {
4124 if (!request.AccountIdHasBeenSet())
4125 {
4126 AWS_LOGSTREAM_ERROR("InviteUsers", "Required field: AccountId, is not set");
4127 return InviteUsersOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
4128 }
4129 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4130 Aws::StringStream ss;
4131 uri.AddPathSegments("/accounts/");
4132 uri.AddPathSegment(request.GetAccountId());
4133 uri.AddPathSegments("/users");
4134 ss.str("?operation=add");
4135 uri.SetQueryString(ss.str());
4136 return InviteUsersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
4137 }
4138
InviteUsersCallable(const InviteUsersRequest & request) const4139 InviteUsersOutcomeCallable ChimeClient::InviteUsersCallable(const InviteUsersRequest& request) const
4140 {
4141 auto task = Aws::MakeShared< std::packaged_task< InviteUsersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->InviteUsers(request); } );
4142 auto packagedFunction = [task]() { (*task)(); };
4143 m_executor->Submit(packagedFunction);
4144 return task->get_future();
4145 }
4146
InviteUsersAsync(const InviteUsersRequest & request,const InviteUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4147 void ChimeClient::InviteUsersAsync(const InviteUsersRequest& request, const InviteUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4148 {
4149 m_executor->Submit( [this, request, handler, context](){ this->InviteUsersAsyncHelper( request, handler, context ); } );
4150 }
4151
InviteUsersAsyncHelper(const InviteUsersRequest & request,const InviteUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4152 void ChimeClient::InviteUsersAsyncHelper(const InviteUsersRequest& request, const InviteUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4153 {
4154 handler(this, request, InviteUsers(request), context);
4155 }
4156
ListAccounts(const ListAccountsRequest & request) const4157 ListAccountsOutcome ChimeClient::ListAccounts(const ListAccountsRequest& request) const
4158 {
4159 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4160 uri.AddPathSegments("/accounts");
4161 return ListAccountsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4162 }
4163
ListAccountsCallable(const ListAccountsRequest & request) const4164 ListAccountsOutcomeCallable ChimeClient::ListAccountsCallable(const ListAccountsRequest& request) const
4165 {
4166 auto task = Aws::MakeShared< std::packaged_task< ListAccountsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAccounts(request); } );
4167 auto packagedFunction = [task]() { (*task)(); };
4168 m_executor->Submit(packagedFunction);
4169 return task->get_future();
4170 }
4171
ListAccountsAsync(const ListAccountsRequest & request,const ListAccountsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4172 void ChimeClient::ListAccountsAsync(const ListAccountsRequest& request, const ListAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4173 {
4174 m_executor->Submit( [this, request, handler, context](){ this->ListAccountsAsyncHelper( request, handler, context ); } );
4175 }
4176
ListAccountsAsyncHelper(const ListAccountsRequest & request,const ListAccountsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4177 void ChimeClient::ListAccountsAsyncHelper(const ListAccountsRequest& request, const ListAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4178 {
4179 handler(this, request, ListAccounts(request), context);
4180 }
4181
ListAppInstanceAdmins(const ListAppInstanceAdminsRequest & request) const4182 ListAppInstanceAdminsOutcome ChimeClient::ListAppInstanceAdmins(const ListAppInstanceAdminsRequest& request) const
4183 {
4184 if (!request.AppInstanceArnHasBeenSet())
4185 {
4186 AWS_LOGSTREAM_ERROR("ListAppInstanceAdmins", "Required field: AppInstanceArn, is not set");
4187 return ListAppInstanceAdminsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
4188 }
4189 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4190 if (m_enableHostPrefixInjection)
4191 {
4192 uri.SetAuthority("identity-" + uri.GetAuthority());
4193 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4194 {
4195 AWS_LOGSTREAM_ERROR("ListAppInstanceAdmins", "Invalid DNS host: " << uri.GetAuthority());
4196 return ListAppInstanceAdminsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4197 }
4198 }
4199 uri.AddPathSegments("/app-instances/");
4200 uri.AddPathSegment(request.GetAppInstanceArn());
4201 uri.AddPathSegments("/admins");
4202 return ListAppInstanceAdminsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4203 }
4204
ListAppInstanceAdminsCallable(const ListAppInstanceAdminsRequest & request) const4205 ListAppInstanceAdminsOutcomeCallable ChimeClient::ListAppInstanceAdminsCallable(const ListAppInstanceAdminsRequest& request) const
4206 {
4207 auto task = Aws::MakeShared< std::packaged_task< ListAppInstanceAdminsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAppInstanceAdmins(request); } );
4208 auto packagedFunction = [task]() { (*task)(); };
4209 m_executor->Submit(packagedFunction);
4210 return task->get_future();
4211 }
4212
ListAppInstanceAdminsAsync(const ListAppInstanceAdminsRequest & request,const ListAppInstanceAdminsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4213 void ChimeClient::ListAppInstanceAdminsAsync(const ListAppInstanceAdminsRequest& request, const ListAppInstanceAdminsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4214 {
4215 m_executor->Submit( [this, request, handler, context](){ this->ListAppInstanceAdminsAsyncHelper( request, handler, context ); } );
4216 }
4217
ListAppInstanceAdminsAsyncHelper(const ListAppInstanceAdminsRequest & request,const ListAppInstanceAdminsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4218 void ChimeClient::ListAppInstanceAdminsAsyncHelper(const ListAppInstanceAdminsRequest& request, const ListAppInstanceAdminsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4219 {
4220 handler(this, request, ListAppInstanceAdmins(request), context);
4221 }
4222
ListAppInstanceUsers(const ListAppInstanceUsersRequest & request) const4223 ListAppInstanceUsersOutcome ChimeClient::ListAppInstanceUsers(const ListAppInstanceUsersRequest& request) const
4224 {
4225 if (!request.AppInstanceArnHasBeenSet())
4226 {
4227 AWS_LOGSTREAM_ERROR("ListAppInstanceUsers", "Required field: AppInstanceArn, is not set");
4228 return ListAppInstanceUsersOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
4229 }
4230 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4231 if (m_enableHostPrefixInjection)
4232 {
4233 uri.SetAuthority("identity-" + uri.GetAuthority());
4234 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4235 {
4236 AWS_LOGSTREAM_ERROR("ListAppInstanceUsers", "Invalid DNS host: " << uri.GetAuthority());
4237 return ListAppInstanceUsersOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4238 }
4239 }
4240 uri.AddPathSegments("/app-instance-users");
4241 return ListAppInstanceUsersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4242 }
4243
ListAppInstanceUsersCallable(const ListAppInstanceUsersRequest & request) const4244 ListAppInstanceUsersOutcomeCallable ChimeClient::ListAppInstanceUsersCallable(const ListAppInstanceUsersRequest& request) const
4245 {
4246 auto task = Aws::MakeShared< std::packaged_task< ListAppInstanceUsersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAppInstanceUsers(request); } );
4247 auto packagedFunction = [task]() { (*task)(); };
4248 m_executor->Submit(packagedFunction);
4249 return task->get_future();
4250 }
4251
ListAppInstanceUsersAsync(const ListAppInstanceUsersRequest & request,const ListAppInstanceUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4252 void ChimeClient::ListAppInstanceUsersAsync(const ListAppInstanceUsersRequest& request, const ListAppInstanceUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4253 {
4254 m_executor->Submit( [this, request, handler, context](){ this->ListAppInstanceUsersAsyncHelper( request, handler, context ); } );
4255 }
4256
ListAppInstanceUsersAsyncHelper(const ListAppInstanceUsersRequest & request,const ListAppInstanceUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4257 void ChimeClient::ListAppInstanceUsersAsyncHelper(const ListAppInstanceUsersRequest& request, const ListAppInstanceUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4258 {
4259 handler(this, request, ListAppInstanceUsers(request), context);
4260 }
4261
ListAppInstances(const ListAppInstancesRequest & request) const4262 ListAppInstancesOutcome ChimeClient::ListAppInstances(const ListAppInstancesRequest& request) const
4263 {
4264 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4265 if (m_enableHostPrefixInjection)
4266 {
4267 uri.SetAuthority("identity-" + uri.GetAuthority());
4268 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4269 {
4270 AWS_LOGSTREAM_ERROR("ListAppInstances", "Invalid DNS host: " << uri.GetAuthority());
4271 return ListAppInstancesOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4272 }
4273 }
4274 uri.AddPathSegments("/app-instances");
4275 return ListAppInstancesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4276 }
4277
ListAppInstancesCallable(const ListAppInstancesRequest & request) const4278 ListAppInstancesOutcomeCallable ChimeClient::ListAppInstancesCallable(const ListAppInstancesRequest& request) const
4279 {
4280 auto task = Aws::MakeShared< std::packaged_task< ListAppInstancesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAppInstances(request); } );
4281 auto packagedFunction = [task]() { (*task)(); };
4282 m_executor->Submit(packagedFunction);
4283 return task->get_future();
4284 }
4285
ListAppInstancesAsync(const ListAppInstancesRequest & request,const ListAppInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4286 void ChimeClient::ListAppInstancesAsync(const ListAppInstancesRequest& request, const ListAppInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4287 {
4288 m_executor->Submit( [this, request, handler, context](){ this->ListAppInstancesAsyncHelper( request, handler, context ); } );
4289 }
4290
ListAppInstancesAsyncHelper(const ListAppInstancesRequest & request,const ListAppInstancesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4291 void ChimeClient::ListAppInstancesAsyncHelper(const ListAppInstancesRequest& request, const ListAppInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4292 {
4293 handler(this, request, ListAppInstances(request), context);
4294 }
4295
ListAttendeeTags(const ListAttendeeTagsRequest & request) const4296 ListAttendeeTagsOutcome ChimeClient::ListAttendeeTags(const ListAttendeeTagsRequest& request) const
4297 {
4298 if (!request.MeetingIdHasBeenSet())
4299 {
4300 AWS_LOGSTREAM_ERROR("ListAttendeeTags", "Required field: MeetingId, is not set");
4301 return ListAttendeeTagsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
4302 }
4303 if (!request.AttendeeIdHasBeenSet())
4304 {
4305 AWS_LOGSTREAM_ERROR("ListAttendeeTags", "Required field: AttendeeId, is not set");
4306 return ListAttendeeTagsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AttendeeId]", false));
4307 }
4308 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4309 uri.AddPathSegments("/meetings/");
4310 uri.AddPathSegment(request.GetMeetingId());
4311 uri.AddPathSegments("/attendees/");
4312 uri.AddPathSegment(request.GetAttendeeId());
4313 uri.AddPathSegments("/tags");
4314 return ListAttendeeTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4315 }
4316
ListAttendeeTagsCallable(const ListAttendeeTagsRequest & request) const4317 ListAttendeeTagsOutcomeCallable ChimeClient::ListAttendeeTagsCallable(const ListAttendeeTagsRequest& request) const
4318 {
4319 auto task = Aws::MakeShared< std::packaged_task< ListAttendeeTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAttendeeTags(request); } );
4320 auto packagedFunction = [task]() { (*task)(); };
4321 m_executor->Submit(packagedFunction);
4322 return task->get_future();
4323 }
4324
ListAttendeeTagsAsync(const ListAttendeeTagsRequest & request,const ListAttendeeTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4325 void ChimeClient::ListAttendeeTagsAsync(const ListAttendeeTagsRequest& request, const ListAttendeeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4326 {
4327 m_executor->Submit( [this, request, handler, context](){ this->ListAttendeeTagsAsyncHelper( request, handler, context ); } );
4328 }
4329
ListAttendeeTagsAsyncHelper(const ListAttendeeTagsRequest & request,const ListAttendeeTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4330 void ChimeClient::ListAttendeeTagsAsyncHelper(const ListAttendeeTagsRequest& request, const ListAttendeeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4331 {
4332 handler(this, request, ListAttendeeTags(request), context);
4333 }
4334
ListAttendees(const ListAttendeesRequest & request) const4335 ListAttendeesOutcome ChimeClient::ListAttendees(const ListAttendeesRequest& request) const
4336 {
4337 if (!request.MeetingIdHasBeenSet())
4338 {
4339 AWS_LOGSTREAM_ERROR("ListAttendees", "Required field: MeetingId, is not set");
4340 return ListAttendeesOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
4341 }
4342 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4343 uri.AddPathSegments("/meetings/");
4344 uri.AddPathSegment(request.GetMeetingId());
4345 uri.AddPathSegments("/attendees");
4346 return ListAttendeesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4347 }
4348
ListAttendeesCallable(const ListAttendeesRequest & request) const4349 ListAttendeesOutcomeCallable ChimeClient::ListAttendeesCallable(const ListAttendeesRequest& request) const
4350 {
4351 auto task = Aws::MakeShared< std::packaged_task< ListAttendeesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAttendees(request); } );
4352 auto packagedFunction = [task]() { (*task)(); };
4353 m_executor->Submit(packagedFunction);
4354 return task->get_future();
4355 }
4356
ListAttendeesAsync(const ListAttendeesRequest & request,const ListAttendeesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4357 void ChimeClient::ListAttendeesAsync(const ListAttendeesRequest& request, const ListAttendeesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4358 {
4359 m_executor->Submit( [this, request, handler, context](){ this->ListAttendeesAsyncHelper( request, handler, context ); } );
4360 }
4361
ListAttendeesAsyncHelper(const ListAttendeesRequest & request,const ListAttendeesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4362 void ChimeClient::ListAttendeesAsyncHelper(const ListAttendeesRequest& request, const ListAttendeesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4363 {
4364 handler(this, request, ListAttendees(request), context);
4365 }
4366
ListBots(const ListBotsRequest & request) const4367 ListBotsOutcome ChimeClient::ListBots(const ListBotsRequest& request) const
4368 {
4369 if (!request.AccountIdHasBeenSet())
4370 {
4371 AWS_LOGSTREAM_ERROR("ListBots", "Required field: AccountId, is not set");
4372 return ListBotsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
4373 }
4374 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4375 uri.AddPathSegments("/accounts/");
4376 uri.AddPathSegment(request.GetAccountId());
4377 uri.AddPathSegments("/bots");
4378 return ListBotsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4379 }
4380
ListBotsCallable(const ListBotsRequest & request) const4381 ListBotsOutcomeCallable ChimeClient::ListBotsCallable(const ListBotsRequest& request) const
4382 {
4383 auto task = Aws::MakeShared< std::packaged_task< ListBotsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListBots(request); } );
4384 auto packagedFunction = [task]() { (*task)(); };
4385 m_executor->Submit(packagedFunction);
4386 return task->get_future();
4387 }
4388
ListBotsAsync(const ListBotsRequest & request,const ListBotsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4389 void ChimeClient::ListBotsAsync(const ListBotsRequest& request, const ListBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4390 {
4391 m_executor->Submit( [this, request, handler, context](){ this->ListBotsAsyncHelper( request, handler, context ); } );
4392 }
4393
ListBotsAsyncHelper(const ListBotsRequest & request,const ListBotsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4394 void ChimeClient::ListBotsAsyncHelper(const ListBotsRequest& request, const ListBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4395 {
4396 handler(this, request, ListBots(request), context);
4397 }
4398
ListChannelBans(const ListChannelBansRequest & request) const4399 ListChannelBansOutcome ChimeClient::ListChannelBans(const ListChannelBansRequest& request) const
4400 {
4401 if (!request.ChannelArnHasBeenSet())
4402 {
4403 AWS_LOGSTREAM_ERROR("ListChannelBans", "Required field: ChannelArn, is not set");
4404 return ListChannelBansOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
4405 }
4406 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4407 if (m_enableHostPrefixInjection)
4408 {
4409 uri.SetAuthority("messaging-" + uri.GetAuthority());
4410 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4411 {
4412 AWS_LOGSTREAM_ERROR("ListChannelBans", "Invalid DNS host: " << uri.GetAuthority());
4413 return ListChannelBansOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4414 }
4415 }
4416 uri.AddPathSegments("/channels/");
4417 uri.AddPathSegment(request.GetChannelArn());
4418 uri.AddPathSegments("/bans");
4419 return ListChannelBansOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4420 }
4421
ListChannelBansCallable(const ListChannelBansRequest & request) const4422 ListChannelBansOutcomeCallable ChimeClient::ListChannelBansCallable(const ListChannelBansRequest& request) const
4423 {
4424 auto task = Aws::MakeShared< std::packaged_task< ListChannelBansOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListChannelBans(request); } );
4425 auto packagedFunction = [task]() { (*task)(); };
4426 m_executor->Submit(packagedFunction);
4427 return task->get_future();
4428 }
4429
ListChannelBansAsync(const ListChannelBansRequest & request,const ListChannelBansResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4430 void ChimeClient::ListChannelBansAsync(const ListChannelBansRequest& request, const ListChannelBansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4431 {
4432 m_executor->Submit( [this, request, handler, context](){ this->ListChannelBansAsyncHelper( request, handler, context ); } );
4433 }
4434
ListChannelBansAsyncHelper(const ListChannelBansRequest & request,const ListChannelBansResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4435 void ChimeClient::ListChannelBansAsyncHelper(const ListChannelBansRequest& request, const ListChannelBansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4436 {
4437 handler(this, request, ListChannelBans(request), context);
4438 }
4439
ListChannelMemberships(const ListChannelMembershipsRequest & request) const4440 ListChannelMembershipsOutcome ChimeClient::ListChannelMemberships(const ListChannelMembershipsRequest& request) const
4441 {
4442 if (!request.ChannelArnHasBeenSet())
4443 {
4444 AWS_LOGSTREAM_ERROR("ListChannelMemberships", "Required field: ChannelArn, is not set");
4445 return ListChannelMembershipsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
4446 }
4447 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4448 if (m_enableHostPrefixInjection)
4449 {
4450 uri.SetAuthority("messaging-" + uri.GetAuthority());
4451 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4452 {
4453 AWS_LOGSTREAM_ERROR("ListChannelMemberships", "Invalid DNS host: " << uri.GetAuthority());
4454 return ListChannelMembershipsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4455 }
4456 }
4457 uri.AddPathSegments("/channels/");
4458 uri.AddPathSegment(request.GetChannelArn());
4459 uri.AddPathSegments("/memberships");
4460 return ListChannelMembershipsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4461 }
4462
ListChannelMembershipsCallable(const ListChannelMembershipsRequest & request) const4463 ListChannelMembershipsOutcomeCallable ChimeClient::ListChannelMembershipsCallable(const ListChannelMembershipsRequest& request) const
4464 {
4465 auto task = Aws::MakeShared< std::packaged_task< ListChannelMembershipsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListChannelMemberships(request); } );
4466 auto packagedFunction = [task]() { (*task)(); };
4467 m_executor->Submit(packagedFunction);
4468 return task->get_future();
4469 }
4470
ListChannelMembershipsAsync(const ListChannelMembershipsRequest & request,const ListChannelMembershipsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4471 void ChimeClient::ListChannelMembershipsAsync(const ListChannelMembershipsRequest& request, const ListChannelMembershipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4472 {
4473 m_executor->Submit( [this, request, handler, context](){ this->ListChannelMembershipsAsyncHelper( request, handler, context ); } );
4474 }
4475
ListChannelMembershipsAsyncHelper(const ListChannelMembershipsRequest & request,const ListChannelMembershipsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4476 void ChimeClient::ListChannelMembershipsAsyncHelper(const ListChannelMembershipsRequest& request, const ListChannelMembershipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4477 {
4478 handler(this, request, ListChannelMemberships(request), context);
4479 }
4480
ListChannelMembershipsForAppInstanceUser(const ListChannelMembershipsForAppInstanceUserRequest & request) const4481 ListChannelMembershipsForAppInstanceUserOutcome ChimeClient::ListChannelMembershipsForAppInstanceUser(const ListChannelMembershipsForAppInstanceUserRequest& request) const
4482 {
4483 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4484 if (m_enableHostPrefixInjection)
4485 {
4486 uri.SetAuthority("messaging-" + uri.GetAuthority());
4487 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4488 {
4489 AWS_LOGSTREAM_ERROR("ListChannelMembershipsForAppInstanceUser", "Invalid DNS host: " << uri.GetAuthority());
4490 return ListChannelMembershipsForAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4491 }
4492 }
4493 Aws::StringStream ss;
4494 uri.AddPathSegments("/channels");
4495 ss.str("?scope=app-instance-user-memberships");
4496 uri.SetQueryString(ss.str());
4497 return ListChannelMembershipsForAppInstanceUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4498 }
4499
ListChannelMembershipsForAppInstanceUserCallable(const ListChannelMembershipsForAppInstanceUserRequest & request) const4500 ListChannelMembershipsForAppInstanceUserOutcomeCallable ChimeClient::ListChannelMembershipsForAppInstanceUserCallable(const ListChannelMembershipsForAppInstanceUserRequest& request) const
4501 {
4502 auto task = Aws::MakeShared< std::packaged_task< ListChannelMembershipsForAppInstanceUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListChannelMembershipsForAppInstanceUser(request); } );
4503 auto packagedFunction = [task]() { (*task)(); };
4504 m_executor->Submit(packagedFunction);
4505 return task->get_future();
4506 }
4507
ListChannelMembershipsForAppInstanceUserAsync(const ListChannelMembershipsForAppInstanceUserRequest & request,const ListChannelMembershipsForAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4508 void ChimeClient::ListChannelMembershipsForAppInstanceUserAsync(const ListChannelMembershipsForAppInstanceUserRequest& request, const ListChannelMembershipsForAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4509 {
4510 m_executor->Submit( [this, request, handler, context](){ this->ListChannelMembershipsForAppInstanceUserAsyncHelper( request, handler, context ); } );
4511 }
4512
ListChannelMembershipsForAppInstanceUserAsyncHelper(const ListChannelMembershipsForAppInstanceUserRequest & request,const ListChannelMembershipsForAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4513 void ChimeClient::ListChannelMembershipsForAppInstanceUserAsyncHelper(const ListChannelMembershipsForAppInstanceUserRequest& request, const ListChannelMembershipsForAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4514 {
4515 handler(this, request, ListChannelMembershipsForAppInstanceUser(request), context);
4516 }
4517
ListChannelMessages(const ListChannelMessagesRequest & request) const4518 ListChannelMessagesOutcome ChimeClient::ListChannelMessages(const ListChannelMessagesRequest& request) const
4519 {
4520 if (!request.ChannelArnHasBeenSet())
4521 {
4522 AWS_LOGSTREAM_ERROR("ListChannelMessages", "Required field: ChannelArn, is not set");
4523 return ListChannelMessagesOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
4524 }
4525 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4526 if (m_enableHostPrefixInjection)
4527 {
4528 uri.SetAuthority("messaging-" + uri.GetAuthority());
4529 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4530 {
4531 AWS_LOGSTREAM_ERROR("ListChannelMessages", "Invalid DNS host: " << uri.GetAuthority());
4532 return ListChannelMessagesOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4533 }
4534 }
4535 uri.AddPathSegments("/channels/");
4536 uri.AddPathSegment(request.GetChannelArn());
4537 uri.AddPathSegments("/messages");
4538 return ListChannelMessagesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4539 }
4540
ListChannelMessagesCallable(const ListChannelMessagesRequest & request) const4541 ListChannelMessagesOutcomeCallable ChimeClient::ListChannelMessagesCallable(const ListChannelMessagesRequest& request) const
4542 {
4543 auto task = Aws::MakeShared< std::packaged_task< ListChannelMessagesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListChannelMessages(request); } );
4544 auto packagedFunction = [task]() { (*task)(); };
4545 m_executor->Submit(packagedFunction);
4546 return task->get_future();
4547 }
4548
ListChannelMessagesAsync(const ListChannelMessagesRequest & request,const ListChannelMessagesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4549 void ChimeClient::ListChannelMessagesAsync(const ListChannelMessagesRequest& request, const ListChannelMessagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4550 {
4551 m_executor->Submit( [this, request, handler, context](){ this->ListChannelMessagesAsyncHelper( request, handler, context ); } );
4552 }
4553
ListChannelMessagesAsyncHelper(const ListChannelMessagesRequest & request,const ListChannelMessagesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4554 void ChimeClient::ListChannelMessagesAsyncHelper(const ListChannelMessagesRequest& request, const ListChannelMessagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4555 {
4556 handler(this, request, ListChannelMessages(request), context);
4557 }
4558
ListChannelModerators(const ListChannelModeratorsRequest & request) const4559 ListChannelModeratorsOutcome ChimeClient::ListChannelModerators(const ListChannelModeratorsRequest& request) const
4560 {
4561 if (!request.ChannelArnHasBeenSet())
4562 {
4563 AWS_LOGSTREAM_ERROR("ListChannelModerators", "Required field: ChannelArn, is not set");
4564 return ListChannelModeratorsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
4565 }
4566 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4567 if (m_enableHostPrefixInjection)
4568 {
4569 uri.SetAuthority("messaging-" + uri.GetAuthority());
4570 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4571 {
4572 AWS_LOGSTREAM_ERROR("ListChannelModerators", "Invalid DNS host: " << uri.GetAuthority());
4573 return ListChannelModeratorsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4574 }
4575 }
4576 uri.AddPathSegments("/channels/");
4577 uri.AddPathSegment(request.GetChannelArn());
4578 uri.AddPathSegments("/moderators");
4579 return ListChannelModeratorsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4580 }
4581
ListChannelModeratorsCallable(const ListChannelModeratorsRequest & request) const4582 ListChannelModeratorsOutcomeCallable ChimeClient::ListChannelModeratorsCallable(const ListChannelModeratorsRequest& request) const
4583 {
4584 auto task = Aws::MakeShared< std::packaged_task< ListChannelModeratorsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListChannelModerators(request); } );
4585 auto packagedFunction = [task]() { (*task)(); };
4586 m_executor->Submit(packagedFunction);
4587 return task->get_future();
4588 }
4589
ListChannelModeratorsAsync(const ListChannelModeratorsRequest & request,const ListChannelModeratorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4590 void ChimeClient::ListChannelModeratorsAsync(const ListChannelModeratorsRequest& request, const ListChannelModeratorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4591 {
4592 m_executor->Submit( [this, request, handler, context](){ this->ListChannelModeratorsAsyncHelper( request, handler, context ); } );
4593 }
4594
ListChannelModeratorsAsyncHelper(const ListChannelModeratorsRequest & request,const ListChannelModeratorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4595 void ChimeClient::ListChannelModeratorsAsyncHelper(const ListChannelModeratorsRequest& request, const ListChannelModeratorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4596 {
4597 handler(this, request, ListChannelModerators(request), context);
4598 }
4599
ListChannels(const ListChannelsRequest & request) const4600 ListChannelsOutcome ChimeClient::ListChannels(const ListChannelsRequest& request) const
4601 {
4602 if (!request.AppInstanceArnHasBeenSet())
4603 {
4604 AWS_LOGSTREAM_ERROR("ListChannels", "Required field: AppInstanceArn, is not set");
4605 return ListChannelsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
4606 }
4607 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4608 if (m_enableHostPrefixInjection)
4609 {
4610 uri.SetAuthority("messaging-" + uri.GetAuthority());
4611 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4612 {
4613 AWS_LOGSTREAM_ERROR("ListChannels", "Invalid DNS host: " << uri.GetAuthority());
4614 return ListChannelsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4615 }
4616 }
4617 uri.AddPathSegments("/channels");
4618 return ListChannelsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4619 }
4620
ListChannelsCallable(const ListChannelsRequest & request) const4621 ListChannelsOutcomeCallable ChimeClient::ListChannelsCallable(const ListChannelsRequest& request) const
4622 {
4623 auto task = Aws::MakeShared< std::packaged_task< ListChannelsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListChannels(request); } );
4624 auto packagedFunction = [task]() { (*task)(); };
4625 m_executor->Submit(packagedFunction);
4626 return task->get_future();
4627 }
4628
ListChannelsAsync(const ListChannelsRequest & request,const ListChannelsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4629 void ChimeClient::ListChannelsAsync(const ListChannelsRequest& request, const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4630 {
4631 m_executor->Submit( [this, request, handler, context](){ this->ListChannelsAsyncHelper( request, handler, context ); } );
4632 }
4633
ListChannelsAsyncHelper(const ListChannelsRequest & request,const ListChannelsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4634 void ChimeClient::ListChannelsAsyncHelper(const ListChannelsRequest& request, const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4635 {
4636 handler(this, request, ListChannels(request), context);
4637 }
4638
ListChannelsModeratedByAppInstanceUser(const ListChannelsModeratedByAppInstanceUserRequest & request) const4639 ListChannelsModeratedByAppInstanceUserOutcome ChimeClient::ListChannelsModeratedByAppInstanceUser(const ListChannelsModeratedByAppInstanceUserRequest& request) const
4640 {
4641 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4642 if (m_enableHostPrefixInjection)
4643 {
4644 uri.SetAuthority("messaging-" + uri.GetAuthority());
4645 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
4646 {
4647 AWS_LOGSTREAM_ERROR("ListChannelsModeratedByAppInstanceUser", "Invalid DNS host: " << uri.GetAuthority());
4648 return ListChannelsModeratedByAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
4649 }
4650 }
4651 Aws::StringStream ss;
4652 uri.AddPathSegments("/channels");
4653 ss.str("?scope=app-instance-user-moderated-channels");
4654 uri.SetQueryString(ss.str());
4655 return ListChannelsModeratedByAppInstanceUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4656 }
4657
ListChannelsModeratedByAppInstanceUserCallable(const ListChannelsModeratedByAppInstanceUserRequest & request) const4658 ListChannelsModeratedByAppInstanceUserOutcomeCallable ChimeClient::ListChannelsModeratedByAppInstanceUserCallable(const ListChannelsModeratedByAppInstanceUserRequest& request) const
4659 {
4660 auto task = Aws::MakeShared< std::packaged_task< ListChannelsModeratedByAppInstanceUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListChannelsModeratedByAppInstanceUser(request); } );
4661 auto packagedFunction = [task]() { (*task)(); };
4662 m_executor->Submit(packagedFunction);
4663 return task->get_future();
4664 }
4665
ListChannelsModeratedByAppInstanceUserAsync(const ListChannelsModeratedByAppInstanceUserRequest & request,const ListChannelsModeratedByAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4666 void ChimeClient::ListChannelsModeratedByAppInstanceUserAsync(const ListChannelsModeratedByAppInstanceUserRequest& request, const ListChannelsModeratedByAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4667 {
4668 m_executor->Submit( [this, request, handler, context](){ this->ListChannelsModeratedByAppInstanceUserAsyncHelper( request, handler, context ); } );
4669 }
4670
ListChannelsModeratedByAppInstanceUserAsyncHelper(const ListChannelsModeratedByAppInstanceUserRequest & request,const ListChannelsModeratedByAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4671 void ChimeClient::ListChannelsModeratedByAppInstanceUserAsyncHelper(const ListChannelsModeratedByAppInstanceUserRequest& request, const ListChannelsModeratedByAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4672 {
4673 handler(this, request, ListChannelsModeratedByAppInstanceUser(request), context);
4674 }
4675
ListMediaCapturePipelines(const ListMediaCapturePipelinesRequest & request) const4676 ListMediaCapturePipelinesOutcome ChimeClient::ListMediaCapturePipelines(const ListMediaCapturePipelinesRequest& request) const
4677 {
4678 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4679 uri.AddPathSegments("/media-capture-pipelines");
4680 return ListMediaCapturePipelinesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4681 }
4682
ListMediaCapturePipelinesCallable(const ListMediaCapturePipelinesRequest & request) const4683 ListMediaCapturePipelinesOutcomeCallable ChimeClient::ListMediaCapturePipelinesCallable(const ListMediaCapturePipelinesRequest& request) const
4684 {
4685 auto task = Aws::MakeShared< std::packaged_task< ListMediaCapturePipelinesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListMediaCapturePipelines(request); } );
4686 auto packagedFunction = [task]() { (*task)(); };
4687 m_executor->Submit(packagedFunction);
4688 return task->get_future();
4689 }
4690
ListMediaCapturePipelinesAsync(const ListMediaCapturePipelinesRequest & request,const ListMediaCapturePipelinesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4691 void ChimeClient::ListMediaCapturePipelinesAsync(const ListMediaCapturePipelinesRequest& request, const ListMediaCapturePipelinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4692 {
4693 m_executor->Submit( [this, request, handler, context](){ this->ListMediaCapturePipelinesAsyncHelper( request, handler, context ); } );
4694 }
4695
ListMediaCapturePipelinesAsyncHelper(const ListMediaCapturePipelinesRequest & request,const ListMediaCapturePipelinesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4696 void ChimeClient::ListMediaCapturePipelinesAsyncHelper(const ListMediaCapturePipelinesRequest& request, const ListMediaCapturePipelinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4697 {
4698 handler(this, request, ListMediaCapturePipelines(request), context);
4699 }
4700
ListMeetingTags(const ListMeetingTagsRequest & request) const4701 ListMeetingTagsOutcome ChimeClient::ListMeetingTags(const ListMeetingTagsRequest& request) const
4702 {
4703 if (!request.MeetingIdHasBeenSet())
4704 {
4705 AWS_LOGSTREAM_ERROR("ListMeetingTags", "Required field: MeetingId, is not set");
4706 return ListMeetingTagsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
4707 }
4708 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4709 uri.AddPathSegments("/meetings/");
4710 uri.AddPathSegment(request.GetMeetingId());
4711 uri.AddPathSegments("/tags");
4712 return ListMeetingTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4713 }
4714
ListMeetingTagsCallable(const ListMeetingTagsRequest & request) const4715 ListMeetingTagsOutcomeCallable ChimeClient::ListMeetingTagsCallable(const ListMeetingTagsRequest& request) const
4716 {
4717 auto task = Aws::MakeShared< std::packaged_task< ListMeetingTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListMeetingTags(request); } );
4718 auto packagedFunction = [task]() { (*task)(); };
4719 m_executor->Submit(packagedFunction);
4720 return task->get_future();
4721 }
4722
ListMeetingTagsAsync(const ListMeetingTagsRequest & request,const ListMeetingTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4723 void ChimeClient::ListMeetingTagsAsync(const ListMeetingTagsRequest& request, const ListMeetingTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4724 {
4725 m_executor->Submit( [this, request, handler, context](){ this->ListMeetingTagsAsyncHelper( request, handler, context ); } );
4726 }
4727
ListMeetingTagsAsyncHelper(const ListMeetingTagsRequest & request,const ListMeetingTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4728 void ChimeClient::ListMeetingTagsAsyncHelper(const ListMeetingTagsRequest& request, const ListMeetingTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4729 {
4730 handler(this, request, ListMeetingTags(request), context);
4731 }
4732
ListMeetings(const ListMeetingsRequest & request) const4733 ListMeetingsOutcome ChimeClient::ListMeetings(const ListMeetingsRequest& request) const
4734 {
4735 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4736 uri.AddPathSegments("/meetings");
4737 return ListMeetingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4738 }
4739
ListMeetingsCallable(const ListMeetingsRequest & request) const4740 ListMeetingsOutcomeCallable ChimeClient::ListMeetingsCallable(const ListMeetingsRequest& request) const
4741 {
4742 auto task = Aws::MakeShared< std::packaged_task< ListMeetingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListMeetings(request); } );
4743 auto packagedFunction = [task]() { (*task)(); };
4744 m_executor->Submit(packagedFunction);
4745 return task->get_future();
4746 }
4747
ListMeetingsAsync(const ListMeetingsRequest & request,const ListMeetingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4748 void ChimeClient::ListMeetingsAsync(const ListMeetingsRequest& request, const ListMeetingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4749 {
4750 m_executor->Submit( [this, request, handler, context](){ this->ListMeetingsAsyncHelper( request, handler, context ); } );
4751 }
4752
ListMeetingsAsyncHelper(const ListMeetingsRequest & request,const ListMeetingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4753 void ChimeClient::ListMeetingsAsyncHelper(const ListMeetingsRequest& request, const ListMeetingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4754 {
4755 handler(this, request, ListMeetings(request), context);
4756 }
4757
ListPhoneNumberOrders(const ListPhoneNumberOrdersRequest & request) const4758 ListPhoneNumberOrdersOutcome ChimeClient::ListPhoneNumberOrders(const ListPhoneNumberOrdersRequest& request) const
4759 {
4760 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4761 uri.AddPathSegments("/phone-number-orders");
4762 return ListPhoneNumberOrdersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4763 }
4764
ListPhoneNumberOrdersCallable(const ListPhoneNumberOrdersRequest & request) const4765 ListPhoneNumberOrdersOutcomeCallable ChimeClient::ListPhoneNumberOrdersCallable(const ListPhoneNumberOrdersRequest& request) const
4766 {
4767 auto task = Aws::MakeShared< std::packaged_task< ListPhoneNumberOrdersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPhoneNumberOrders(request); } );
4768 auto packagedFunction = [task]() { (*task)(); };
4769 m_executor->Submit(packagedFunction);
4770 return task->get_future();
4771 }
4772
ListPhoneNumberOrdersAsync(const ListPhoneNumberOrdersRequest & request,const ListPhoneNumberOrdersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4773 void ChimeClient::ListPhoneNumberOrdersAsync(const ListPhoneNumberOrdersRequest& request, const ListPhoneNumberOrdersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4774 {
4775 m_executor->Submit( [this, request, handler, context](){ this->ListPhoneNumberOrdersAsyncHelper( request, handler, context ); } );
4776 }
4777
ListPhoneNumberOrdersAsyncHelper(const ListPhoneNumberOrdersRequest & request,const ListPhoneNumberOrdersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4778 void ChimeClient::ListPhoneNumberOrdersAsyncHelper(const ListPhoneNumberOrdersRequest& request, const ListPhoneNumberOrdersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4779 {
4780 handler(this, request, ListPhoneNumberOrders(request), context);
4781 }
4782
ListPhoneNumbers(const ListPhoneNumbersRequest & request) const4783 ListPhoneNumbersOutcome ChimeClient::ListPhoneNumbers(const ListPhoneNumbersRequest& request) const
4784 {
4785 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4786 uri.AddPathSegments("/phone-numbers");
4787 return ListPhoneNumbersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4788 }
4789
ListPhoneNumbersCallable(const ListPhoneNumbersRequest & request) const4790 ListPhoneNumbersOutcomeCallable ChimeClient::ListPhoneNumbersCallable(const ListPhoneNumbersRequest& request) const
4791 {
4792 auto task = Aws::MakeShared< std::packaged_task< ListPhoneNumbersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPhoneNumbers(request); } );
4793 auto packagedFunction = [task]() { (*task)(); };
4794 m_executor->Submit(packagedFunction);
4795 return task->get_future();
4796 }
4797
ListPhoneNumbersAsync(const ListPhoneNumbersRequest & request,const ListPhoneNumbersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4798 void ChimeClient::ListPhoneNumbersAsync(const ListPhoneNumbersRequest& request, const ListPhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4799 {
4800 m_executor->Submit( [this, request, handler, context](){ this->ListPhoneNumbersAsyncHelper( request, handler, context ); } );
4801 }
4802
ListPhoneNumbersAsyncHelper(const ListPhoneNumbersRequest & request,const ListPhoneNumbersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4803 void ChimeClient::ListPhoneNumbersAsyncHelper(const ListPhoneNumbersRequest& request, const ListPhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4804 {
4805 handler(this, request, ListPhoneNumbers(request), context);
4806 }
4807
ListProxySessions(const ListProxySessionsRequest & request) const4808 ListProxySessionsOutcome ChimeClient::ListProxySessions(const ListProxySessionsRequest& request) const
4809 {
4810 if (!request.VoiceConnectorIdHasBeenSet())
4811 {
4812 AWS_LOGSTREAM_ERROR("ListProxySessions", "Required field: VoiceConnectorId, is not set");
4813 return ListProxySessionsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
4814 }
4815 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4816 uri.AddPathSegments("/voice-connectors/");
4817 uri.AddPathSegment(request.GetVoiceConnectorId());
4818 uri.AddPathSegments("/proxy-sessions");
4819 return ListProxySessionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4820 }
4821
ListProxySessionsCallable(const ListProxySessionsRequest & request) const4822 ListProxySessionsOutcomeCallable ChimeClient::ListProxySessionsCallable(const ListProxySessionsRequest& request) const
4823 {
4824 auto task = Aws::MakeShared< std::packaged_task< ListProxySessionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListProxySessions(request); } );
4825 auto packagedFunction = [task]() { (*task)(); };
4826 m_executor->Submit(packagedFunction);
4827 return task->get_future();
4828 }
4829
ListProxySessionsAsync(const ListProxySessionsRequest & request,const ListProxySessionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4830 void ChimeClient::ListProxySessionsAsync(const ListProxySessionsRequest& request, const ListProxySessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4831 {
4832 m_executor->Submit( [this, request, handler, context](){ this->ListProxySessionsAsyncHelper( request, handler, context ); } );
4833 }
4834
ListProxySessionsAsyncHelper(const ListProxySessionsRequest & request,const ListProxySessionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4835 void ChimeClient::ListProxySessionsAsyncHelper(const ListProxySessionsRequest& request, const ListProxySessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4836 {
4837 handler(this, request, ListProxySessions(request), context);
4838 }
4839
ListRoomMemberships(const ListRoomMembershipsRequest & request) const4840 ListRoomMembershipsOutcome ChimeClient::ListRoomMemberships(const ListRoomMembershipsRequest& request) const
4841 {
4842 if (!request.AccountIdHasBeenSet())
4843 {
4844 AWS_LOGSTREAM_ERROR("ListRoomMemberships", "Required field: AccountId, is not set");
4845 return ListRoomMembershipsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
4846 }
4847 if (!request.RoomIdHasBeenSet())
4848 {
4849 AWS_LOGSTREAM_ERROR("ListRoomMemberships", "Required field: RoomId, is not set");
4850 return ListRoomMembershipsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
4851 }
4852 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4853 uri.AddPathSegments("/accounts/");
4854 uri.AddPathSegment(request.GetAccountId());
4855 uri.AddPathSegments("/rooms/");
4856 uri.AddPathSegment(request.GetRoomId());
4857 uri.AddPathSegments("/memberships");
4858 return ListRoomMembershipsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4859 }
4860
ListRoomMembershipsCallable(const ListRoomMembershipsRequest & request) const4861 ListRoomMembershipsOutcomeCallable ChimeClient::ListRoomMembershipsCallable(const ListRoomMembershipsRequest& request) const
4862 {
4863 auto task = Aws::MakeShared< std::packaged_task< ListRoomMembershipsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRoomMemberships(request); } );
4864 auto packagedFunction = [task]() { (*task)(); };
4865 m_executor->Submit(packagedFunction);
4866 return task->get_future();
4867 }
4868
ListRoomMembershipsAsync(const ListRoomMembershipsRequest & request,const ListRoomMembershipsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4869 void ChimeClient::ListRoomMembershipsAsync(const ListRoomMembershipsRequest& request, const ListRoomMembershipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4870 {
4871 m_executor->Submit( [this, request, handler, context](){ this->ListRoomMembershipsAsyncHelper( request, handler, context ); } );
4872 }
4873
ListRoomMembershipsAsyncHelper(const ListRoomMembershipsRequest & request,const ListRoomMembershipsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4874 void ChimeClient::ListRoomMembershipsAsyncHelper(const ListRoomMembershipsRequest& request, const ListRoomMembershipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4875 {
4876 handler(this, request, ListRoomMemberships(request), context);
4877 }
4878
ListRooms(const ListRoomsRequest & request) const4879 ListRoomsOutcome ChimeClient::ListRooms(const ListRoomsRequest& request) const
4880 {
4881 if (!request.AccountIdHasBeenSet())
4882 {
4883 AWS_LOGSTREAM_ERROR("ListRooms", "Required field: AccountId, is not set");
4884 return ListRoomsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
4885 }
4886 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4887 uri.AddPathSegments("/accounts/");
4888 uri.AddPathSegment(request.GetAccountId());
4889 uri.AddPathSegments("/rooms");
4890 return ListRoomsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4891 }
4892
ListRoomsCallable(const ListRoomsRequest & request) const4893 ListRoomsOutcomeCallable ChimeClient::ListRoomsCallable(const ListRoomsRequest& request) const
4894 {
4895 auto task = Aws::MakeShared< std::packaged_task< ListRoomsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRooms(request); } );
4896 auto packagedFunction = [task]() { (*task)(); };
4897 m_executor->Submit(packagedFunction);
4898 return task->get_future();
4899 }
4900
ListRoomsAsync(const ListRoomsRequest & request,const ListRoomsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4901 void ChimeClient::ListRoomsAsync(const ListRoomsRequest& request, const ListRoomsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4902 {
4903 m_executor->Submit( [this, request, handler, context](){ this->ListRoomsAsyncHelper( request, handler, context ); } );
4904 }
4905
ListRoomsAsyncHelper(const ListRoomsRequest & request,const ListRoomsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4906 void ChimeClient::ListRoomsAsyncHelper(const ListRoomsRequest& request, const ListRoomsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4907 {
4908 handler(this, request, ListRooms(request), context);
4909 }
4910
ListSipMediaApplications(const ListSipMediaApplicationsRequest & request) const4911 ListSipMediaApplicationsOutcome ChimeClient::ListSipMediaApplications(const ListSipMediaApplicationsRequest& request) const
4912 {
4913 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4914 uri.AddPathSegments("/sip-media-applications");
4915 return ListSipMediaApplicationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4916 }
4917
ListSipMediaApplicationsCallable(const ListSipMediaApplicationsRequest & request) const4918 ListSipMediaApplicationsOutcomeCallable ChimeClient::ListSipMediaApplicationsCallable(const ListSipMediaApplicationsRequest& request) const
4919 {
4920 auto task = Aws::MakeShared< std::packaged_task< ListSipMediaApplicationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSipMediaApplications(request); } );
4921 auto packagedFunction = [task]() { (*task)(); };
4922 m_executor->Submit(packagedFunction);
4923 return task->get_future();
4924 }
4925
ListSipMediaApplicationsAsync(const ListSipMediaApplicationsRequest & request,const ListSipMediaApplicationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4926 void ChimeClient::ListSipMediaApplicationsAsync(const ListSipMediaApplicationsRequest& request, const ListSipMediaApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4927 {
4928 m_executor->Submit( [this, request, handler, context](){ this->ListSipMediaApplicationsAsyncHelper( request, handler, context ); } );
4929 }
4930
ListSipMediaApplicationsAsyncHelper(const ListSipMediaApplicationsRequest & request,const ListSipMediaApplicationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4931 void ChimeClient::ListSipMediaApplicationsAsyncHelper(const ListSipMediaApplicationsRequest& request, const ListSipMediaApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4932 {
4933 handler(this, request, ListSipMediaApplications(request), context);
4934 }
4935
ListSipRules(const ListSipRulesRequest & request) const4936 ListSipRulesOutcome ChimeClient::ListSipRules(const ListSipRulesRequest& request) const
4937 {
4938 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4939 uri.AddPathSegments("/sip-rules");
4940 return ListSipRulesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4941 }
4942
ListSipRulesCallable(const ListSipRulesRequest & request) const4943 ListSipRulesOutcomeCallable ChimeClient::ListSipRulesCallable(const ListSipRulesRequest& request) const
4944 {
4945 auto task = Aws::MakeShared< std::packaged_task< ListSipRulesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSipRules(request); } );
4946 auto packagedFunction = [task]() { (*task)(); };
4947 m_executor->Submit(packagedFunction);
4948 return task->get_future();
4949 }
4950
ListSipRulesAsync(const ListSipRulesRequest & request,const ListSipRulesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4951 void ChimeClient::ListSipRulesAsync(const ListSipRulesRequest& request, const ListSipRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4952 {
4953 m_executor->Submit( [this, request, handler, context](){ this->ListSipRulesAsyncHelper( request, handler, context ); } );
4954 }
4955
ListSipRulesAsyncHelper(const ListSipRulesRequest & request,const ListSipRulesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4956 void ChimeClient::ListSipRulesAsyncHelper(const ListSipRulesRequest& request, const ListSipRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4957 {
4958 handler(this, request, ListSipRules(request), context);
4959 }
4960
ListSupportedPhoneNumberCountries(const ListSupportedPhoneNumberCountriesRequest & request) const4961 ListSupportedPhoneNumberCountriesOutcome ChimeClient::ListSupportedPhoneNumberCountries(const ListSupportedPhoneNumberCountriesRequest& request) const
4962 {
4963 if (!request.ProductTypeHasBeenSet())
4964 {
4965 AWS_LOGSTREAM_ERROR("ListSupportedPhoneNumberCountries", "Required field: ProductType, is not set");
4966 return ListSupportedPhoneNumberCountriesOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ProductType]", false));
4967 }
4968 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4969 uri.AddPathSegments("/phone-number-countries");
4970 return ListSupportedPhoneNumberCountriesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
4971 }
4972
ListSupportedPhoneNumberCountriesCallable(const ListSupportedPhoneNumberCountriesRequest & request) const4973 ListSupportedPhoneNumberCountriesOutcomeCallable ChimeClient::ListSupportedPhoneNumberCountriesCallable(const ListSupportedPhoneNumberCountriesRequest& request) const
4974 {
4975 auto task = Aws::MakeShared< std::packaged_task< ListSupportedPhoneNumberCountriesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSupportedPhoneNumberCountries(request); } );
4976 auto packagedFunction = [task]() { (*task)(); };
4977 m_executor->Submit(packagedFunction);
4978 return task->get_future();
4979 }
4980
ListSupportedPhoneNumberCountriesAsync(const ListSupportedPhoneNumberCountriesRequest & request,const ListSupportedPhoneNumberCountriesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4981 void ChimeClient::ListSupportedPhoneNumberCountriesAsync(const ListSupportedPhoneNumberCountriesRequest& request, const ListSupportedPhoneNumberCountriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4982 {
4983 m_executor->Submit( [this, request, handler, context](){ this->ListSupportedPhoneNumberCountriesAsyncHelper( request, handler, context ); } );
4984 }
4985
ListSupportedPhoneNumberCountriesAsyncHelper(const ListSupportedPhoneNumberCountriesRequest & request,const ListSupportedPhoneNumberCountriesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4986 void ChimeClient::ListSupportedPhoneNumberCountriesAsyncHelper(const ListSupportedPhoneNumberCountriesRequest& request, const ListSupportedPhoneNumberCountriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4987 {
4988 handler(this, request, ListSupportedPhoneNumberCountries(request), context);
4989 }
4990
ListTagsForResource(const ListTagsForResourceRequest & request) const4991 ListTagsForResourceOutcome ChimeClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
4992 {
4993 if (!request.ResourceARNHasBeenSet())
4994 {
4995 AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceARN, is not set");
4996 return ListTagsForResourceOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceARN]", false));
4997 }
4998 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
4999 uri.AddPathSegments("/tags");
5000 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
5001 }
5002
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const5003 ListTagsForResourceOutcomeCallable ChimeClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
5004 {
5005 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
5006 auto packagedFunction = [task]() { (*task)(); };
5007 m_executor->Submit(packagedFunction);
5008 return task->get_future();
5009 }
5010
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5011 void ChimeClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5012 {
5013 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
5014 }
5015
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5016 void ChimeClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5017 {
5018 handler(this, request, ListTagsForResource(request), context);
5019 }
5020
ListUsers(const ListUsersRequest & request) const5021 ListUsersOutcome ChimeClient::ListUsers(const ListUsersRequest& request) const
5022 {
5023 if (!request.AccountIdHasBeenSet())
5024 {
5025 AWS_LOGSTREAM_ERROR("ListUsers", "Required field: AccountId, is not set");
5026 return ListUsersOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
5027 }
5028 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5029 uri.AddPathSegments("/accounts/");
5030 uri.AddPathSegment(request.GetAccountId());
5031 uri.AddPathSegments("/users");
5032 return ListUsersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
5033 }
5034
ListUsersCallable(const ListUsersRequest & request) const5035 ListUsersOutcomeCallable ChimeClient::ListUsersCallable(const ListUsersRequest& request) const
5036 {
5037 auto task = Aws::MakeShared< std::packaged_task< ListUsersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListUsers(request); } );
5038 auto packagedFunction = [task]() { (*task)(); };
5039 m_executor->Submit(packagedFunction);
5040 return task->get_future();
5041 }
5042
ListUsersAsync(const ListUsersRequest & request,const ListUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5043 void ChimeClient::ListUsersAsync(const ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5044 {
5045 m_executor->Submit( [this, request, handler, context](){ this->ListUsersAsyncHelper( request, handler, context ); } );
5046 }
5047
ListUsersAsyncHelper(const ListUsersRequest & request,const ListUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5048 void ChimeClient::ListUsersAsyncHelper(const ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5049 {
5050 handler(this, request, ListUsers(request), context);
5051 }
5052
ListVoiceConnectorGroups(const ListVoiceConnectorGroupsRequest & request) const5053 ListVoiceConnectorGroupsOutcome ChimeClient::ListVoiceConnectorGroups(const ListVoiceConnectorGroupsRequest& request) const
5054 {
5055 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5056 uri.AddPathSegments("/voice-connector-groups");
5057 return ListVoiceConnectorGroupsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
5058 }
5059
ListVoiceConnectorGroupsCallable(const ListVoiceConnectorGroupsRequest & request) const5060 ListVoiceConnectorGroupsOutcomeCallable ChimeClient::ListVoiceConnectorGroupsCallable(const ListVoiceConnectorGroupsRequest& request) const
5061 {
5062 auto task = Aws::MakeShared< std::packaged_task< ListVoiceConnectorGroupsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVoiceConnectorGroups(request); } );
5063 auto packagedFunction = [task]() { (*task)(); };
5064 m_executor->Submit(packagedFunction);
5065 return task->get_future();
5066 }
5067
ListVoiceConnectorGroupsAsync(const ListVoiceConnectorGroupsRequest & request,const ListVoiceConnectorGroupsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5068 void ChimeClient::ListVoiceConnectorGroupsAsync(const ListVoiceConnectorGroupsRequest& request, const ListVoiceConnectorGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5069 {
5070 m_executor->Submit( [this, request, handler, context](){ this->ListVoiceConnectorGroupsAsyncHelper( request, handler, context ); } );
5071 }
5072
ListVoiceConnectorGroupsAsyncHelper(const ListVoiceConnectorGroupsRequest & request,const ListVoiceConnectorGroupsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5073 void ChimeClient::ListVoiceConnectorGroupsAsyncHelper(const ListVoiceConnectorGroupsRequest& request, const ListVoiceConnectorGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5074 {
5075 handler(this, request, ListVoiceConnectorGroups(request), context);
5076 }
5077
ListVoiceConnectorTerminationCredentials(const ListVoiceConnectorTerminationCredentialsRequest & request) const5078 ListVoiceConnectorTerminationCredentialsOutcome ChimeClient::ListVoiceConnectorTerminationCredentials(const ListVoiceConnectorTerminationCredentialsRequest& request) const
5079 {
5080 if (!request.VoiceConnectorIdHasBeenSet())
5081 {
5082 AWS_LOGSTREAM_ERROR("ListVoiceConnectorTerminationCredentials", "Required field: VoiceConnectorId, is not set");
5083 return ListVoiceConnectorTerminationCredentialsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
5084 }
5085 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5086 uri.AddPathSegments("/voice-connectors/");
5087 uri.AddPathSegment(request.GetVoiceConnectorId());
5088 uri.AddPathSegments("/termination/credentials");
5089 return ListVoiceConnectorTerminationCredentialsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
5090 }
5091
ListVoiceConnectorTerminationCredentialsCallable(const ListVoiceConnectorTerminationCredentialsRequest & request) const5092 ListVoiceConnectorTerminationCredentialsOutcomeCallable ChimeClient::ListVoiceConnectorTerminationCredentialsCallable(const ListVoiceConnectorTerminationCredentialsRequest& request) const
5093 {
5094 auto task = Aws::MakeShared< std::packaged_task< ListVoiceConnectorTerminationCredentialsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVoiceConnectorTerminationCredentials(request); } );
5095 auto packagedFunction = [task]() { (*task)(); };
5096 m_executor->Submit(packagedFunction);
5097 return task->get_future();
5098 }
5099
ListVoiceConnectorTerminationCredentialsAsync(const ListVoiceConnectorTerminationCredentialsRequest & request,const ListVoiceConnectorTerminationCredentialsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5100 void ChimeClient::ListVoiceConnectorTerminationCredentialsAsync(const ListVoiceConnectorTerminationCredentialsRequest& request, const ListVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5101 {
5102 m_executor->Submit( [this, request, handler, context](){ this->ListVoiceConnectorTerminationCredentialsAsyncHelper( request, handler, context ); } );
5103 }
5104
ListVoiceConnectorTerminationCredentialsAsyncHelper(const ListVoiceConnectorTerminationCredentialsRequest & request,const ListVoiceConnectorTerminationCredentialsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5105 void ChimeClient::ListVoiceConnectorTerminationCredentialsAsyncHelper(const ListVoiceConnectorTerminationCredentialsRequest& request, const ListVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5106 {
5107 handler(this, request, ListVoiceConnectorTerminationCredentials(request), context);
5108 }
5109
ListVoiceConnectors(const ListVoiceConnectorsRequest & request) const5110 ListVoiceConnectorsOutcome ChimeClient::ListVoiceConnectors(const ListVoiceConnectorsRequest& request) const
5111 {
5112 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5113 uri.AddPathSegments("/voice-connectors");
5114 return ListVoiceConnectorsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
5115 }
5116
ListVoiceConnectorsCallable(const ListVoiceConnectorsRequest & request) const5117 ListVoiceConnectorsOutcomeCallable ChimeClient::ListVoiceConnectorsCallable(const ListVoiceConnectorsRequest& request) const
5118 {
5119 auto task = Aws::MakeShared< std::packaged_task< ListVoiceConnectorsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVoiceConnectors(request); } );
5120 auto packagedFunction = [task]() { (*task)(); };
5121 m_executor->Submit(packagedFunction);
5122 return task->get_future();
5123 }
5124
ListVoiceConnectorsAsync(const ListVoiceConnectorsRequest & request,const ListVoiceConnectorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5125 void ChimeClient::ListVoiceConnectorsAsync(const ListVoiceConnectorsRequest& request, const ListVoiceConnectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5126 {
5127 m_executor->Submit( [this, request, handler, context](){ this->ListVoiceConnectorsAsyncHelper( request, handler, context ); } );
5128 }
5129
ListVoiceConnectorsAsyncHelper(const ListVoiceConnectorsRequest & request,const ListVoiceConnectorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5130 void ChimeClient::ListVoiceConnectorsAsyncHelper(const ListVoiceConnectorsRequest& request, const ListVoiceConnectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5131 {
5132 handler(this, request, ListVoiceConnectors(request), context);
5133 }
5134
LogoutUser(const LogoutUserRequest & request) const5135 LogoutUserOutcome ChimeClient::LogoutUser(const LogoutUserRequest& request) const
5136 {
5137 if (!request.AccountIdHasBeenSet())
5138 {
5139 AWS_LOGSTREAM_ERROR("LogoutUser", "Required field: AccountId, is not set");
5140 return LogoutUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
5141 }
5142 if (!request.UserIdHasBeenSet())
5143 {
5144 AWS_LOGSTREAM_ERROR("LogoutUser", "Required field: UserId, is not set");
5145 return LogoutUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
5146 }
5147 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5148 Aws::StringStream ss;
5149 uri.AddPathSegments("/accounts/");
5150 uri.AddPathSegment(request.GetAccountId());
5151 uri.AddPathSegments("/users/");
5152 uri.AddPathSegment(request.GetUserId());
5153 ss.str("?operation=logout");
5154 uri.SetQueryString(ss.str());
5155 return LogoutUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5156 }
5157
LogoutUserCallable(const LogoutUserRequest & request) const5158 LogoutUserOutcomeCallable ChimeClient::LogoutUserCallable(const LogoutUserRequest& request) const
5159 {
5160 auto task = Aws::MakeShared< std::packaged_task< LogoutUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->LogoutUser(request); } );
5161 auto packagedFunction = [task]() { (*task)(); };
5162 m_executor->Submit(packagedFunction);
5163 return task->get_future();
5164 }
5165
LogoutUserAsync(const LogoutUserRequest & request,const LogoutUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5166 void ChimeClient::LogoutUserAsync(const LogoutUserRequest& request, const LogoutUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5167 {
5168 m_executor->Submit( [this, request, handler, context](){ this->LogoutUserAsyncHelper( request, handler, context ); } );
5169 }
5170
LogoutUserAsyncHelper(const LogoutUserRequest & request,const LogoutUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5171 void ChimeClient::LogoutUserAsyncHelper(const LogoutUserRequest& request, const LogoutUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5172 {
5173 handler(this, request, LogoutUser(request), context);
5174 }
5175
PutAppInstanceRetentionSettings(const PutAppInstanceRetentionSettingsRequest & request) const5176 PutAppInstanceRetentionSettingsOutcome ChimeClient::PutAppInstanceRetentionSettings(const PutAppInstanceRetentionSettingsRequest& request) const
5177 {
5178 if (!request.AppInstanceArnHasBeenSet())
5179 {
5180 AWS_LOGSTREAM_ERROR("PutAppInstanceRetentionSettings", "Required field: AppInstanceArn, is not set");
5181 return PutAppInstanceRetentionSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
5182 }
5183 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5184 if (m_enableHostPrefixInjection)
5185 {
5186 uri.SetAuthority("identity-" + uri.GetAuthority());
5187 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
5188 {
5189 AWS_LOGSTREAM_ERROR("PutAppInstanceRetentionSettings", "Invalid DNS host: " << uri.GetAuthority());
5190 return PutAppInstanceRetentionSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
5191 }
5192 }
5193 uri.AddPathSegments("/app-instances/");
5194 uri.AddPathSegment(request.GetAppInstanceArn());
5195 uri.AddPathSegments("/retention-settings");
5196 return PutAppInstanceRetentionSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5197 }
5198
PutAppInstanceRetentionSettingsCallable(const PutAppInstanceRetentionSettingsRequest & request) const5199 PutAppInstanceRetentionSettingsOutcomeCallable ChimeClient::PutAppInstanceRetentionSettingsCallable(const PutAppInstanceRetentionSettingsRequest& request) const
5200 {
5201 auto task = Aws::MakeShared< std::packaged_task< PutAppInstanceRetentionSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutAppInstanceRetentionSettings(request); } );
5202 auto packagedFunction = [task]() { (*task)(); };
5203 m_executor->Submit(packagedFunction);
5204 return task->get_future();
5205 }
5206
PutAppInstanceRetentionSettingsAsync(const PutAppInstanceRetentionSettingsRequest & request,const PutAppInstanceRetentionSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5207 void ChimeClient::PutAppInstanceRetentionSettingsAsync(const PutAppInstanceRetentionSettingsRequest& request, const PutAppInstanceRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5208 {
5209 m_executor->Submit( [this, request, handler, context](){ this->PutAppInstanceRetentionSettingsAsyncHelper( request, handler, context ); } );
5210 }
5211
PutAppInstanceRetentionSettingsAsyncHelper(const PutAppInstanceRetentionSettingsRequest & request,const PutAppInstanceRetentionSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5212 void ChimeClient::PutAppInstanceRetentionSettingsAsyncHelper(const PutAppInstanceRetentionSettingsRequest& request, const PutAppInstanceRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5213 {
5214 handler(this, request, PutAppInstanceRetentionSettings(request), context);
5215 }
5216
PutAppInstanceStreamingConfigurations(const PutAppInstanceStreamingConfigurationsRequest & request) const5217 PutAppInstanceStreamingConfigurationsOutcome ChimeClient::PutAppInstanceStreamingConfigurations(const PutAppInstanceStreamingConfigurationsRequest& request) const
5218 {
5219 if (!request.AppInstanceArnHasBeenSet())
5220 {
5221 AWS_LOGSTREAM_ERROR("PutAppInstanceStreamingConfigurations", "Required field: AppInstanceArn, is not set");
5222 return PutAppInstanceStreamingConfigurationsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
5223 }
5224 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5225 uri.AddPathSegments("/app-instances/");
5226 uri.AddPathSegment(request.GetAppInstanceArn());
5227 uri.AddPathSegments("/streaming-configurations");
5228 return PutAppInstanceStreamingConfigurationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5229 }
5230
PutAppInstanceStreamingConfigurationsCallable(const PutAppInstanceStreamingConfigurationsRequest & request) const5231 PutAppInstanceStreamingConfigurationsOutcomeCallable ChimeClient::PutAppInstanceStreamingConfigurationsCallable(const PutAppInstanceStreamingConfigurationsRequest& request) const
5232 {
5233 auto task = Aws::MakeShared< std::packaged_task< PutAppInstanceStreamingConfigurationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutAppInstanceStreamingConfigurations(request); } );
5234 auto packagedFunction = [task]() { (*task)(); };
5235 m_executor->Submit(packagedFunction);
5236 return task->get_future();
5237 }
5238
PutAppInstanceStreamingConfigurationsAsync(const PutAppInstanceStreamingConfigurationsRequest & request,const PutAppInstanceStreamingConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5239 void ChimeClient::PutAppInstanceStreamingConfigurationsAsync(const PutAppInstanceStreamingConfigurationsRequest& request, const PutAppInstanceStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5240 {
5241 m_executor->Submit( [this, request, handler, context](){ this->PutAppInstanceStreamingConfigurationsAsyncHelper( request, handler, context ); } );
5242 }
5243
PutAppInstanceStreamingConfigurationsAsyncHelper(const PutAppInstanceStreamingConfigurationsRequest & request,const PutAppInstanceStreamingConfigurationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5244 void ChimeClient::PutAppInstanceStreamingConfigurationsAsyncHelper(const PutAppInstanceStreamingConfigurationsRequest& request, const PutAppInstanceStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5245 {
5246 handler(this, request, PutAppInstanceStreamingConfigurations(request), context);
5247 }
5248
PutEventsConfiguration(const PutEventsConfigurationRequest & request) const5249 PutEventsConfigurationOutcome ChimeClient::PutEventsConfiguration(const PutEventsConfigurationRequest& request) const
5250 {
5251 if (!request.AccountIdHasBeenSet())
5252 {
5253 AWS_LOGSTREAM_ERROR("PutEventsConfiguration", "Required field: AccountId, is not set");
5254 return PutEventsConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
5255 }
5256 if (!request.BotIdHasBeenSet())
5257 {
5258 AWS_LOGSTREAM_ERROR("PutEventsConfiguration", "Required field: BotId, is not set");
5259 return PutEventsConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [BotId]", false));
5260 }
5261 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5262 uri.AddPathSegments("/accounts/");
5263 uri.AddPathSegment(request.GetAccountId());
5264 uri.AddPathSegments("/bots/");
5265 uri.AddPathSegment(request.GetBotId());
5266 uri.AddPathSegments("/events-configuration");
5267 return PutEventsConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5268 }
5269
PutEventsConfigurationCallable(const PutEventsConfigurationRequest & request) const5270 PutEventsConfigurationOutcomeCallable ChimeClient::PutEventsConfigurationCallable(const PutEventsConfigurationRequest& request) const
5271 {
5272 auto task = Aws::MakeShared< std::packaged_task< PutEventsConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutEventsConfiguration(request); } );
5273 auto packagedFunction = [task]() { (*task)(); };
5274 m_executor->Submit(packagedFunction);
5275 return task->get_future();
5276 }
5277
PutEventsConfigurationAsync(const PutEventsConfigurationRequest & request,const PutEventsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5278 void ChimeClient::PutEventsConfigurationAsync(const PutEventsConfigurationRequest& request, const PutEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5279 {
5280 m_executor->Submit( [this, request, handler, context](){ this->PutEventsConfigurationAsyncHelper( request, handler, context ); } );
5281 }
5282
PutEventsConfigurationAsyncHelper(const PutEventsConfigurationRequest & request,const PutEventsConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5283 void ChimeClient::PutEventsConfigurationAsyncHelper(const PutEventsConfigurationRequest& request, const PutEventsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5284 {
5285 handler(this, request, PutEventsConfiguration(request), context);
5286 }
5287
PutRetentionSettings(const PutRetentionSettingsRequest & request) const5288 PutRetentionSettingsOutcome ChimeClient::PutRetentionSettings(const PutRetentionSettingsRequest& request) const
5289 {
5290 if (!request.AccountIdHasBeenSet())
5291 {
5292 AWS_LOGSTREAM_ERROR("PutRetentionSettings", "Required field: AccountId, is not set");
5293 return PutRetentionSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
5294 }
5295 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5296 uri.AddPathSegments("/accounts/");
5297 uri.AddPathSegment(request.GetAccountId());
5298 uri.AddPathSegments("/retention-settings");
5299 return PutRetentionSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5300 }
5301
PutRetentionSettingsCallable(const PutRetentionSettingsRequest & request) const5302 PutRetentionSettingsOutcomeCallable ChimeClient::PutRetentionSettingsCallable(const PutRetentionSettingsRequest& request) const
5303 {
5304 auto task = Aws::MakeShared< std::packaged_task< PutRetentionSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutRetentionSettings(request); } );
5305 auto packagedFunction = [task]() { (*task)(); };
5306 m_executor->Submit(packagedFunction);
5307 return task->get_future();
5308 }
5309
PutRetentionSettingsAsync(const PutRetentionSettingsRequest & request,const PutRetentionSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5310 void ChimeClient::PutRetentionSettingsAsync(const PutRetentionSettingsRequest& request, const PutRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5311 {
5312 m_executor->Submit( [this, request, handler, context](){ this->PutRetentionSettingsAsyncHelper( request, handler, context ); } );
5313 }
5314
PutRetentionSettingsAsyncHelper(const PutRetentionSettingsRequest & request,const PutRetentionSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5315 void ChimeClient::PutRetentionSettingsAsyncHelper(const PutRetentionSettingsRequest& request, const PutRetentionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5316 {
5317 handler(this, request, PutRetentionSettings(request), context);
5318 }
5319
PutSipMediaApplicationLoggingConfiguration(const PutSipMediaApplicationLoggingConfigurationRequest & request) const5320 PutSipMediaApplicationLoggingConfigurationOutcome ChimeClient::PutSipMediaApplicationLoggingConfiguration(const PutSipMediaApplicationLoggingConfigurationRequest& request) const
5321 {
5322 if (!request.SipMediaApplicationIdHasBeenSet())
5323 {
5324 AWS_LOGSTREAM_ERROR("PutSipMediaApplicationLoggingConfiguration", "Required field: SipMediaApplicationId, is not set");
5325 return PutSipMediaApplicationLoggingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipMediaApplicationId]", false));
5326 }
5327 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5328 uri.AddPathSegments("/sip-media-applications/");
5329 uri.AddPathSegment(request.GetSipMediaApplicationId());
5330 uri.AddPathSegments("/logging-configuration");
5331 return PutSipMediaApplicationLoggingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5332 }
5333
PutSipMediaApplicationLoggingConfigurationCallable(const PutSipMediaApplicationLoggingConfigurationRequest & request) const5334 PutSipMediaApplicationLoggingConfigurationOutcomeCallable ChimeClient::PutSipMediaApplicationLoggingConfigurationCallable(const PutSipMediaApplicationLoggingConfigurationRequest& request) const
5335 {
5336 auto task = Aws::MakeShared< std::packaged_task< PutSipMediaApplicationLoggingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutSipMediaApplicationLoggingConfiguration(request); } );
5337 auto packagedFunction = [task]() { (*task)(); };
5338 m_executor->Submit(packagedFunction);
5339 return task->get_future();
5340 }
5341
PutSipMediaApplicationLoggingConfigurationAsync(const PutSipMediaApplicationLoggingConfigurationRequest & request,const PutSipMediaApplicationLoggingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5342 void ChimeClient::PutSipMediaApplicationLoggingConfigurationAsync(const PutSipMediaApplicationLoggingConfigurationRequest& request, const PutSipMediaApplicationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5343 {
5344 m_executor->Submit( [this, request, handler, context](){ this->PutSipMediaApplicationLoggingConfigurationAsyncHelper( request, handler, context ); } );
5345 }
5346
PutSipMediaApplicationLoggingConfigurationAsyncHelper(const PutSipMediaApplicationLoggingConfigurationRequest & request,const PutSipMediaApplicationLoggingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5347 void ChimeClient::PutSipMediaApplicationLoggingConfigurationAsyncHelper(const PutSipMediaApplicationLoggingConfigurationRequest& request, const PutSipMediaApplicationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5348 {
5349 handler(this, request, PutSipMediaApplicationLoggingConfiguration(request), context);
5350 }
5351
PutVoiceConnectorEmergencyCallingConfiguration(const PutVoiceConnectorEmergencyCallingConfigurationRequest & request) const5352 PutVoiceConnectorEmergencyCallingConfigurationOutcome ChimeClient::PutVoiceConnectorEmergencyCallingConfiguration(const PutVoiceConnectorEmergencyCallingConfigurationRequest& request) const
5353 {
5354 if (!request.VoiceConnectorIdHasBeenSet())
5355 {
5356 AWS_LOGSTREAM_ERROR("PutVoiceConnectorEmergencyCallingConfiguration", "Required field: VoiceConnectorId, is not set");
5357 return PutVoiceConnectorEmergencyCallingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
5358 }
5359 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5360 uri.AddPathSegments("/voice-connectors/");
5361 uri.AddPathSegment(request.GetVoiceConnectorId());
5362 uri.AddPathSegments("/emergency-calling-configuration");
5363 return PutVoiceConnectorEmergencyCallingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5364 }
5365
PutVoiceConnectorEmergencyCallingConfigurationCallable(const PutVoiceConnectorEmergencyCallingConfigurationRequest & request) const5366 PutVoiceConnectorEmergencyCallingConfigurationOutcomeCallable ChimeClient::PutVoiceConnectorEmergencyCallingConfigurationCallable(const PutVoiceConnectorEmergencyCallingConfigurationRequest& request) const
5367 {
5368 auto task = Aws::MakeShared< std::packaged_task< PutVoiceConnectorEmergencyCallingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutVoiceConnectorEmergencyCallingConfiguration(request); } );
5369 auto packagedFunction = [task]() { (*task)(); };
5370 m_executor->Submit(packagedFunction);
5371 return task->get_future();
5372 }
5373
PutVoiceConnectorEmergencyCallingConfigurationAsync(const PutVoiceConnectorEmergencyCallingConfigurationRequest & request,const PutVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5374 void ChimeClient::PutVoiceConnectorEmergencyCallingConfigurationAsync(const PutVoiceConnectorEmergencyCallingConfigurationRequest& request, const PutVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5375 {
5376 m_executor->Submit( [this, request, handler, context](){ this->PutVoiceConnectorEmergencyCallingConfigurationAsyncHelper( request, handler, context ); } );
5377 }
5378
PutVoiceConnectorEmergencyCallingConfigurationAsyncHelper(const PutVoiceConnectorEmergencyCallingConfigurationRequest & request,const PutVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5379 void ChimeClient::PutVoiceConnectorEmergencyCallingConfigurationAsyncHelper(const PutVoiceConnectorEmergencyCallingConfigurationRequest& request, const PutVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5380 {
5381 handler(this, request, PutVoiceConnectorEmergencyCallingConfiguration(request), context);
5382 }
5383
PutVoiceConnectorLoggingConfiguration(const PutVoiceConnectorLoggingConfigurationRequest & request) const5384 PutVoiceConnectorLoggingConfigurationOutcome ChimeClient::PutVoiceConnectorLoggingConfiguration(const PutVoiceConnectorLoggingConfigurationRequest& request) const
5385 {
5386 if (!request.VoiceConnectorIdHasBeenSet())
5387 {
5388 AWS_LOGSTREAM_ERROR("PutVoiceConnectorLoggingConfiguration", "Required field: VoiceConnectorId, is not set");
5389 return PutVoiceConnectorLoggingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
5390 }
5391 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5392 uri.AddPathSegments("/voice-connectors/");
5393 uri.AddPathSegment(request.GetVoiceConnectorId());
5394 uri.AddPathSegments("/logging-configuration");
5395 return PutVoiceConnectorLoggingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5396 }
5397
PutVoiceConnectorLoggingConfigurationCallable(const PutVoiceConnectorLoggingConfigurationRequest & request) const5398 PutVoiceConnectorLoggingConfigurationOutcomeCallable ChimeClient::PutVoiceConnectorLoggingConfigurationCallable(const PutVoiceConnectorLoggingConfigurationRequest& request) const
5399 {
5400 auto task = Aws::MakeShared< std::packaged_task< PutVoiceConnectorLoggingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutVoiceConnectorLoggingConfiguration(request); } );
5401 auto packagedFunction = [task]() { (*task)(); };
5402 m_executor->Submit(packagedFunction);
5403 return task->get_future();
5404 }
5405
PutVoiceConnectorLoggingConfigurationAsync(const PutVoiceConnectorLoggingConfigurationRequest & request,const PutVoiceConnectorLoggingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5406 void ChimeClient::PutVoiceConnectorLoggingConfigurationAsync(const PutVoiceConnectorLoggingConfigurationRequest& request, const PutVoiceConnectorLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5407 {
5408 m_executor->Submit( [this, request, handler, context](){ this->PutVoiceConnectorLoggingConfigurationAsyncHelper( request, handler, context ); } );
5409 }
5410
PutVoiceConnectorLoggingConfigurationAsyncHelper(const PutVoiceConnectorLoggingConfigurationRequest & request,const PutVoiceConnectorLoggingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5411 void ChimeClient::PutVoiceConnectorLoggingConfigurationAsyncHelper(const PutVoiceConnectorLoggingConfigurationRequest& request, const PutVoiceConnectorLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5412 {
5413 handler(this, request, PutVoiceConnectorLoggingConfiguration(request), context);
5414 }
5415
PutVoiceConnectorOrigination(const PutVoiceConnectorOriginationRequest & request) const5416 PutVoiceConnectorOriginationOutcome ChimeClient::PutVoiceConnectorOrigination(const PutVoiceConnectorOriginationRequest& request) const
5417 {
5418 if (!request.VoiceConnectorIdHasBeenSet())
5419 {
5420 AWS_LOGSTREAM_ERROR("PutVoiceConnectorOrigination", "Required field: VoiceConnectorId, is not set");
5421 return PutVoiceConnectorOriginationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
5422 }
5423 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5424 uri.AddPathSegments("/voice-connectors/");
5425 uri.AddPathSegment(request.GetVoiceConnectorId());
5426 uri.AddPathSegments("/origination");
5427 return PutVoiceConnectorOriginationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5428 }
5429
PutVoiceConnectorOriginationCallable(const PutVoiceConnectorOriginationRequest & request) const5430 PutVoiceConnectorOriginationOutcomeCallable ChimeClient::PutVoiceConnectorOriginationCallable(const PutVoiceConnectorOriginationRequest& request) const
5431 {
5432 auto task = Aws::MakeShared< std::packaged_task< PutVoiceConnectorOriginationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutVoiceConnectorOrigination(request); } );
5433 auto packagedFunction = [task]() { (*task)(); };
5434 m_executor->Submit(packagedFunction);
5435 return task->get_future();
5436 }
5437
PutVoiceConnectorOriginationAsync(const PutVoiceConnectorOriginationRequest & request,const PutVoiceConnectorOriginationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5438 void ChimeClient::PutVoiceConnectorOriginationAsync(const PutVoiceConnectorOriginationRequest& request, const PutVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5439 {
5440 m_executor->Submit( [this, request, handler, context](){ this->PutVoiceConnectorOriginationAsyncHelper( request, handler, context ); } );
5441 }
5442
PutVoiceConnectorOriginationAsyncHelper(const PutVoiceConnectorOriginationRequest & request,const PutVoiceConnectorOriginationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5443 void ChimeClient::PutVoiceConnectorOriginationAsyncHelper(const PutVoiceConnectorOriginationRequest& request, const PutVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5444 {
5445 handler(this, request, PutVoiceConnectorOrigination(request), context);
5446 }
5447
PutVoiceConnectorProxy(const PutVoiceConnectorProxyRequest & request) const5448 PutVoiceConnectorProxyOutcome ChimeClient::PutVoiceConnectorProxy(const PutVoiceConnectorProxyRequest& request) const
5449 {
5450 if (!request.VoiceConnectorIdHasBeenSet())
5451 {
5452 AWS_LOGSTREAM_ERROR("PutVoiceConnectorProxy", "Required field: VoiceConnectorId, is not set");
5453 return PutVoiceConnectorProxyOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
5454 }
5455 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5456 uri.AddPathSegments("/voice-connectors/");
5457 uri.AddPathSegment(request.GetVoiceConnectorId());
5458 uri.AddPathSegments("/programmable-numbers/proxy");
5459 return PutVoiceConnectorProxyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5460 }
5461
PutVoiceConnectorProxyCallable(const PutVoiceConnectorProxyRequest & request) const5462 PutVoiceConnectorProxyOutcomeCallable ChimeClient::PutVoiceConnectorProxyCallable(const PutVoiceConnectorProxyRequest& request) const
5463 {
5464 auto task = Aws::MakeShared< std::packaged_task< PutVoiceConnectorProxyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutVoiceConnectorProxy(request); } );
5465 auto packagedFunction = [task]() { (*task)(); };
5466 m_executor->Submit(packagedFunction);
5467 return task->get_future();
5468 }
5469
PutVoiceConnectorProxyAsync(const PutVoiceConnectorProxyRequest & request,const PutVoiceConnectorProxyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5470 void ChimeClient::PutVoiceConnectorProxyAsync(const PutVoiceConnectorProxyRequest& request, const PutVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5471 {
5472 m_executor->Submit( [this, request, handler, context](){ this->PutVoiceConnectorProxyAsyncHelper( request, handler, context ); } );
5473 }
5474
PutVoiceConnectorProxyAsyncHelper(const PutVoiceConnectorProxyRequest & request,const PutVoiceConnectorProxyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5475 void ChimeClient::PutVoiceConnectorProxyAsyncHelper(const PutVoiceConnectorProxyRequest& request, const PutVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5476 {
5477 handler(this, request, PutVoiceConnectorProxy(request), context);
5478 }
5479
PutVoiceConnectorStreamingConfiguration(const PutVoiceConnectorStreamingConfigurationRequest & request) const5480 PutVoiceConnectorStreamingConfigurationOutcome ChimeClient::PutVoiceConnectorStreamingConfiguration(const PutVoiceConnectorStreamingConfigurationRequest& request) const
5481 {
5482 if (!request.VoiceConnectorIdHasBeenSet())
5483 {
5484 AWS_LOGSTREAM_ERROR("PutVoiceConnectorStreamingConfiguration", "Required field: VoiceConnectorId, is not set");
5485 return PutVoiceConnectorStreamingConfigurationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
5486 }
5487 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5488 uri.AddPathSegments("/voice-connectors/");
5489 uri.AddPathSegment(request.GetVoiceConnectorId());
5490 uri.AddPathSegments("/streaming-configuration");
5491 return PutVoiceConnectorStreamingConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5492 }
5493
PutVoiceConnectorStreamingConfigurationCallable(const PutVoiceConnectorStreamingConfigurationRequest & request) const5494 PutVoiceConnectorStreamingConfigurationOutcomeCallable ChimeClient::PutVoiceConnectorStreamingConfigurationCallable(const PutVoiceConnectorStreamingConfigurationRequest& request) const
5495 {
5496 auto task = Aws::MakeShared< std::packaged_task< PutVoiceConnectorStreamingConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutVoiceConnectorStreamingConfiguration(request); } );
5497 auto packagedFunction = [task]() { (*task)(); };
5498 m_executor->Submit(packagedFunction);
5499 return task->get_future();
5500 }
5501
PutVoiceConnectorStreamingConfigurationAsync(const PutVoiceConnectorStreamingConfigurationRequest & request,const PutVoiceConnectorStreamingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5502 void ChimeClient::PutVoiceConnectorStreamingConfigurationAsync(const PutVoiceConnectorStreamingConfigurationRequest& request, const PutVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5503 {
5504 m_executor->Submit( [this, request, handler, context](){ this->PutVoiceConnectorStreamingConfigurationAsyncHelper( request, handler, context ); } );
5505 }
5506
PutVoiceConnectorStreamingConfigurationAsyncHelper(const PutVoiceConnectorStreamingConfigurationRequest & request,const PutVoiceConnectorStreamingConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5507 void ChimeClient::PutVoiceConnectorStreamingConfigurationAsyncHelper(const PutVoiceConnectorStreamingConfigurationRequest& request, const PutVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5508 {
5509 handler(this, request, PutVoiceConnectorStreamingConfiguration(request), context);
5510 }
5511
PutVoiceConnectorTermination(const PutVoiceConnectorTerminationRequest & request) const5512 PutVoiceConnectorTerminationOutcome ChimeClient::PutVoiceConnectorTermination(const PutVoiceConnectorTerminationRequest& request) const
5513 {
5514 if (!request.VoiceConnectorIdHasBeenSet())
5515 {
5516 AWS_LOGSTREAM_ERROR("PutVoiceConnectorTermination", "Required field: VoiceConnectorId, is not set");
5517 return PutVoiceConnectorTerminationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
5518 }
5519 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5520 uri.AddPathSegments("/voice-connectors/");
5521 uri.AddPathSegment(request.GetVoiceConnectorId());
5522 uri.AddPathSegments("/termination");
5523 return PutVoiceConnectorTerminationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
5524 }
5525
PutVoiceConnectorTerminationCallable(const PutVoiceConnectorTerminationRequest & request) const5526 PutVoiceConnectorTerminationOutcomeCallable ChimeClient::PutVoiceConnectorTerminationCallable(const PutVoiceConnectorTerminationRequest& request) const
5527 {
5528 auto task = Aws::MakeShared< std::packaged_task< PutVoiceConnectorTerminationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutVoiceConnectorTermination(request); } );
5529 auto packagedFunction = [task]() { (*task)(); };
5530 m_executor->Submit(packagedFunction);
5531 return task->get_future();
5532 }
5533
PutVoiceConnectorTerminationAsync(const PutVoiceConnectorTerminationRequest & request,const PutVoiceConnectorTerminationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5534 void ChimeClient::PutVoiceConnectorTerminationAsync(const PutVoiceConnectorTerminationRequest& request, const PutVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5535 {
5536 m_executor->Submit( [this, request, handler, context](){ this->PutVoiceConnectorTerminationAsyncHelper( request, handler, context ); } );
5537 }
5538
PutVoiceConnectorTerminationAsyncHelper(const PutVoiceConnectorTerminationRequest & request,const PutVoiceConnectorTerminationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5539 void ChimeClient::PutVoiceConnectorTerminationAsyncHelper(const PutVoiceConnectorTerminationRequest& request, const PutVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5540 {
5541 handler(this, request, PutVoiceConnectorTermination(request), context);
5542 }
5543
PutVoiceConnectorTerminationCredentials(const PutVoiceConnectorTerminationCredentialsRequest & request) const5544 PutVoiceConnectorTerminationCredentialsOutcome ChimeClient::PutVoiceConnectorTerminationCredentials(const PutVoiceConnectorTerminationCredentialsRequest& request) const
5545 {
5546 if (!request.VoiceConnectorIdHasBeenSet())
5547 {
5548 AWS_LOGSTREAM_ERROR("PutVoiceConnectorTerminationCredentials", "Required field: VoiceConnectorId, is not set");
5549 return PutVoiceConnectorTerminationCredentialsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
5550 }
5551 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5552 Aws::StringStream ss;
5553 uri.AddPathSegments("/voice-connectors/");
5554 uri.AddPathSegment(request.GetVoiceConnectorId());
5555 uri.AddPathSegments("/termination/credentials");
5556 ss.str("?operation=put");
5557 uri.SetQueryString(ss.str());
5558 return PutVoiceConnectorTerminationCredentialsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5559 }
5560
PutVoiceConnectorTerminationCredentialsCallable(const PutVoiceConnectorTerminationCredentialsRequest & request) const5561 PutVoiceConnectorTerminationCredentialsOutcomeCallable ChimeClient::PutVoiceConnectorTerminationCredentialsCallable(const PutVoiceConnectorTerminationCredentialsRequest& request) const
5562 {
5563 auto task = Aws::MakeShared< std::packaged_task< PutVoiceConnectorTerminationCredentialsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutVoiceConnectorTerminationCredentials(request); } );
5564 auto packagedFunction = [task]() { (*task)(); };
5565 m_executor->Submit(packagedFunction);
5566 return task->get_future();
5567 }
5568
PutVoiceConnectorTerminationCredentialsAsync(const PutVoiceConnectorTerminationCredentialsRequest & request,const PutVoiceConnectorTerminationCredentialsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5569 void ChimeClient::PutVoiceConnectorTerminationCredentialsAsync(const PutVoiceConnectorTerminationCredentialsRequest& request, const PutVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5570 {
5571 m_executor->Submit( [this, request, handler, context](){ this->PutVoiceConnectorTerminationCredentialsAsyncHelper( request, handler, context ); } );
5572 }
5573
PutVoiceConnectorTerminationCredentialsAsyncHelper(const PutVoiceConnectorTerminationCredentialsRequest & request,const PutVoiceConnectorTerminationCredentialsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5574 void ChimeClient::PutVoiceConnectorTerminationCredentialsAsyncHelper(const PutVoiceConnectorTerminationCredentialsRequest& request, const PutVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5575 {
5576 handler(this, request, PutVoiceConnectorTerminationCredentials(request), context);
5577 }
5578
RedactChannelMessage(const RedactChannelMessageRequest & request) const5579 RedactChannelMessageOutcome ChimeClient::RedactChannelMessage(const RedactChannelMessageRequest& request) const
5580 {
5581 if (!request.ChannelArnHasBeenSet())
5582 {
5583 AWS_LOGSTREAM_ERROR("RedactChannelMessage", "Required field: ChannelArn, is not set");
5584 return RedactChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
5585 }
5586 if (!request.MessageIdHasBeenSet())
5587 {
5588 AWS_LOGSTREAM_ERROR("RedactChannelMessage", "Required field: MessageId, is not set");
5589 return RedactChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MessageId]", false));
5590 }
5591 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5592 if (m_enableHostPrefixInjection)
5593 {
5594 uri.SetAuthority("messaging-" + uri.GetAuthority());
5595 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
5596 {
5597 AWS_LOGSTREAM_ERROR("RedactChannelMessage", "Invalid DNS host: " << uri.GetAuthority());
5598 return RedactChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
5599 }
5600 }
5601 Aws::StringStream ss;
5602 uri.AddPathSegments("/channels/");
5603 uri.AddPathSegment(request.GetChannelArn());
5604 uri.AddPathSegments("/messages/");
5605 uri.AddPathSegment(request.GetMessageId());
5606 ss.str("?operation=redact");
5607 uri.SetQueryString(ss.str());
5608 return RedactChannelMessageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5609 }
5610
RedactChannelMessageCallable(const RedactChannelMessageRequest & request) const5611 RedactChannelMessageOutcomeCallable ChimeClient::RedactChannelMessageCallable(const RedactChannelMessageRequest& request) const
5612 {
5613 auto task = Aws::MakeShared< std::packaged_task< RedactChannelMessageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RedactChannelMessage(request); } );
5614 auto packagedFunction = [task]() { (*task)(); };
5615 m_executor->Submit(packagedFunction);
5616 return task->get_future();
5617 }
5618
RedactChannelMessageAsync(const RedactChannelMessageRequest & request,const RedactChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5619 void ChimeClient::RedactChannelMessageAsync(const RedactChannelMessageRequest& request, const RedactChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5620 {
5621 m_executor->Submit( [this, request, handler, context](){ this->RedactChannelMessageAsyncHelper( request, handler, context ); } );
5622 }
5623
RedactChannelMessageAsyncHelper(const RedactChannelMessageRequest & request,const RedactChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5624 void ChimeClient::RedactChannelMessageAsyncHelper(const RedactChannelMessageRequest& request, const RedactChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5625 {
5626 handler(this, request, RedactChannelMessage(request), context);
5627 }
5628
RedactConversationMessage(const RedactConversationMessageRequest & request) const5629 RedactConversationMessageOutcome ChimeClient::RedactConversationMessage(const RedactConversationMessageRequest& request) const
5630 {
5631 if (!request.AccountIdHasBeenSet())
5632 {
5633 AWS_LOGSTREAM_ERROR("RedactConversationMessage", "Required field: AccountId, is not set");
5634 return RedactConversationMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
5635 }
5636 if (!request.ConversationIdHasBeenSet())
5637 {
5638 AWS_LOGSTREAM_ERROR("RedactConversationMessage", "Required field: ConversationId, is not set");
5639 return RedactConversationMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConversationId]", false));
5640 }
5641 if (!request.MessageIdHasBeenSet())
5642 {
5643 AWS_LOGSTREAM_ERROR("RedactConversationMessage", "Required field: MessageId, is not set");
5644 return RedactConversationMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MessageId]", false));
5645 }
5646 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5647 Aws::StringStream ss;
5648 uri.AddPathSegments("/accounts/");
5649 uri.AddPathSegment(request.GetAccountId());
5650 uri.AddPathSegments("/conversations/");
5651 uri.AddPathSegment(request.GetConversationId());
5652 uri.AddPathSegments("/messages/");
5653 uri.AddPathSegment(request.GetMessageId());
5654 ss.str("?operation=redact");
5655 uri.SetQueryString(ss.str());
5656 return RedactConversationMessageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5657 }
5658
RedactConversationMessageCallable(const RedactConversationMessageRequest & request) const5659 RedactConversationMessageOutcomeCallable ChimeClient::RedactConversationMessageCallable(const RedactConversationMessageRequest& request) const
5660 {
5661 auto task = Aws::MakeShared< std::packaged_task< RedactConversationMessageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RedactConversationMessage(request); } );
5662 auto packagedFunction = [task]() { (*task)(); };
5663 m_executor->Submit(packagedFunction);
5664 return task->get_future();
5665 }
5666
RedactConversationMessageAsync(const RedactConversationMessageRequest & request,const RedactConversationMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5667 void ChimeClient::RedactConversationMessageAsync(const RedactConversationMessageRequest& request, const RedactConversationMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5668 {
5669 m_executor->Submit( [this, request, handler, context](){ this->RedactConversationMessageAsyncHelper( request, handler, context ); } );
5670 }
5671
RedactConversationMessageAsyncHelper(const RedactConversationMessageRequest & request,const RedactConversationMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5672 void ChimeClient::RedactConversationMessageAsyncHelper(const RedactConversationMessageRequest& request, const RedactConversationMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5673 {
5674 handler(this, request, RedactConversationMessage(request), context);
5675 }
5676
RedactRoomMessage(const RedactRoomMessageRequest & request) const5677 RedactRoomMessageOutcome ChimeClient::RedactRoomMessage(const RedactRoomMessageRequest& request) const
5678 {
5679 if (!request.AccountIdHasBeenSet())
5680 {
5681 AWS_LOGSTREAM_ERROR("RedactRoomMessage", "Required field: AccountId, is not set");
5682 return RedactRoomMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
5683 }
5684 if (!request.RoomIdHasBeenSet())
5685 {
5686 AWS_LOGSTREAM_ERROR("RedactRoomMessage", "Required field: RoomId, is not set");
5687 return RedactRoomMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
5688 }
5689 if (!request.MessageIdHasBeenSet())
5690 {
5691 AWS_LOGSTREAM_ERROR("RedactRoomMessage", "Required field: MessageId, is not set");
5692 return RedactRoomMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MessageId]", false));
5693 }
5694 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5695 Aws::StringStream ss;
5696 uri.AddPathSegments("/accounts/");
5697 uri.AddPathSegment(request.GetAccountId());
5698 uri.AddPathSegments("/rooms/");
5699 uri.AddPathSegment(request.GetRoomId());
5700 uri.AddPathSegments("/messages/");
5701 uri.AddPathSegment(request.GetMessageId());
5702 ss.str("?operation=redact");
5703 uri.SetQueryString(ss.str());
5704 return RedactRoomMessageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5705 }
5706
RedactRoomMessageCallable(const RedactRoomMessageRequest & request) const5707 RedactRoomMessageOutcomeCallable ChimeClient::RedactRoomMessageCallable(const RedactRoomMessageRequest& request) const
5708 {
5709 auto task = Aws::MakeShared< std::packaged_task< RedactRoomMessageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RedactRoomMessage(request); } );
5710 auto packagedFunction = [task]() { (*task)(); };
5711 m_executor->Submit(packagedFunction);
5712 return task->get_future();
5713 }
5714
RedactRoomMessageAsync(const RedactRoomMessageRequest & request,const RedactRoomMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5715 void ChimeClient::RedactRoomMessageAsync(const RedactRoomMessageRequest& request, const RedactRoomMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5716 {
5717 m_executor->Submit( [this, request, handler, context](){ this->RedactRoomMessageAsyncHelper( request, handler, context ); } );
5718 }
5719
RedactRoomMessageAsyncHelper(const RedactRoomMessageRequest & request,const RedactRoomMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5720 void ChimeClient::RedactRoomMessageAsyncHelper(const RedactRoomMessageRequest& request, const RedactRoomMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5721 {
5722 handler(this, request, RedactRoomMessage(request), context);
5723 }
5724
RegenerateSecurityToken(const RegenerateSecurityTokenRequest & request) const5725 RegenerateSecurityTokenOutcome ChimeClient::RegenerateSecurityToken(const RegenerateSecurityTokenRequest& request) const
5726 {
5727 if (!request.AccountIdHasBeenSet())
5728 {
5729 AWS_LOGSTREAM_ERROR("RegenerateSecurityToken", "Required field: AccountId, is not set");
5730 return RegenerateSecurityTokenOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
5731 }
5732 if (!request.BotIdHasBeenSet())
5733 {
5734 AWS_LOGSTREAM_ERROR("RegenerateSecurityToken", "Required field: BotId, is not set");
5735 return RegenerateSecurityTokenOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [BotId]", false));
5736 }
5737 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5738 Aws::StringStream ss;
5739 uri.AddPathSegments("/accounts/");
5740 uri.AddPathSegment(request.GetAccountId());
5741 uri.AddPathSegments("/bots/");
5742 uri.AddPathSegment(request.GetBotId());
5743 ss.str("?operation=regenerate-security-token");
5744 uri.SetQueryString(ss.str());
5745 return RegenerateSecurityTokenOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5746 }
5747
RegenerateSecurityTokenCallable(const RegenerateSecurityTokenRequest & request) const5748 RegenerateSecurityTokenOutcomeCallable ChimeClient::RegenerateSecurityTokenCallable(const RegenerateSecurityTokenRequest& request) const
5749 {
5750 auto task = Aws::MakeShared< std::packaged_task< RegenerateSecurityTokenOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RegenerateSecurityToken(request); } );
5751 auto packagedFunction = [task]() { (*task)(); };
5752 m_executor->Submit(packagedFunction);
5753 return task->get_future();
5754 }
5755
RegenerateSecurityTokenAsync(const RegenerateSecurityTokenRequest & request,const RegenerateSecurityTokenResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5756 void ChimeClient::RegenerateSecurityTokenAsync(const RegenerateSecurityTokenRequest& request, const RegenerateSecurityTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5757 {
5758 m_executor->Submit( [this, request, handler, context](){ this->RegenerateSecurityTokenAsyncHelper( request, handler, context ); } );
5759 }
5760
RegenerateSecurityTokenAsyncHelper(const RegenerateSecurityTokenRequest & request,const RegenerateSecurityTokenResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5761 void ChimeClient::RegenerateSecurityTokenAsyncHelper(const RegenerateSecurityTokenRequest& request, const RegenerateSecurityTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5762 {
5763 handler(this, request, RegenerateSecurityToken(request), context);
5764 }
5765
ResetPersonalPIN(const ResetPersonalPINRequest & request) const5766 ResetPersonalPINOutcome ChimeClient::ResetPersonalPIN(const ResetPersonalPINRequest& request) const
5767 {
5768 if (!request.AccountIdHasBeenSet())
5769 {
5770 AWS_LOGSTREAM_ERROR("ResetPersonalPIN", "Required field: AccountId, is not set");
5771 return ResetPersonalPINOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
5772 }
5773 if (!request.UserIdHasBeenSet())
5774 {
5775 AWS_LOGSTREAM_ERROR("ResetPersonalPIN", "Required field: UserId, is not set");
5776 return ResetPersonalPINOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
5777 }
5778 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5779 Aws::StringStream ss;
5780 uri.AddPathSegments("/accounts/");
5781 uri.AddPathSegment(request.GetAccountId());
5782 uri.AddPathSegments("/users/");
5783 uri.AddPathSegment(request.GetUserId());
5784 ss.str("?operation=reset-personal-pin");
5785 uri.SetQueryString(ss.str());
5786 return ResetPersonalPINOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5787 }
5788
ResetPersonalPINCallable(const ResetPersonalPINRequest & request) const5789 ResetPersonalPINOutcomeCallable ChimeClient::ResetPersonalPINCallable(const ResetPersonalPINRequest& request) const
5790 {
5791 auto task = Aws::MakeShared< std::packaged_task< ResetPersonalPINOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ResetPersonalPIN(request); } );
5792 auto packagedFunction = [task]() { (*task)(); };
5793 m_executor->Submit(packagedFunction);
5794 return task->get_future();
5795 }
5796
ResetPersonalPINAsync(const ResetPersonalPINRequest & request,const ResetPersonalPINResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5797 void ChimeClient::ResetPersonalPINAsync(const ResetPersonalPINRequest& request, const ResetPersonalPINResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5798 {
5799 m_executor->Submit( [this, request, handler, context](){ this->ResetPersonalPINAsyncHelper( request, handler, context ); } );
5800 }
5801
ResetPersonalPINAsyncHelper(const ResetPersonalPINRequest & request,const ResetPersonalPINResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5802 void ChimeClient::ResetPersonalPINAsyncHelper(const ResetPersonalPINRequest& request, const ResetPersonalPINResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5803 {
5804 handler(this, request, ResetPersonalPIN(request), context);
5805 }
5806
RestorePhoneNumber(const RestorePhoneNumberRequest & request) const5807 RestorePhoneNumberOutcome ChimeClient::RestorePhoneNumber(const RestorePhoneNumberRequest& request) const
5808 {
5809 if (!request.PhoneNumberIdHasBeenSet())
5810 {
5811 AWS_LOGSTREAM_ERROR("RestorePhoneNumber", "Required field: PhoneNumberId, is not set");
5812 return RestorePhoneNumberOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PhoneNumberId]", false));
5813 }
5814 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5815 Aws::StringStream ss;
5816 uri.AddPathSegments("/phone-numbers/");
5817 uri.AddPathSegment(request.GetPhoneNumberId());
5818 ss.str("?operation=restore");
5819 uri.SetQueryString(ss.str());
5820 return RestorePhoneNumberOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5821 }
5822
RestorePhoneNumberCallable(const RestorePhoneNumberRequest & request) const5823 RestorePhoneNumberOutcomeCallable ChimeClient::RestorePhoneNumberCallable(const RestorePhoneNumberRequest& request) const
5824 {
5825 auto task = Aws::MakeShared< std::packaged_task< RestorePhoneNumberOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RestorePhoneNumber(request); } );
5826 auto packagedFunction = [task]() { (*task)(); };
5827 m_executor->Submit(packagedFunction);
5828 return task->get_future();
5829 }
5830
RestorePhoneNumberAsync(const RestorePhoneNumberRequest & request,const RestorePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5831 void ChimeClient::RestorePhoneNumberAsync(const RestorePhoneNumberRequest& request, const RestorePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5832 {
5833 m_executor->Submit( [this, request, handler, context](){ this->RestorePhoneNumberAsyncHelper( request, handler, context ); } );
5834 }
5835
RestorePhoneNumberAsyncHelper(const RestorePhoneNumberRequest & request,const RestorePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5836 void ChimeClient::RestorePhoneNumberAsyncHelper(const RestorePhoneNumberRequest& request, const RestorePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5837 {
5838 handler(this, request, RestorePhoneNumber(request), context);
5839 }
5840
SearchAvailablePhoneNumbers(const SearchAvailablePhoneNumbersRequest & request) const5841 SearchAvailablePhoneNumbersOutcome ChimeClient::SearchAvailablePhoneNumbers(const SearchAvailablePhoneNumbersRequest& request) const
5842 {
5843 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5844 Aws::StringStream ss;
5845 uri.AddPathSegments("/search");
5846 ss.str("?type=phone-numbers");
5847 uri.SetQueryString(ss.str());
5848 return SearchAvailablePhoneNumbersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
5849 }
5850
SearchAvailablePhoneNumbersCallable(const SearchAvailablePhoneNumbersRequest & request) const5851 SearchAvailablePhoneNumbersOutcomeCallable ChimeClient::SearchAvailablePhoneNumbersCallable(const SearchAvailablePhoneNumbersRequest& request) const
5852 {
5853 auto task = Aws::MakeShared< std::packaged_task< SearchAvailablePhoneNumbersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SearchAvailablePhoneNumbers(request); } );
5854 auto packagedFunction = [task]() { (*task)(); };
5855 m_executor->Submit(packagedFunction);
5856 return task->get_future();
5857 }
5858
SearchAvailablePhoneNumbersAsync(const SearchAvailablePhoneNumbersRequest & request,const SearchAvailablePhoneNumbersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5859 void ChimeClient::SearchAvailablePhoneNumbersAsync(const SearchAvailablePhoneNumbersRequest& request, const SearchAvailablePhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5860 {
5861 m_executor->Submit( [this, request, handler, context](){ this->SearchAvailablePhoneNumbersAsyncHelper( request, handler, context ); } );
5862 }
5863
SearchAvailablePhoneNumbersAsyncHelper(const SearchAvailablePhoneNumbersRequest & request,const SearchAvailablePhoneNumbersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5864 void ChimeClient::SearchAvailablePhoneNumbersAsyncHelper(const SearchAvailablePhoneNumbersRequest& request, const SearchAvailablePhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5865 {
5866 handler(this, request, SearchAvailablePhoneNumbers(request), context);
5867 }
5868
SendChannelMessage(const SendChannelMessageRequest & request) const5869 SendChannelMessageOutcome ChimeClient::SendChannelMessage(const SendChannelMessageRequest& request) const
5870 {
5871 if (!request.ChannelArnHasBeenSet())
5872 {
5873 AWS_LOGSTREAM_ERROR("SendChannelMessage", "Required field: ChannelArn, is not set");
5874 return SendChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
5875 }
5876 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5877 if (m_enableHostPrefixInjection)
5878 {
5879 uri.SetAuthority("messaging-" + uri.GetAuthority());
5880 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
5881 {
5882 AWS_LOGSTREAM_ERROR("SendChannelMessage", "Invalid DNS host: " << uri.GetAuthority());
5883 return SendChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
5884 }
5885 }
5886 uri.AddPathSegments("/channels/");
5887 uri.AddPathSegment(request.GetChannelArn());
5888 uri.AddPathSegments("/messages");
5889 return SendChannelMessageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5890 }
5891
SendChannelMessageCallable(const SendChannelMessageRequest & request) const5892 SendChannelMessageOutcomeCallable ChimeClient::SendChannelMessageCallable(const SendChannelMessageRequest& request) const
5893 {
5894 auto task = Aws::MakeShared< std::packaged_task< SendChannelMessageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SendChannelMessage(request); } );
5895 auto packagedFunction = [task]() { (*task)(); };
5896 m_executor->Submit(packagedFunction);
5897 return task->get_future();
5898 }
5899
SendChannelMessageAsync(const SendChannelMessageRequest & request,const SendChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5900 void ChimeClient::SendChannelMessageAsync(const SendChannelMessageRequest& request, const SendChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5901 {
5902 m_executor->Submit( [this, request, handler, context](){ this->SendChannelMessageAsyncHelper( request, handler, context ); } );
5903 }
5904
SendChannelMessageAsyncHelper(const SendChannelMessageRequest & request,const SendChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5905 void ChimeClient::SendChannelMessageAsyncHelper(const SendChannelMessageRequest& request, const SendChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5906 {
5907 handler(this, request, SendChannelMessage(request), context);
5908 }
5909
StartMeetingTranscription(const StartMeetingTranscriptionRequest & request) const5910 StartMeetingTranscriptionOutcome ChimeClient::StartMeetingTranscription(const StartMeetingTranscriptionRequest& request) const
5911 {
5912 if (!request.MeetingIdHasBeenSet())
5913 {
5914 AWS_LOGSTREAM_ERROR("StartMeetingTranscription", "Required field: MeetingId, is not set");
5915 return StartMeetingTranscriptionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
5916 }
5917 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5918 Aws::StringStream ss;
5919 uri.AddPathSegments("/meetings/");
5920 uri.AddPathSegment(request.GetMeetingId());
5921 uri.AddPathSegments("/transcription");
5922 ss.str("?operation=start");
5923 uri.SetQueryString(ss.str());
5924 return StartMeetingTranscriptionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5925 }
5926
StartMeetingTranscriptionCallable(const StartMeetingTranscriptionRequest & request) const5927 StartMeetingTranscriptionOutcomeCallable ChimeClient::StartMeetingTranscriptionCallable(const StartMeetingTranscriptionRequest& request) const
5928 {
5929 auto task = Aws::MakeShared< std::packaged_task< StartMeetingTranscriptionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartMeetingTranscription(request); } );
5930 auto packagedFunction = [task]() { (*task)(); };
5931 m_executor->Submit(packagedFunction);
5932 return task->get_future();
5933 }
5934
StartMeetingTranscriptionAsync(const StartMeetingTranscriptionRequest & request,const StartMeetingTranscriptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5935 void ChimeClient::StartMeetingTranscriptionAsync(const StartMeetingTranscriptionRequest& request, const StartMeetingTranscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5936 {
5937 m_executor->Submit( [this, request, handler, context](){ this->StartMeetingTranscriptionAsyncHelper( request, handler, context ); } );
5938 }
5939
StartMeetingTranscriptionAsyncHelper(const StartMeetingTranscriptionRequest & request,const StartMeetingTranscriptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5940 void ChimeClient::StartMeetingTranscriptionAsyncHelper(const StartMeetingTranscriptionRequest& request, const StartMeetingTranscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5941 {
5942 handler(this, request, StartMeetingTranscription(request), context);
5943 }
5944
StopMeetingTranscription(const StopMeetingTranscriptionRequest & request) const5945 StopMeetingTranscriptionOutcome ChimeClient::StopMeetingTranscription(const StopMeetingTranscriptionRequest& request) const
5946 {
5947 if (!request.MeetingIdHasBeenSet())
5948 {
5949 AWS_LOGSTREAM_ERROR("StopMeetingTranscription", "Required field: MeetingId, is not set");
5950 return StopMeetingTranscriptionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
5951 }
5952 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5953 Aws::StringStream ss;
5954 uri.AddPathSegments("/meetings/");
5955 uri.AddPathSegment(request.GetMeetingId());
5956 uri.AddPathSegments("/transcription");
5957 ss.str("?operation=stop");
5958 uri.SetQueryString(ss.str());
5959 return StopMeetingTranscriptionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
5960 }
5961
StopMeetingTranscriptionCallable(const StopMeetingTranscriptionRequest & request) const5962 StopMeetingTranscriptionOutcomeCallable ChimeClient::StopMeetingTranscriptionCallable(const StopMeetingTranscriptionRequest& request) const
5963 {
5964 auto task = Aws::MakeShared< std::packaged_task< StopMeetingTranscriptionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopMeetingTranscription(request); } );
5965 auto packagedFunction = [task]() { (*task)(); };
5966 m_executor->Submit(packagedFunction);
5967 return task->get_future();
5968 }
5969
StopMeetingTranscriptionAsync(const StopMeetingTranscriptionRequest & request,const StopMeetingTranscriptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5970 void ChimeClient::StopMeetingTranscriptionAsync(const StopMeetingTranscriptionRequest& request, const StopMeetingTranscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5971 {
5972 m_executor->Submit( [this, request, handler, context](){ this->StopMeetingTranscriptionAsyncHelper( request, handler, context ); } );
5973 }
5974
StopMeetingTranscriptionAsyncHelper(const StopMeetingTranscriptionRequest & request,const StopMeetingTranscriptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const5975 void ChimeClient::StopMeetingTranscriptionAsyncHelper(const StopMeetingTranscriptionRequest& request, const StopMeetingTranscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
5976 {
5977 handler(this, request, StopMeetingTranscription(request), context);
5978 }
5979
TagAttendee(const TagAttendeeRequest & request) const5980 TagAttendeeOutcome ChimeClient::TagAttendee(const TagAttendeeRequest& request) const
5981 {
5982 if (!request.MeetingIdHasBeenSet())
5983 {
5984 AWS_LOGSTREAM_ERROR("TagAttendee", "Required field: MeetingId, is not set");
5985 return TagAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
5986 }
5987 if (!request.AttendeeIdHasBeenSet())
5988 {
5989 AWS_LOGSTREAM_ERROR("TagAttendee", "Required field: AttendeeId, is not set");
5990 return TagAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AttendeeId]", false));
5991 }
5992 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
5993 Aws::StringStream ss;
5994 uri.AddPathSegments("/meetings/");
5995 uri.AddPathSegment(request.GetMeetingId());
5996 uri.AddPathSegments("/attendees/");
5997 uri.AddPathSegment(request.GetAttendeeId());
5998 uri.AddPathSegments("/tags");
5999 ss.str("?operation=add");
6000 uri.SetQueryString(ss.str());
6001 return TagAttendeeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6002 }
6003
TagAttendeeCallable(const TagAttendeeRequest & request) const6004 TagAttendeeOutcomeCallable ChimeClient::TagAttendeeCallable(const TagAttendeeRequest& request) const
6005 {
6006 auto task = Aws::MakeShared< std::packaged_task< TagAttendeeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagAttendee(request); } );
6007 auto packagedFunction = [task]() { (*task)(); };
6008 m_executor->Submit(packagedFunction);
6009 return task->get_future();
6010 }
6011
TagAttendeeAsync(const TagAttendeeRequest & request,const TagAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6012 void ChimeClient::TagAttendeeAsync(const TagAttendeeRequest& request, const TagAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6013 {
6014 m_executor->Submit( [this, request, handler, context](){ this->TagAttendeeAsyncHelper( request, handler, context ); } );
6015 }
6016
TagAttendeeAsyncHelper(const TagAttendeeRequest & request,const TagAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6017 void ChimeClient::TagAttendeeAsyncHelper(const TagAttendeeRequest& request, const TagAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6018 {
6019 handler(this, request, TagAttendee(request), context);
6020 }
6021
TagMeeting(const TagMeetingRequest & request) const6022 TagMeetingOutcome ChimeClient::TagMeeting(const TagMeetingRequest& request) const
6023 {
6024 if (!request.MeetingIdHasBeenSet())
6025 {
6026 AWS_LOGSTREAM_ERROR("TagMeeting", "Required field: MeetingId, is not set");
6027 return TagMeetingOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
6028 }
6029 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6030 Aws::StringStream ss;
6031 uri.AddPathSegments("/meetings/");
6032 uri.AddPathSegment(request.GetMeetingId());
6033 uri.AddPathSegments("/tags");
6034 ss.str("?operation=add");
6035 uri.SetQueryString(ss.str());
6036 return TagMeetingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6037 }
6038
TagMeetingCallable(const TagMeetingRequest & request) const6039 TagMeetingOutcomeCallable ChimeClient::TagMeetingCallable(const TagMeetingRequest& request) const
6040 {
6041 auto task = Aws::MakeShared< std::packaged_task< TagMeetingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagMeeting(request); } );
6042 auto packagedFunction = [task]() { (*task)(); };
6043 m_executor->Submit(packagedFunction);
6044 return task->get_future();
6045 }
6046
TagMeetingAsync(const TagMeetingRequest & request,const TagMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6047 void ChimeClient::TagMeetingAsync(const TagMeetingRequest& request, const TagMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6048 {
6049 m_executor->Submit( [this, request, handler, context](){ this->TagMeetingAsyncHelper( request, handler, context ); } );
6050 }
6051
TagMeetingAsyncHelper(const TagMeetingRequest & request,const TagMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6052 void ChimeClient::TagMeetingAsyncHelper(const TagMeetingRequest& request, const TagMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6053 {
6054 handler(this, request, TagMeeting(request), context);
6055 }
6056
TagResource(const TagResourceRequest & request) const6057 TagResourceOutcome ChimeClient::TagResource(const TagResourceRequest& request) const
6058 {
6059 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6060 Aws::StringStream ss;
6061 uri.AddPathSegments("/tags");
6062 ss.str("?operation=tag-resource");
6063 uri.SetQueryString(ss.str());
6064 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6065 }
6066
TagResourceCallable(const TagResourceRequest & request) const6067 TagResourceOutcomeCallable ChimeClient::TagResourceCallable(const TagResourceRequest& request) const
6068 {
6069 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
6070 auto packagedFunction = [task]() { (*task)(); };
6071 m_executor->Submit(packagedFunction);
6072 return task->get_future();
6073 }
6074
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6075 void ChimeClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6076 {
6077 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
6078 }
6079
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6080 void ChimeClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6081 {
6082 handler(this, request, TagResource(request), context);
6083 }
6084
UntagAttendee(const UntagAttendeeRequest & request) const6085 UntagAttendeeOutcome ChimeClient::UntagAttendee(const UntagAttendeeRequest& request) const
6086 {
6087 if (!request.MeetingIdHasBeenSet())
6088 {
6089 AWS_LOGSTREAM_ERROR("UntagAttendee", "Required field: MeetingId, is not set");
6090 return UntagAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
6091 }
6092 if (!request.AttendeeIdHasBeenSet())
6093 {
6094 AWS_LOGSTREAM_ERROR("UntagAttendee", "Required field: AttendeeId, is not set");
6095 return UntagAttendeeOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AttendeeId]", false));
6096 }
6097 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6098 Aws::StringStream ss;
6099 uri.AddPathSegments("/meetings/");
6100 uri.AddPathSegment(request.GetMeetingId());
6101 uri.AddPathSegments("/attendees/");
6102 uri.AddPathSegment(request.GetAttendeeId());
6103 uri.AddPathSegments("/tags");
6104 ss.str("?operation=delete");
6105 uri.SetQueryString(ss.str());
6106 return UntagAttendeeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6107 }
6108
UntagAttendeeCallable(const UntagAttendeeRequest & request) const6109 UntagAttendeeOutcomeCallable ChimeClient::UntagAttendeeCallable(const UntagAttendeeRequest& request) const
6110 {
6111 auto task = Aws::MakeShared< std::packaged_task< UntagAttendeeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagAttendee(request); } );
6112 auto packagedFunction = [task]() { (*task)(); };
6113 m_executor->Submit(packagedFunction);
6114 return task->get_future();
6115 }
6116
UntagAttendeeAsync(const UntagAttendeeRequest & request,const UntagAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6117 void ChimeClient::UntagAttendeeAsync(const UntagAttendeeRequest& request, const UntagAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6118 {
6119 m_executor->Submit( [this, request, handler, context](){ this->UntagAttendeeAsyncHelper( request, handler, context ); } );
6120 }
6121
UntagAttendeeAsyncHelper(const UntagAttendeeRequest & request,const UntagAttendeeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6122 void ChimeClient::UntagAttendeeAsyncHelper(const UntagAttendeeRequest& request, const UntagAttendeeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6123 {
6124 handler(this, request, UntagAttendee(request), context);
6125 }
6126
UntagMeeting(const UntagMeetingRequest & request) const6127 UntagMeetingOutcome ChimeClient::UntagMeeting(const UntagMeetingRequest& request) const
6128 {
6129 if (!request.MeetingIdHasBeenSet())
6130 {
6131 AWS_LOGSTREAM_ERROR("UntagMeeting", "Required field: MeetingId, is not set");
6132 return UntagMeetingOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MeetingId]", false));
6133 }
6134 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6135 Aws::StringStream ss;
6136 uri.AddPathSegments("/meetings/");
6137 uri.AddPathSegment(request.GetMeetingId());
6138 uri.AddPathSegments("/tags");
6139 ss.str("?operation=delete");
6140 uri.SetQueryString(ss.str());
6141 return UntagMeetingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6142 }
6143
UntagMeetingCallable(const UntagMeetingRequest & request) const6144 UntagMeetingOutcomeCallable ChimeClient::UntagMeetingCallable(const UntagMeetingRequest& request) const
6145 {
6146 auto task = Aws::MakeShared< std::packaged_task< UntagMeetingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagMeeting(request); } );
6147 auto packagedFunction = [task]() { (*task)(); };
6148 m_executor->Submit(packagedFunction);
6149 return task->get_future();
6150 }
6151
UntagMeetingAsync(const UntagMeetingRequest & request,const UntagMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6152 void ChimeClient::UntagMeetingAsync(const UntagMeetingRequest& request, const UntagMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6153 {
6154 m_executor->Submit( [this, request, handler, context](){ this->UntagMeetingAsyncHelper( request, handler, context ); } );
6155 }
6156
UntagMeetingAsyncHelper(const UntagMeetingRequest & request,const UntagMeetingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6157 void ChimeClient::UntagMeetingAsyncHelper(const UntagMeetingRequest& request, const UntagMeetingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6158 {
6159 handler(this, request, UntagMeeting(request), context);
6160 }
6161
UntagResource(const UntagResourceRequest & request) const6162 UntagResourceOutcome ChimeClient::UntagResource(const UntagResourceRequest& request) const
6163 {
6164 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6165 Aws::StringStream ss;
6166 uri.AddPathSegments("/tags");
6167 ss.str("?operation=untag-resource");
6168 uri.SetQueryString(ss.str());
6169 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6170 }
6171
UntagResourceCallable(const UntagResourceRequest & request) const6172 UntagResourceOutcomeCallable ChimeClient::UntagResourceCallable(const UntagResourceRequest& request) const
6173 {
6174 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
6175 auto packagedFunction = [task]() { (*task)(); };
6176 m_executor->Submit(packagedFunction);
6177 return task->get_future();
6178 }
6179
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6180 void ChimeClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6181 {
6182 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
6183 }
6184
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6185 void ChimeClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6186 {
6187 handler(this, request, UntagResource(request), context);
6188 }
6189
UpdateAccount(const UpdateAccountRequest & request) const6190 UpdateAccountOutcome ChimeClient::UpdateAccount(const UpdateAccountRequest& request) const
6191 {
6192 if (!request.AccountIdHasBeenSet())
6193 {
6194 AWS_LOGSTREAM_ERROR("UpdateAccount", "Required field: AccountId, is not set");
6195 return UpdateAccountOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
6196 }
6197 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6198 uri.AddPathSegments("/accounts/");
6199 uri.AddPathSegment(request.GetAccountId());
6200 return UpdateAccountOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6201 }
6202
UpdateAccountCallable(const UpdateAccountRequest & request) const6203 UpdateAccountOutcomeCallable ChimeClient::UpdateAccountCallable(const UpdateAccountRequest& request) const
6204 {
6205 auto task = Aws::MakeShared< std::packaged_task< UpdateAccountOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAccount(request); } );
6206 auto packagedFunction = [task]() { (*task)(); };
6207 m_executor->Submit(packagedFunction);
6208 return task->get_future();
6209 }
6210
UpdateAccountAsync(const UpdateAccountRequest & request,const UpdateAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6211 void ChimeClient::UpdateAccountAsync(const UpdateAccountRequest& request, const UpdateAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6212 {
6213 m_executor->Submit( [this, request, handler, context](){ this->UpdateAccountAsyncHelper( request, handler, context ); } );
6214 }
6215
UpdateAccountAsyncHelper(const UpdateAccountRequest & request,const UpdateAccountResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6216 void ChimeClient::UpdateAccountAsyncHelper(const UpdateAccountRequest& request, const UpdateAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6217 {
6218 handler(this, request, UpdateAccount(request), context);
6219 }
6220
UpdateAccountSettings(const UpdateAccountSettingsRequest & request) const6221 UpdateAccountSettingsOutcome ChimeClient::UpdateAccountSettings(const UpdateAccountSettingsRequest& request) const
6222 {
6223 if (!request.AccountIdHasBeenSet())
6224 {
6225 AWS_LOGSTREAM_ERROR("UpdateAccountSettings", "Required field: AccountId, is not set");
6226 return UpdateAccountSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
6227 }
6228 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6229 uri.AddPathSegments("/accounts/");
6230 uri.AddPathSegment(request.GetAccountId());
6231 uri.AddPathSegments("/settings");
6232 return UpdateAccountSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6233 }
6234
UpdateAccountSettingsCallable(const UpdateAccountSettingsRequest & request) const6235 UpdateAccountSettingsOutcomeCallable ChimeClient::UpdateAccountSettingsCallable(const UpdateAccountSettingsRequest& request) const
6236 {
6237 auto task = Aws::MakeShared< std::packaged_task< UpdateAccountSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAccountSettings(request); } );
6238 auto packagedFunction = [task]() { (*task)(); };
6239 m_executor->Submit(packagedFunction);
6240 return task->get_future();
6241 }
6242
UpdateAccountSettingsAsync(const UpdateAccountSettingsRequest & request,const UpdateAccountSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6243 void ChimeClient::UpdateAccountSettingsAsync(const UpdateAccountSettingsRequest& request, const UpdateAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6244 {
6245 m_executor->Submit( [this, request, handler, context](){ this->UpdateAccountSettingsAsyncHelper( request, handler, context ); } );
6246 }
6247
UpdateAccountSettingsAsyncHelper(const UpdateAccountSettingsRequest & request,const UpdateAccountSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6248 void ChimeClient::UpdateAccountSettingsAsyncHelper(const UpdateAccountSettingsRequest& request, const UpdateAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6249 {
6250 handler(this, request, UpdateAccountSettings(request), context);
6251 }
6252
UpdateAppInstance(const UpdateAppInstanceRequest & request) const6253 UpdateAppInstanceOutcome ChimeClient::UpdateAppInstance(const UpdateAppInstanceRequest& request) const
6254 {
6255 if (!request.AppInstanceArnHasBeenSet())
6256 {
6257 AWS_LOGSTREAM_ERROR("UpdateAppInstance", "Required field: AppInstanceArn, is not set");
6258 return UpdateAppInstanceOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceArn]", false));
6259 }
6260 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6261 if (m_enableHostPrefixInjection)
6262 {
6263 uri.SetAuthority("identity-" + uri.GetAuthority());
6264 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
6265 {
6266 AWS_LOGSTREAM_ERROR("UpdateAppInstance", "Invalid DNS host: " << uri.GetAuthority());
6267 return UpdateAppInstanceOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
6268 }
6269 }
6270 uri.AddPathSegments("/app-instances/");
6271 uri.AddPathSegment(request.GetAppInstanceArn());
6272 return UpdateAppInstanceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6273 }
6274
UpdateAppInstanceCallable(const UpdateAppInstanceRequest & request) const6275 UpdateAppInstanceOutcomeCallable ChimeClient::UpdateAppInstanceCallable(const UpdateAppInstanceRequest& request) const
6276 {
6277 auto task = Aws::MakeShared< std::packaged_task< UpdateAppInstanceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAppInstance(request); } );
6278 auto packagedFunction = [task]() { (*task)(); };
6279 m_executor->Submit(packagedFunction);
6280 return task->get_future();
6281 }
6282
UpdateAppInstanceAsync(const UpdateAppInstanceRequest & request,const UpdateAppInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6283 void ChimeClient::UpdateAppInstanceAsync(const UpdateAppInstanceRequest& request, const UpdateAppInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6284 {
6285 m_executor->Submit( [this, request, handler, context](){ this->UpdateAppInstanceAsyncHelper( request, handler, context ); } );
6286 }
6287
UpdateAppInstanceAsyncHelper(const UpdateAppInstanceRequest & request,const UpdateAppInstanceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6288 void ChimeClient::UpdateAppInstanceAsyncHelper(const UpdateAppInstanceRequest& request, const UpdateAppInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6289 {
6290 handler(this, request, UpdateAppInstance(request), context);
6291 }
6292
UpdateAppInstanceUser(const UpdateAppInstanceUserRequest & request) const6293 UpdateAppInstanceUserOutcome ChimeClient::UpdateAppInstanceUser(const UpdateAppInstanceUserRequest& request) const
6294 {
6295 if (!request.AppInstanceUserArnHasBeenSet())
6296 {
6297 AWS_LOGSTREAM_ERROR("UpdateAppInstanceUser", "Required field: AppInstanceUserArn, is not set");
6298 return UpdateAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AppInstanceUserArn]", false));
6299 }
6300 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6301 if (m_enableHostPrefixInjection)
6302 {
6303 uri.SetAuthority("identity-" + uri.GetAuthority());
6304 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
6305 {
6306 AWS_LOGSTREAM_ERROR("UpdateAppInstanceUser", "Invalid DNS host: " << uri.GetAuthority());
6307 return UpdateAppInstanceUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
6308 }
6309 }
6310 uri.AddPathSegments("/app-instance-users/");
6311 uri.AddPathSegment(request.GetAppInstanceUserArn());
6312 return UpdateAppInstanceUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6313 }
6314
UpdateAppInstanceUserCallable(const UpdateAppInstanceUserRequest & request) const6315 UpdateAppInstanceUserOutcomeCallable ChimeClient::UpdateAppInstanceUserCallable(const UpdateAppInstanceUserRequest& request) const
6316 {
6317 auto task = Aws::MakeShared< std::packaged_task< UpdateAppInstanceUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAppInstanceUser(request); } );
6318 auto packagedFunction = [task]() { (*task)(); };
6319 m_executor->Submit(packagedFunction);
6320 return task->get_future();
6321 }
6322
UpdateAppInstanceUserAsync(const UpdateAppInstanceUserRequest & request,const UpdateAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6323 void ChimeClient::UpdateAppInstanceUserAsync(const UpdateAppInstanceUserRequest& request, const UpdateAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6324 {
6325 m_executor->Submit( [this, request, handler, context](){ this->UpdateAppInstanceUserAsyncHelper( request, handler, context ); } );
6326 }
6327
UpdateAppInstanceUserAsyncHelper(const UpdateAppInstanceUserRequest & request,const UpdateAppInstanceUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6328 void ChimeClient::UpdateAppInstanceUserAsyncHelper(const UpdateAppInstanceUserRequest& request, const UpdateAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6329 {
6330 handler(this, request, UpdateAppInstanceUser(request), context);
6331 }
6332
UpdateBot(const UpdateBotRequest & request) const6333 UpdateBotOutcome ChimeClient::UpdateBot(const UpdateBotRequest& request) const
6334 {
6335 if (!request.AccountIdHasBeenSet())
6336 {
6337 AWS_LOGSTREAM_ERROR("UpdateBot", "Required field: AccountId, is not set");
6338 return UpdateBotOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
6339 }
6340 if (!request.BotIdHasBeenSet())
6341 {
6342 AWS_LOGSTREAM_ERROR("UpdateBot", "Required field: BotId, is not set");
6343 return UpdateBotOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [BotId]", false));
6344 }
6345 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6346 uri.AddPathSegments("/accounts/");
6347 uri.AddPathSegment(request.GetAccountId());
6348 uri.AddPathSegments("/bots/");
6349 uri.AddPathSegment(request.GetBotId());
6350 return UpdateBotOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6351 }
6352
UpdateBotCallable(const UpdateBotRequest & request) const6353 UpdateBotOutcomeCallable ChimeClient::UpdateBotCallable(const UpdateBotRequest& request) const
6354 {
6355 auto task = Aws::MakeShared< std::packaged_task< UpdateBotOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateBot(request); } );
6356 auto packagedFunction = [task]() { (*task)(); };
6357 m_executor->Submit(packagedFunction);
6358 return task->get_future();
6359 }
6360
UpdateBotAsync(const UpdateBotRequest & request,const UpdateBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6361 void ChimeClient::UpdateBotAsync(const UpdateBotRequest& request, const UpdateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6362 {
6363 m_executor->Submit( [this, request, handler, context](){ this->UpdateBotAsyncHelper( request, handler, context ); } );
6364 }
6365
UpdateBotAsyncHelper(const UpdateBotRequest & request,const UpdateBotResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6366 void ChimeClient::UpdateBotAsyncHelper(const UpdateBotRequest& request, const UpdateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6367 {
6368 handler(this, request, UpdateBot(request), context);
6369 }
6370
UpdateChannel(const UpdateChannelRequest & request) const6371 UpdateChannelOutcome ChimeClient::UpdateChannel(const UpdateChannelRequest& request) const
6372 {
6373 if (!request.ChannelArnHasBeenSet())
6374 {
6375 AWS_LOGSTREAM_ERROR("UpdateChannel", "Required field: ChannelArn, is not set");
6376 return UpdateChannelOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
6377 }
6378 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6379 if (m_enableHostPrefixInjection)
6380 {
6381 uri.SetAuthority("messaging-" + uri.GetAuthority());
6382 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
6383 {
6384 AWS_LOGSTREAM_ERROR("UpdateChannel", "Invalid DNS host: " << uri.GetAuthority());
6385 return UpdateChannelOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
6386 }
6387 }
6388 uri.AddPathSegments("/channels/");
6389 uri.AddPathSegment(request.GetChannelArn());
6390 return UpdateChannelOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6391 }
6392
UpdateChannelCallable(const UpdateChannelRequest & request) const6393 UpdateChannelOutcomeCallable ChimeClient::UpdateChannelCallable(const UpdateChannelRequest& request) const
6394 {
6395 auto task = Aws::MakeShared< std::packaged_task< UpdateChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateChannel(request); } );
6396 auto packagedFunction = [task]() { (*task)(); };
6397 m_executor->Submit(packagedFunction);
6398 return task->get_future();
6399 }
6400
UpdateChannelAsync(const UpdateChannelRequest & request,const UpdateChannelResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6401 void ChimeClient::UpdateChannelAsync(const UpdateChannelRequest& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6402 {
6403 m_executor->Submit( [this, request, handler, context](){ this->UpdateChannelAsyncHelper( request, handler, context ); } );
6404 }
6405
UpdateChannelAsyncHelper(const UpdateChannelRequest & request,const UpdateChannelResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6406 void ChimeClient::UpdateChannelAsyncHelper(const UpdateChannelRequest& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6407 {
6408 handler(this, request, UpdateChannel(request), context);
6409 }
6410
UpdateChannelMessage(const UpdateChannelMessageRequest & request) const6411 UpdateChannelMessageOutcome ChimeClient::UpdateChannelMessage(const UpdateChannelMessageRequest& request) const
6412 {
6413 if (!request.ChannelArnHasBeenSet())
6414 {
6415 AWS_LOGSTREAM_ERROR("UpdateChannelMessage", "Required field: ChannelArn, is not set");
6416 return UpdateChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
6417 }
6418 if (!request.MessageIdHasBeenSet())
6419 {
6420 AWS_LOGSTREAM_ERROR("UpdateChannelMessage", "Required field: MessageId, is not set");
6421 return UpdateChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MessageId]", false));
6422 }
6423 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6424 if (m_enableHostPrefixInjection)
6425 {
6426 uri.SetAuthority("messaging-" + uri.GetAuthority());
6427 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
6428 {
6429 AWS_LOGSTREAM_ERROR("UpdateChannelMessage", "Invalid DNS host: " << uri.GetAuthority());
6430 return UpdateChannelMessageOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
6431 }
6432 }
6433 uri.AddPathSegments("/channels/");
6434 uri.AddPathSegment(request.GetChannelArn());
6435 uri.AddPathSegments("/messages/");
6436 uri.AddPathSegment(request.GetMessageId());
6437 return UpdateChannelMessageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6438 }
6439
UpdateChannelMessageCallable(const UpdateChannelMessageRequest & request) const6440 UpdateChannelMessageOutcomeCallable ChimeClient::UpdateChannelMessageCallable(const UpdateChannelMessageRequest& request) const
6441 {
6442 auto task = Aws::MakeShared< std::packaged_task< UpdateChannelMessageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateChannelMessage(request); } );
6443 auto packagedFunction = [task]() { (*task)(); };
6444 m_executor->Submit(packagedFunction);
6445 return task->get_future();
6446 }
6447
UpdateChannelMessageAsync(const UpdateChannelMessageRequest & request,const UpdateChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6448 void ChimeClient::UpdateChannelMessageAsync(const UpdateChannelMessageRequest& request, const UpdateChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6449 {
6450 m_executor->Submit( [this, request, handler, context](){ this->UpdateChannelMessageAsyncHelper( request, handler, context ); } );
6451 }
6452
UpdateChannelMessageAsyncHelper(const UpdateChannelMessageRequest & request,const UpdateChannelMessageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6453 void ChimeClient::UpdateChannelMessageAsyncHelper(const UpdateChannelMessageRequest& request, const UpdateChannelMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6454 {
6455 handler(this, request, UpdateChannelMessage(request), context);
6456 }
6457
UpdateChannelReadMarker(const UpdateChannelReadMarkerRequest & request) const6458 UpdateChannelReadMarkerOutcome ChimeClient::UpdateChannelReadMarker(const UpdateChannelReadMarkerRequest& request) const
6459 {
6460 if (!request.ChannelArnHasBeenSet())
6461 {
6462 AWS_LOGSTREAM_ERROR("UpdateChannelReadMarker", "Required field: ChannelArn, is not set");
6463 return UpdateChannelReadMarkerOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ChannelArn]", false));
6464 }
6465 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6466 if (m_enableHostPrefixInjection)
6467 {
6468 uri.SetAuthority("messaging-" + uri.GetAuthority());
6469 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
6470 {
6471 AWS_LOGSTREAM_ERROR("UpdateChannelReadMarker", "Invalid DNS host: " << uri.GetAuthority());
6472 return UpdateChannelReadMarkerOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
6473 }
6474 }
6475 uri.AddPathSegments("/channels/");
6476 uri.AddPathSegment(request.GetChannelArn());
6477 uri.AddPathSegments("/readMarker");
6478 return UpdateChannelReadMarkerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6479 }
6480
UpdateChannelReadMarkerCallable(const UpdateChannelReadMarkerRequest & request) const6481 UpdateChannelReadMarkerOutcomeCallable ChimeClient::UpdateChannelReadMarkerCallable(const UpdateChannelReadMarkerRequest& request) const
6482 {
6483 auto task = Aws::MakeShared< std::packaged_task< UpdateChannelReadMarkerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateChannelReadMarker(request); } );
6484 auto packagedFunction = [task]() { (*task)(); };
6485 m_executor->Submit(packagedFunction);
6486 return task->get_future();
6487 }
6488
UpdateChannelReadMarkerAsync(const UpdateChannelReadMarkerRequest & request,const UpdateChannelReadMarkerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6489 void ChimeClient::UpdateChannelReadMarkerAsync(const UpdateChannelReadMarkerRequest& request, const UpdateChannelReadMarkerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6490 {
6491 m_executor->Submit( [this, request, handler, context](){ this->UpdateChannelReadMarkerAsyncHelper( request, handler, context ); } );
6492 }
6493
UpdateChannelReadMarkerAsyncHelper(const UpdateChannelReadMarkerRequest & request,const UpdateChannelReadMarkerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6494 void ChimeClient::UpdateChannelReadMarkerAsyncHelper(const UpdateChannelReadMarkerRequest& request, const UpdateChannelReadMarkerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6495 {
6496 handler(this, request, UpdateChannelReadMarker(request), context);
6497 }
6498
UpdateGlobalSettings(const UpdateGlobalSettingsRequest & request) const6499 UpdateGlobalSettingsOutcome ChimeClient::UpdateGlobalSettings(const UpdateGlobalSettingsRequest& request) const
6500 {
6501 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6502 uri.AddPathSegments("/settings");
6503 return UpdateGlobalSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6504 }
6505
UpdateGlobalSettingsCallable(const UpdateGlobalSettingsRequest & request) const6506 UpdateGlobalSettingsOutcomeCallable ChimeClient::UpdateGlobalSettingsCallable(const UpdateGlobalSettingsRequest& request) const
6507 {
6508 auto task = Aws::MakeShared< std::packaged_task< UpdateGlobalSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateGlobalSettings(request); } );
6509 auto packagedFunction = [task]() { (*task)(); };
6510 m_executor->Submit(packagedFunction);
6511 return task->get_future();
6512 }
6513
UpdateGlobalSettingsAsync(const UpdateGlobalSettingsRequest & request,const UpdateGlobalSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6514 void ChimeClient::UpdateGlobalSettingsAsync(const UpdateGlobalSettingsRequest& request, const UpdateGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6515 {
6516 m_executor->Submit( [this, request, handler, context](){ this->UpdateGlobalSettingsAsyncHelper( request, handler, context ); } );
6517 }
6518
UpdateGlobalSettingsAsyncHelper(const UpdateGlobalSettingsRequest & request,const UpdateGlobalSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6519 void ChimeClient::UpdateGlobalSettingsAsyncHelper(const UpdateGlobalSettingsRequest& request, const UpdateGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6520 {
6521 handler(this, request, UpdateGlobalSettings(request), context);
6522 }
6523
UpdatePhoneNumber(const UpdatePhoneNumberRequest & request) const6524 UpdatePhoneNumberOutcome ChimeClient::UpdatePhoneNumber(const UpdatePhoneNumberRequest& request) const
6525 {
6526 if (!request.PhoneNumberIdHasBeenSet())
6527 {
6528 AWS_LOGSTREAM_ERROR("UpdatePhoneNumber", "Required field: PhoneNumberId, is not set");
6529 return UpdatePhoneNumberOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [PhoneNumberId]", false));
6530 }
6531 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6532 uri.AddPathSegments("/phone-numbers/");
6533 uri.AddPathSegment(request.GetPhoneNumberId());
6534 return UpdatePhoneNumberOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6535 }
6536
UpdatePhoneNumberCallable(const UpdatePhoneNumberRequest & request) const6537 UpdatePhoneNumberOutcomeCallable ChimeClient::UpdatePhoneNumberCallable(const UpdatePhoneNumberRequest& request) const
6538 {
6539 auto task = Aws::MakeShared< std::packaged_task< UpdatePhoneNumberOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdatePhoneNumber(request); } );
6540 auto packagedFunction = [task]() { (*task)(); };
6541 m_executor->Submit(packagedFunction);
6542 return task->get_future();
6543 }
6544
UpdatePhoneNumberAsync(const UpdatePhoneNumberRequest & request,const UpdatePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6545 void ChimeClient::UpdatePhoneNumberAsync(const UpdatePhoneNumberRequest& request, const UpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6546 {
6547 m_executor->Submit( [this, request, handler, context](){ this->UpdatePhoneNumberAsyncHelper( request, handler, context ); } );
6548 }
6549
UpdatePhoneNumberAsyncHelper(const UpdatePhoneNumberRequest & request,const UpdatePhoneNumberResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6550 void ChimeClient::UpdatePhoneNumberAsyncHelper(const UpdatePhoneNumberRequest& request, const UpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6551 {
6552 handler(this, request, UpdatePhoneNumber(request), context);
6553 }
6554
UpdatePhoneNumberSettings(const UpdatePhoneNumberSettingsRequest & request) const6555 UpdatePhoneNumberSettingsOutcome ChimeClient::UpdatePhoneNumberSettings(const UpdatePhoneNumberSettingsRequest& request) const
6556 {
6557 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6558 uri.AddPathSegments("/settings/phone-number");
6559 return UpdatePhoneNumberSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6560 }
6561
UpdatePhoneNumberSettingsCallable(const UpdatePhoneNumberSettingsRequest & request) const6562 UpdatePhoneNumberSettingsOutcomeCallable ChimeClient::UpdatePhoneNumberSettingsCallable(const UpdatePhoneNumberSettingsRequest& request) const
6563 {
6564 auto task = Aws::MakeShared< std::packaged_task< UpdatePhoneNumberSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdatePhoneNumberSettings(request); } );
6565 auto packagedFunction = [task]() { (*task)(); };
6566 m_executor->Submit(packagedFunction);
6567 return task->get_future();
6568 }
6569
UpdatePhoneNumberSettingsAsync(const UpdatePhoneNumberSettingsRequest & request,const UpdatePhoneNumberSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6570 void ChimeClient::UpdatePhoneNumberSettingsAsync(const UpdatePhoneNumberSettingsRequest& request, const UpdatePhoneNumberSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6571 {
6572 m_executor->Submit( [this, request, handler, context](){ this->UpdatePhoneNumberSettingsAsyncHelper( request, handler, context ); } );
6573 }
6574
UpdatePhoneNumberSettingsAsyncHelper(const UpdatePhoneNumberSettingsRequest & request,const UpdatePhoneNumberSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6575 void ChimeClient::UpdatePhoneNumberSettingsAsyncHelper(const UpdatePhoneNumberSettingsRequest& request, const UpdatePhoneNumberSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6576 {
6577 handler(this, request, UpdatePhoneNumberSettings(request), context);
6578 }
6579
UpdateProxySession(const UpdateProxySessionRequest & request) const6580 UpdateProxySessionOutcome ChimeClient::UpdateProxySession(const UpdateProxySessionRequest& request) const
6581 {
6582 if (!request.VoiceConnectorIdHasBeenSet())
6583 {
6584 AWS_LOGSTREAM_ERROR("UpdateProxySession", "Required field: VoiceConnectorId, is not set");
6585 return UpdateProxySessionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
6586 }
6587 if (!request.ProxySessionIdHasBeenSet())
6588 {
6589 AWS_LOGSTREAM_ERROR("UpdateProxySession", "Required field: ProxySessionId, is not set");
6590 return UpdateProxySessionOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ProxySessionId]", false));
6591 }
6592 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6593 uri.AddPathSegments("/voice-connectors/");
6594 uri.AddPathSegment(request.GetVoiceConnectorId());
6595 uri.AddPathSegments("/proxy-sessions/");
6596 uri.AddPathSegment(request.GetProxySessionId());
6597 return UpdateProxySessionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6598 }
6599
UpdateProxySessionCallable(const UpdateProxySessionRequest & request) const6600 UpdateProxySessionOutcomeCallable ChimeClient::UpdateProxySessionCallable(const UpdateProxySessionRequest& request) const
6601 {
6602 auto task = Aws::MakeShared< std::packaged_task< UpdateProxySessionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateProxySession(request); } );
6603 auto packagedFunction = [task]() { (*task)(); };
6604 m_executor->Submit(packagedFunction);
6605 return task->get_future();
6606 }
6607
UpdateProxySessionAsync(const UpdateProxySessionRequest & request,const UpdateProxySessionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6608 void ChimeClient::UpdateProxySessionAsync(const UpdateProxySessionRequest& request, const UpdateProxySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6609 {
6610 m_executor->Submit( [this, request, handler, context](){ this->UpdateProxySessionAsyncHelper( request, handler, context ); } );
6611 }
6612
UpdateProxySessionAsyncHelper(const UpdateProxySessionRequest & request,const UpdateProxySessionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6613 void ChimeClient::UpdateProxySessionAsyncHelper(const UpdateProxySessionRequest& request, const UpdateProxySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6614 {
6615 handler(this, request, UpdateProxySession(request), context);
6616 }
6617
UpdateRoom(const UpdateRoomRequest & request) const6618 UpdateRoomOutcome ChimeClient::UpdateRoom(const UpdateRoomRequest& request) const
6619 {
6620 if (!request.AccountIdHasBeenSet())
6621 {
6622 AWS_LOGSTREAM_ERROR("UpdateRoom", "Required field: AccountId, is not set");
6623 return UpdateRoomOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
6624 }
6625 if (!request.RoomIdHasBeenSet())
6626 {
6627 AWS_LOGSTREAM_ERROR("UpdateRoom", "Required field: RoomId, is not set");
6628 return UpdateRoomOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
6629 }
6630 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6631 uri.AddPathSegments("/accounts/");
6632 uri.AddPathSegment(request.GetAccountId());
6633 uri.AddPathSegments("/rooms/");
6634 uri.AddPathSegment(request.GetRoomId());
6635 return UpdateRoomOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6636 }
6637
UpdateRoomCallable(const UpdateRoomRequest & request) const6638 UpdateRoomOutcomeCallable ChimeClient::UpdateRoomCallable(const UpdateRoomRequest& request) const
6639 {
6640 auto task = Aws::MakeShared< std::packaged_task< UpdateRoomOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRoom(request); } );
6641 auto packagedFunction = [task]() { (*task)(); };
6642 m_executor->Submit(packagedFunction);
6643 return task->get_future();
6644 }
6645
UpdateRoomAsync(const UpdateRoomRequest & request,const UpdateRoomResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6646 void ChimeClient::UpdateRoomAsync(const UpdateRoomRequest& request, const UpdateRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6647 {
6648 m_executor->Submit( [this, request, handler, context](){ this->UpdateRoomAsyncHelper( request, handler, context ); } );
6649 }
6650
UpdateRoomAsyncHelper(const UpdateRoomRequest & request,const UpdateRoomResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6651 void ChimeClient::UpdateRoomAsyncHelper(const UpdateRoomRequest& request, const UpdateRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6652 {
6653 handler(this, request, UpdateRoom(request), context);
6654 }
6655
UpdateRoomMembership(const UpdateRoomMembershipRequest & request) const6656 UpdateRoomMembershipOutcome ChimeClient::UpdateRoomMembership(const UpdateRoomMembershipRequest& request) const
6657 {
6658 if (!request.AccountIdHasBeenSet())
6659 {
6660 AWS_LOGSTREAM_ERROR("UpdateRoomMembership", "Required field: AccountId, is not set");
6661 return UpdateRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
6662 }
6663 if (!request.RoomIdHasBeenSet())
6664 {
6665 AWS_LOGSTREAM_ERROR("UpdateRoomMembership", "Required field: RoomId, is not set");
6666 return UpdateRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [RoomId]", false));
6667 }
6668 if (!request.MemberIdHasBeenSet())
6669 {
6670 AWS_LOGSTREAM_ERROR("UpdateRoomMembership", "Required field: MemberId, is not set");
6671 return UpdateRoomMembershipOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MemberId]", false));
6672 }
6673 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6674 uri.AddPathSegments("/accounts/");
6675 uri.AddPathSegment(request.GetAccountId());
6676 uri.AddPathSegments("/rooms/");
6677 uri.AddPathSegment(request.GetRoomId());
6678 uri.AddPathSegments("/memberships/");
6679 uri.AddPathSegment(request.GetMemberId());
6680 return UpdateRoomMembershipOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6681 }
6682
UpdateRoomMembershipCallable(const UpdateRoomMembershipRequest & request) const6683 UpdateRoomMembershipOutcomeCallable ChimeClient::UpdateRoomMembershipCallable(const UpdateRoomMembershipRequest& request) const
6684 {
6685 auto task = Aws::MakeShared< std::packaged_task< UpdateRoomMembershipOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRoomMembership(request); } );
6686 auto packagedFunction = [task]() { (*task)(); };
6687 m_executor->Submit(packagedFunction);
6688 return task->get_future();
6689 }
6690
UpdateRoomMembershipAsync(const UpdateRoomMembershipRequest & request,const UpdateRoomMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6691 void ChimeClient::UpdateRoomMembershipAsync(const UpdateRoomMembershipRequest& request, const UpdateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6692 {
6693 m_executor->Submit( [this, request, handler, context](){ this->UpdateRoomMembershipAsyncHelper( request, handler, context ); } );
6694 }
6695
UpdateRoomMembershipAsyncHelper(const UpdateRoomMembershipRequest & request,const UpdateRoomMembershipResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6696 void ChimeClient::UpdateRoomMembershipAsyncHelper(const UpdateRoomMembershipRequest& request, const UpdateRoomMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6697 {
6698 handler(this, request, UpdateRoomMembership(request), context);
6699 }
6700
UpdateSipMediaApplication(const UpdateSipMediaApplicationRequest & request) const6701 UpdateSipMediaApplicationOutcome ChimeClient::UpdateSipMediaApplication(const UpdateSipMediaApplicationRequest& request) const
6702 {
6703 if (!request.SipMediaApplicationIdHasBeenSet())
6704 {
6705 AWS_LOGSTREAM_ERROR("UpdateSipMediaApplication", "Required field: SipMediaApplicationId, is not set");
6706 return UpdateSipMediaApplicationOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipMediaApplicationId]", false));
6707 }
6708 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6709 uri.AddPathSegments("/sip-media-applications/");
6710 uri.AddPathSegment(request.GetSipMediaApplicationId());
6711 return UpdateSipMediaApplicationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6712 }
6713
UpdateSipMediaApplicationCallable(const UpdateSipMediaApplicationRequest & request) const6714 UpdateSipMediaApplicationOutcomeCallable ChimeClient::UpdateSipMediaApplicationCallable(const UpdateSipMediaApplicationRequest& request) const
6715 {
6716 auto task = Aws::MakeShared< std::packaged_task< UpdateSipMediaApplicationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateSipMediaApplication(request); } );
6717 auto packagedFunction = [task]() { (*task)(); };
6718 m_executor->Submit(packagedFunction);
6719 return task->get_future();
6720 }
6721
UpdateSipMediaApplicationAsync(const UpdateSipMediaApplicationRequest & request,const UpdateSipMediaApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6722 void ChimeClient::UpdateSipMediaApplicationAsync(const UpdateSipMediaApplicationRequest& request, const UpdateSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6723 {
6724 m_executor->Submit( [this, request, handler, context](){ this->UpdateSipMediaApplicationAsyncHelper( request, handler, context ); } );
6725 }
6726
UpdateSipMediaApplicationAsyncHelper(const UpdateSipMediaApplicationRequest & request,const UpdateSipMediaApplicationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6727 void ChimeClient::UpdateSipMediaApplicationAsyncHelper(const UpdateSipMediaApplicationRequest& request, const UpdateSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6728 {
6729 handler(this, request, UpdateSipMediaApplication(request), context);
6730 }
6731
UpdateSipMediaApplicationCall(const UpdateSipMediaApplicationCallRequest & request) const6732 UpdateSipMediaApplicationCallOutcome ChimeClient::UpdateSipMediaApplicationCall(const UpdateSipMediaApplicationCallRequest& request) const
6733 {
6734 if (!request.SipMediaApplicationIdHasBeenSet())
6735 {
6736 AWS_LOGSTREAM_ERROR("UpdateSipMediaApplicationCall", "Required field: SipMediaApplicationId, is not set");
6737 return UpdateSipMediaApplicationCallOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipMediaApplicationId]", false));
6738 }
6739 if (!request.TransactionIdHasBeenSet())
6740 {
6741 AWS_LOGSTREAM_ERROR("UpdateSipMediaApplicationCall", "Required field: TransactionId, is not set");
6742 return UpdateSipMediaApplicationCallOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TransactionId]", false));
6743 }
6744 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6745 uri.AddPathSegments("/sip-media-applications/");
6746 uri.AddPathSegment(request.GetSipMediaApplicationId());
6747 uri.AddPathSegments("/calls/");
6748 uri.AddPathSegment(request.GetTransactionId());
6749 return UpdateSipMediaApplicationCallOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6750 }
6751
UpdateSipMediaApplicationCallCallable(const UpdateSipMediaApplicationCallRequest & request) const6752 UpdateSipMediaApplicationCallOutcomeCallable ChimeClient::UpdateSipMediaApplicationCallCallable(const UpdateSipMediaApplicationCallRequest& request) const
6753 {
6754 auto task = Aws::MakeShared< std::packaged_task< UpdateSipMediaApplicationCallOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateSipMediaApplicationCall(request); } );
6755 auto packagedFunction = [task]() { (*task)(); };
6756 m_executor->Submit(packagedFunction);
6757 return task->get_future();
6758 }
6759
UpdateSipMediaApplicationCallAsync(const UpdateSipMediaApplicationCallRequest & request,const UpdateSipMediaApplicationCallResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6760 void ChimeClient::UpdateSipMediaApplicationCallAsync(const UpdateSipMediaApplicationCallRequest& request, const UpdateSipMediaApplicationCallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6761 {
6762 m_executor->Submit( [this, request, handler, context](){ this->UpdateSipMediaApplicationCallAsyncHelper( request, handler, context ); } );
6763 }
6764
UpdateSipMediaApplicationCallAsyncHelper(const UpdateSipMediaApplicationCallRequest & request,const UpdateSipMediaApplicationCallResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6765 void ChimeClient::UpdateSipMediaApplicationCallAsyncHelper(const UpdateSipMediaApplicationCallRequest& request, const UpdateSipMediaApplicationCallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6766 {
6767 handler(this, request, UpdateSipMediaApplicationCall(request), context);
6768 }
6769
UpdateSipRule(const UpdateSipRuleRequest & request) const6770 UpdateSipRuleOutcome ChimeClient::UpdateSipRule(const UpdateSipRuleRequest& request) const
6771 {
6772 if (!request.SipRuleIdHasBeenSet())
6773 {
6774 AWS_LOGSTREAM_ERROR("UpdateSipRule", "Required field: SipRuleId, is not set");
6775 return UpdateSipRuleOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [SipRuleId]", false));
6776 }
6777 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6778 uri.AddPathSegments("/sip-rules/");
6779 uri.AddPathSegment(request.GetSipRuleId());
6780 return UpdateSipRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6781 }
6782
UpdateSipRuleCallable(const UpdateSipRuleRequest & request) const6783 UpdateSipRuleOutcomeCallable ChimeClient::UpdateSipRuleCallable(const UpdateSipRuleRequest& request) const
6784 {
6785 auto task = Aws::MakeShared< std::packaged_task< UpdateSipRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateSipRule(request); } );
6786 auto packagedFunction = [task]() { (*task)(); };
6787 m_executor->Submit(packagedFunction);
6788 return task->get_future();
6789 }
6790
UpdateSipRuleAsync(const UpdateSipRuleRequest & request,const UpdateSipRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6791 void ChimeClient::UpdateSipRuleAsync(const UpdateSipRuleRequest& request, const UpdateSipRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6792 {
6793 m_executor->Submit( [this, request, handler, context](){ this->UpdateSipRuleAsyncHelper( request, handler, context ); } );
6794 }
6795
UpdateSipRuleAsyncHelper(const UpdateSipRuleRequest & request,const UpdateSipRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6796 void ChimeClient::UpdateSipRuleAsyncHelper(const UpdateSipRuleRequest& request, const UpdateSipRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6797 {
6798 handler(this, request, UpdateSipRule(request), context);
6799 }
6800
UpdateUser(const UpdateUserRequest & request) const6801 UpdateUserOutcome ChimeClient::UpdateUser(const UpdateUserRequest& request) const
6802 {
6803 if (!request.AccountIdHasBeenSet())
6804 {
6805 AWS_LOGSTREAM_ERROR("UpdateUser", "Required field: AccountId, is not set");
6806 return UpdateUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
6807 }
6808 if (!request.UserIdHasBeenSet())
6809 {
6810 AWS_LOGSTREAM_ERROR("UpdateUser", "Required field: UserId, is not set");
6811 return UpdateUserOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
6812 }
6813 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6814 uri.AddPathSegments("/accounts/");
6815 uri.AddPathSegment(request.GetAccountId());
6816 uri.AddPathSegments("/users/");
6817 uri.AddPathSegment(request.GetUserId());
6818 return UpdateUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
6819 }
6820
UpdateUserCallable(const UpdateUserRequest & request) const6821 UpdateUserOutcomeCallable ChimeClient::UpdateUserCallable(const UpdateUserRequest& request) const
6822 {
6823 auto task = Aws::MakeShared< std::packaged_task< UpdateUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUser(request); } );
6824 auto packagedFunction = [task]() { (*task)(); };
6825 m_executor->Submit(packagedFunction);
6826 return task->get_future();
6827 }
6828
UpdateUserAsync(const UpdateUserRequest & request,const UpdateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6829 void ChimeClient::UpdateUserAsync(const UpdateUserRequest& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6830 {
6831 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserAsyncHelper( request, handler, context ); } );
6832 }
6833
UpdateUserAsyncHelper(const UpdateUserRequest & request,const UpdateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6834 void ChimeClient::UpdateUserAsyncHelper(const UpdateUserRequest& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6835 {
6836 handler(this, request, UpdateUser(request), context);
6837 }
6838
UpdateUserSettings(const UpdateUserSettingsRequest & request) const6839 UpdateUserSettingsOutcome ChimeClient::UpdateUserSettings(const UpdateUserSettingsRequest& request) const
6840 {
6841 if (!request.AccountIdHasBeenSet())
6842 {
6843 AWS_LOGSTREAM_ERROR("UpdateUserSettings", "Required field: AccountId, is not set");
6844 return UpdateUserSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [AccountId]", false));
6845 }
6846 if (!request.UserIdHasBeenSet())
6847 {
6848 AWS_LOGSTREAM_ERROR("UpdateUserSettings", "Required field: UserId, is not set");
6849 return UpdateUserSettingsOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UserId]", false));
6850 }
6851 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6852 uri.AddPathSegments("/accounts/");
6853 uri.AddPathSegment(request.GetAccountId());
6854 uri.AddPathSegments("/users/");
6855 uri.AddPathSegment(request.GetUserId());
6856 uri.AddPathSegments("/settings");
6857 return UpdateUserSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6858 }
6859
UpdateUserSettingsCallable(const UpdateUserSettingsRequest & request) const6860 UpdateUserSettingsOutcomeCallable ChimeClient::UpdateUserSettingsCallable(const UpdateUserSettingsRequest& request) const
6861 {
6862 auto task = Aws::MakeShared< std::packaged_task< UpdateUserSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUserSettings(request); } );
6863 auto packagedFunction = [task]() { (*task)(); };
6864 m_executor->Submit(packagedFunction);
6865 return task->get_future();
6866 }
6867
UpdateUserSettingsAsync(const UpdateUserSettingsRequest & request,const UpdateUserSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6868 void ChimeClient::UpdateUserSettingsAsync(const UpdateUserSettingsRequest& request, const UpdateUserSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6869 {
6870 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserSettingsAsyncHelper( request, handler, context ); } );
6871 }
6872
UpdateUserSettingsAsyncHelper(const UpdateUserSettingsRequest & request,const UpdateUserSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6873 void ChimeClient::UpdateUserSettingsAsyncHelper(const UpdateUserSettingsRequest& request, const UpdateUserSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6874 {
6875 handler(this, request, UpdateUserSettings(request), context);
6876 }
6877
UpdateVoiceConnector(const UpdateVoiceConnectorRequest & request) const6878 UpdateVoiceConnectorOutcome ChimeClient::UpdateVoiceConnector(const UpdateVoiceConnectorRequest& request) const
6879 {
6880 if (!request.VoiceConnectorIdHasBeenSet())
6881 {
6882 AWS_LOGSTREAM_ERROR("UpdateVoiceConnector", "Required field: VoiceConnectorId, is not set");
6883 return UpdateVoiceConnectorOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorId]", false));
6884 }
6885 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6886 uri.AddPathSegments("/voice-connectors/");
6887 uri.AddPathSegment(request.GetVoiceConnectorId());
6888 return UpdateVoiceConnectorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6889 }
6890
UpdateVoiceConnectorCallable(const UpdateVoiceConnectorRequest & request) const6891 UpdateVoiceConnectorOutcomeCallable ChimeClient::UpdateVoiceConnectorCallable(const UpdateVoiceConnectorRequest& request) const
6892 {
6893 auto task = Aws::MakeShared< std::packaged_task< UpdateVoiceConnectorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateVoiceConnector(request); } );
6894 auto packagedFunction = [task]() { (*task)(); };
6895 m_executor->Submit(packagedFunction);
6896 return task->get_future();
6897 }
6898
UpdateVoiceConnectorAsync(const UpdateVoiceConnectorRequest & request,const UpdateVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6899 void ChimeClient::UpdateVoiceConnectorAsync(const UpdateVoiceConnectorRequest& request, const UpdateVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6900 {
6901 m_executor->Submit( [this, request, handler, context](){ this->UpdateVoiceConnectorAsyncHelper( request, handler, context ); } );
6902 }
6903
UpdateVoiceConnectorAsyncHelper(const UpdateVoiceConnectorRequest & request,const UpdateVoiceConnectorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6904 void ChimeClient::UpdateVoiceConnectorAsyncHelper(const UpdateVoiceConnectorRequest& request, const UpdateVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6905 {
6906 handler(this, request, UpdateVoiceConnector(request), context);
6907 }
6908
UpdateVoiceConnectorGroup(const UpdateVoiceConnectorGroupRequest & request) const6909 UpdateVoiceConnectorGroupOutcome ChimeClient::UpdateVoiceConnectorGroup(const UpdateVoiceConnectorGroupRequest& request) const
6910 {
6911 if (!request.VoiceConnectorGroupIdHasBeenSet())
6912 {
6913 AWS_LOGSTREAM_ERROR("UpdateVoiceConnectorGroup", "Required field: VoiceConnectorGroupId, is not set");
6914 return UpdateVoiceConnectorGroupOutcome(Aws::Client::AWSError<ChimeErrors>(ChimeErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VoiceConnectorGroupId]", false));
6915 }
6916 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
6917 uri.AddPathSegments("/voice-connector-groups/");
6918 uri.AddPathSegment(request.GetVoiceConnectorGroupId());
6919 return UpdateVoiceConnectorGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
6920 }
6921
UpdateVoiceConnectorGroupCallable(const UpdateVoiceConnectorGroupRequest & request) const6922 UpdateVoiceConnectorGroupOutcomeCallable ChimeClient::UpdateVoiceConnectorGroupCallable(const UpdateVoiceConnectorGroupRequest& request) const
6923 {
6924 auto task = Aws::MakeShared< std::packaged_task< UpdateVoiceConnectorGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateVoiceConnectorGroup(request); } );
6925 auto packagedFunction = [task]() { (*task)(); };
6926 m_executor->Submit(packagedFunction);
6927 return task->get_future();
6928 }
6929
UpdateVoiceConnectorGroupAsync(const UpdateVoiceConnectorGroupRequest & request,const UpdateVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6930 void ChimeClient::UpdateVoiceConnectorGroupAsync(const UpdateVoiceConnectorGroupRequest& request, const UpdateVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6931 {
6932 m_executor->Submit( [this, request, handler, context](){ this->UpdateVoiceConnectorGroupAsyncHelper( request, handler, context ); } );
6933 }
6934
UpdateVoiceConnectorGroupAsyncHelper(const UpdateVoiceConnectorGroupRequest & request,const UpdateVoiceConnectorGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const6935 void ChimeClient::UpdateVoiceConnectorGroupAsyncHelper(const UpdateVoiceConnectorGroupRequest& request, const UpdateVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
6936 {
6937 handler(this, request, UpdateVoiceConnectorGroup(request), context);
6938 }
6939
6940