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/xml/XmlSerializer.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/iam/IAMClient.h>
21 #include <aws/iam/IAMEndpoint.h>
22 #include <aws/iam/IAMErrorMarshaller.h>
23 #include <aws/iam/model/AddClientIDToOpenIDConnectProviderRequest.h>
24 #include <aws/iam/model/AddRoleToInstanceProfileRequest.h>
25 #include <aws/iam/model/AddUserToGroupRequest.h>
26 #include <aws/iam/model/AttachGroupPolicyRequest.h>
27 #include <aws/iam/model/AttachRolePolicyRequest.h>
28 #include <aws/iam/model/AttachUserPolicyRequest.h>
29 #include <aws/iam/model/ChangePasswordRequest.h>
30 #include <aws/iam/model/CreateAccessKeyRequest.h>
31 #include <aws/iam/model/CreateAccountAliasRequest.h>
32 #include <aws/iam/model/CreateGroupRequest.h>
33 #include <aws/iam/model/CreateInstanceProfileRequest.h>
34 #include <aws/iam/model/CreateLoginProfileRequest.h>
35 #include <aws/iam/model/CreateOpenIDConnectProviderRequest.h>
36 #include <aws/iam/model/CreatePolicyRequest.h>
37 #include <aws/iam/model/CreatePolicyVersionRequest.h>
38 #include <aws/iam/model/CreateRoleRequest.h>
39 #include <aws/iam/model/CreateSAMLProviderRequest.h>
40 #include <aws/iam/model/CreateServiceLinkedRoleRequest.h>
41 #include <aws/iam/model/CreateServiceSpecificCredentialRequest.h>
42 #include <aws/iam/model/CreateUserRequest.h>
43 #include <aws/iam/model/CreateVirtualMFADeviceRequest.h>
44 #include <aws/iam/model/DeactivateMFADeviceRequest.h>
45 #include <aws/iam/model/DeleteAccessKeyRequest.h>
46 #include <aws/iam/model/DeleteAccountAliasRequest.h>
47 #include <aws/iam/model/DeleteAccountPasswordPolicyRequest.h>
48 #include <aws/iam/model/DeleteGroupRequest.h>
49 #include <aws/iam/model/DeleteGroupPolicyRequest.h>
50 #include <aws/iam/model/DeleteInstanceProfileRequest.h>
51 #include <aws/iam/model/DeleteLoginProfileRequest.h>
52 #include <aws/iam/model/DeleteOpenIDConnectProviderRequest.h>
53 #include <aws/iam/model/DeletePolicyRequest.h>
54 #include <aws/iam/model/DeletePolicyVersionRequest.h>
55 #include <aws/iam/model/DeleteRoleRequest.h>
56 #include <aws/iam/model/DeleteRolePermissionsBoundaryRequest.h>
57 #include <aws/iam/model/DeleteRolePolicyRequest.h>
58 #include <aws/iam/model/DeleteSAMLProviderRequest.h>
59 #include <aws/iam/model/DeleteSSHPublicKeyRequest.h>
60 #include <aws/iam/model/DeleteServerCertificateRequest.h>
61 #include <aws/iam/model/DeleteServiceLinkedRoleRequest.h>
62 #include <aws/iam/model/DeleteServiceSpecificCredentialRequest.h>
63 #include <aws/iam/model/DeleteSigningCertificateRequest.h>
64 #include <aws/iam/model/DeleteUserRequest.h>
65 #include <aws/iam/model/DeleteUserPermissionsBoundaryRequest.h>
66 #include <aws/iam/model/DeleteUserPolicyRequest.h>
67 #include <aws/iam/model/DeleteVirtualMFADeviceRequest.h>
68 #include <aws/iam/model/DetachGroupPolicyRequest.h>
69 #include <aws/iam/model/DetachRolePolicyRequest.h>
70 #include <aws/iam/model/DetachUserPolicyRequest.h>
71 #include <aws/iam/model/EnableMFADeviceRequest.h>
72 #include <aws/iam/model/GenerateCredentialReportRequest.h>
73 #include <aws/iam/model/GenerateOrganizationsAccessReportRequest.h>
74 #include <aws/iam/model/GenerateServiceLastAccessedDetailsRequest.h>
75 #include <aws/iam/model/GetAccessKeyLastUsedRequest.h>
76 #include <aws/iam/model/GetAccountAuthorizationDetailsRequest.h>
77 #include <aws/iam/model/GetAccountPasswordPolicyRequest.h>
78 #include <aws/iam/model/GetAccountSummaryRequest.h>
79 #include <aws/iam/model/GetContextKeysForCustomPolicyRequest.h>
80 #include <aws/iam/model/GetContextKeysForPrincipalPolicyRequest.h>
81 #include <aws/iam/model/GetCredentialReportRequest.h>
82 #include <aws/iam/model/GetGroupRequest.h>
83 #include <aws/iam/model/GetGroupPolicyRequest.h>
84 #include <aws/iam/model/GetInstanceProfileRequest.h>
85 #include <aws/iam/model/GetLoginProfileRequest.h>
86 #include <aws/iam/model/GetOpenIDConnectProviderRequest.h>
87 #include <aws/iam/model/GetOrganizationsAccessReportRequest.h>
88 #include <aws/iam/model/GetPolicyRequest.h>
89 #include <aws/iam/model/GetPolicyVersionRequest.h>
90 #include <aws/iam/model/GetRoleRequest.h>
91 #include <aws/iam/model/GetRolePolicyRequest.h>
92 #include <aws/iam/model/GetSAMLProviderRequest.h>
93 #include <aws/iam/model/GetSSHPublicKeyRequest.h>
94 #include <aws/iam/model/GetServerCertificateRequest.h>
95 #include <aws/iam/model/GetServiceLastAccessedDetailsRequest.h>
96 #include <aws/iam/model/GetServiceLastAccessedDetailsWithEntitiesRequest.h>
97 #include <aws/iam/model/GetServiceLinkedRoleDeletionStatusRequest.h>
98 #include <aws/iam/model/GetUserRequest.h>
99 #include <aws/iam/model/GetUserPolicyRequest.h>
100 #include <aws/iam/model/ListAccessKeysRequest.h>
101 #include <aws/iam/model/ListAccountAliasesRequest.h>
102 #include <aws/iam/model/ListAttachedGroupPoliciesRequest.h>
103 #include <aws/iam/model/ListAttachedRolePoliciesRequest.h>
104 #include <aws/iam/model/ListAttachedUserPoliciesRequest.h>
105 #include <aws/iam/model/ListEntitiesForPolicyRequest.h>
106 #include <aws/iam/model/ListGroupPoliciesRequest.h>
107 #include <aws/iam/model/ListGroupsRequest.h>
108 #include <aws/iam/model/ListGroupsForUserRequest.h>
109 #include <aws/iam/model/ListInstanceProfileTagsRequest.h>
110 #include <aws/iam/model/ListInstanceProfilesRequest.h>
111 #include <aws/iam/model/ListInstanceProfilesForRoleRequest.h>
112 #include <aws/iam/model/ListMFADeviceTagsRequest.h>
113 #include <aws/iam/model/ListMFADevicesRequest.h>
114 #include <aws/iam/model/ListOpenIDConnectProviderTagsRequest.h>
115 #include <aws/iam/model/ListOpenIDConnectProvidersRequest.h>
116 #include <aws/iam/model/ListPoliciesRequest.h>
117 #include <aws/iam/model/ListPoliciesGrantingServiceAccessRequest.h>
118 #include <aws/iam/model/ListPolicyTagsRequest.h>
119 #include <aws/iam/model/ListPolicyVersionsRequest.h>
120 #include <aws/iam/model/ListRolePoliciesRequest.h>
121 #include <aws/iam/model/ListRoleTagsRequest.h>
122 #include <aws/iam/model/ListRolesRequest.h>
123 #include <aws/iam/model/ListSAMLProviderTagsRequest.h>
124 #include <aws/iam/model/ListSAMLProvidersRequest.h>
125 #include <aws/iam/model/ListSSHPublicKeysRequest.h>
126 #include <aws/iam/model/ListServerCertificateTagsRequest.h>
127 #include <aws/iam/model/ListServerCertificatesRequest.h>
128 #include <aws/iam/model/ListServiceSpecificCredentialsRequest.h>
129 #include <aws/iam/model/ListSigningCertificatesRequest.h>
130 #include <aws/iam/model/ListUserPoliciesRequest.h>
131 #include <aws/iam/model/ListUserTagsRequest.h>
132 #include <aws/iam/model/ListUsersRequest.h>
133 #include <aws/iam/model/ListVirtualMFADevicesRequest.h>
134 #include <aws/iam/model/PutGroupPolicyRequest.h>
135 #include <aws/iam/model/PutRolePermissionsBoundaryRequest.h>
136 #include <aws/iam/model/PutRolePolicyRequest.h>
137 #include <aws/iam/model/PutUserPermissionsBoundaryRequest.h>
138 #include <aws/iam/model/PutUserPolicyRequest.h>
139 #include <aws/iam/model/RemoveClientIDFromOpenIDConnectProviderRequest.h>
140 #include <aws/iam/model/RemoveRoleFromInstanceProfileRequest.h>
141 #include <aws/iam/model/RemoveUserFromGroupRequest.h>
142 #include <aws/iam/model/ResetServiceSpecificCredentialRequest.h>
143 #include <aws/iam/model/ResyncMFADeviceRequest.h>
144 #include <aws/iam/model/SetDefaultPolicyVersionRequest.h>
145 #include <aws/iam/model/SetSecurityTokenServicePreferencesRequest.h>
146 #include <aws/iam/model/SimulateCustomPolicyRequest.h>
147 #include <aws/iam/model/SimulatePrincipalPolicyRequest.h>
148 #include <aws/iam/model/TagInstanceProfileRequest.h>
149 #include <aws/iam/model/TagMFADeviceRequest.h>
150 #include <aws/iam/model/TagOpenIDConnectProviderRequest.h>
151 #include <aws/iam/model/TagPolicyRequest.h>
152 #include <aws/iam/model/TagRoleRequest.h>
153 #include <aws/iam/model/TagSAMLProviderRequest.h>
154 #include <aws/iam/model/TagServerCertificateRequest.h>
155 #include <aws/iam/model/TagUserRequest.h>
156 #include <aws/iam/model/UntagInstanceProfileRequest.h>
157 #include <aws/iam/model/UntagMFADeviceRequest.h>
158 #include <aws/iam/model/UntagOpenIDConnectProviderRequest.h>
159 #include <aws/iam/model/UntagPolicyRequest.h>
160 #include <aws/iam/model/UntagRoleRequest.h>
161 #include <aws/iam/model/UntagSAMLProviderRequest.h>
162 #include <aws/iam/model/UntagServerCertificateRequest.h>
163 #include <aws/iam/model/UntagUserRequest.h>
164 #include <aws/iam/model/UpdateAccessKeyRequest.h>
165 #include <aws/iam/model/UpdateAccountPasswordPolicyRequest.h>
166 #include <aws/iam/model/UpdateAssumeRolePolicyRequest.h>
167 #include <aws/iam/model/UpdateGroupRequest.h>
168 #include <aws/iam/model/UpdateLoginProfileRequest.h>
169 #include <aws/iam/model/UpdateOpenIDConnectProviderThumbprintRequest.h>
170 #include <aws/iam/model/UpdateRoleRequest.h>
171 #include <aws/iam/model/UpdateRoleDescriptionRequest.h>
172 #include <aws/iam/model/UpdateSAMLProviderRequest.h>
173 #include <aws/iam/model/UpdateSSHPublicKeyRequest.h>
174 #include <aws/iam/model/UpdateServerCertificateRequest.h>
175 #include <aws/iam/model/UpdateServiceSpecificCredentialRequest.h>
176 #include <aws/iam/model/UpdateSigningCertificateRequest.h>
177 #include <aws/iam/model/UpdateUserRequest.h>
178 #include <aws/iam/model/UploadSSHPublicKeyRequest.h>
179 #include <aws/iam/model/UploadServerCertificateRequest.h>
180 #include <aws/iam/model/UploadSigningCertificateRequest.h>
181
182 using namespace Aws;
183 using namespace Aws::Auth;
184 using namespace Aws::Client;
185 using namespace Aws::IAM;
186 using namespace Aws::IAM::Model;
187 using namespace Aws::Http;
188 using namespace Aws::Utils::Xml;
189
190
191 static const char* SERVICE_NAME = "iam";
192 static const char* ALLOCATION_TAG = "IAMClient";
193
194
IAMClient(const Client::ClientConfiguration & clientConfiguration)195 IAMClient::IAMClient(const Client::ClientConfiguration& clientConfiguration) :
196 BASECLASS(clientConfiguration,
197 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
198 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
199 Aws::MakeShared<IAMErrorMarshaller>(ALLOCATION_TAG)),
200 m_executor(clientConfiguration.executor)
201 {
202 init(clientConfiguration);
203 }
204
IAMClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)205 IAMClient::IAMClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
206 BASECLASS(clientConfiguration,
207 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
208 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
209 Aws::MakeShared<IAMErrorMarshaller>(ALLOCATION_TAG)),
210 m_executor(clientConfiguration.executor)
211 {
212 init(clientConfiguration);
213 }
214
IAMClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)215 IAMClient::IAMClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
216 const Client::ClientConfiguration& clientConfiguration) :
217 BASECLASS(clientConfiguration,
218 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
219 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
220 Aws::MakeShared<IAMErrorMarshaller>(ALLOCATION_TAG)),
221 m_executor(clientConfiguration.executor)
222 {
223 init(clientConfiguration);
224 }
225
~IAMClient()226 IAMClient::~IAMClient()
227 {
228 }
229
init(const Client::ClientConfiguration & config)230 void IAMClient::init(const Client::ClientConfiguration& config)
231 {
232 SetServiceClientName("IAM");
233 m_configScheme = SchemeMapper::ToString(config.scheme);
234 if (config.endpointOverride.empty())
235 {
236 m_uri = m_configScheme + "://" + IAMEndpoint::ForRegion(config.region, config.useDualStack);
237 }
238 else
239 {
240 OverrideEndpoint(config.endpointOverride);
241 }
242 }
243
OverrideEndpoint(const Aws::String & endpoint)244 void IAMClient::OverrideEndpoint(const Aws::String& endpoint)
245 {
246 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
247 {
248 m_uri = endpoint;
249 }
250 else
251 {
252 m_uri = m_configScheme + "://" + endpoint;
253 }
254 }
255
ConvertRequestToPresignedUrl(const AmazonSerializableWebServiceRequest & requestToConvert,const char * region) const256 Aws::String IAMClient::ConvertRequestToPresignedUrl(const AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const
257 {
258 Aws::StringStream ss;
259 ss << "https://" << IAMEndpoint::ForRegion(region);
260 ss << "?" << requestToConvert.SerializePayload();
261
262 URI uri(ss.str());
263 return GeneratePresignedUrl(uri, Aws::Http::HttpMethod::HTTP_GET, region, 3600);
264 }
265
AddClientIDToOpenIDConnectProvider(const AddClientIDToOpenIDConnectProviderRequest & request) const266 AddClientIDToOpenIDConnectProviderOutcome IAMClient::AddClientIDToOpenIDConnectProvider(const AddClientIDToOpenIDConnectProviderRequest& request) const
267 {
268 Aws::Http::URI uri = m_uri;
269 return AddClientIDToOpenIDConnectProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
270 }
271
AddClientIDToOpenIDConnectProviderCallable(const AddClientIDToOpenIDConnectProviderRequest & request) const272 AddClientIDToOpenIDConnectProviderOutcomeCallable IAMClient::AddClientIDToOpenIDConnectProviderCallable(const AddClientIDToOpenIDConnectProviderRequest& request) const
273 {
274 auto task = Aws::MakeShared< std::packaged_task< AddClientIDToOpenIDConnectProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AddClientIDToOpenIDConnectProvider(request); } );
275 auto packagedFunction = [task]() { (*task)(); };
276 m_executor->Submit(packagedFunction);
277 return task->get_future();
278 }
279
AddClientIDToOpenIDConnectProviderAsync(const AddClientIDToOpenIDConnectProviderRequest & request,const AddClientIDToOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const280 void IAMClient::AddClientIDToOpenIDConnectProviderAsync(const AddClientIDToOpenIDConnectProviderRequest& request, const AddClientIDToOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
281 {
282 m_executor->Submit( [this, request, handler, context](){ this->AddClientIDToOpenIDConnectProviderAsyncHelper( request, handler, context ); } );
283 }
284
AddClientIDToOpenIDConnectProviderAsyncHelper(const AddClientIDToOpenIDConnectProviderRequest & request,const AddClientIDToOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const285 void IAMClient::AddClientIDToOpenIDConnectProviderAsyncHelper(const AddClientIDToOpenIDConnectProviderRequest& request, const AddClientIDToOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
286 {
287 handler(this, request, AddClientIDToOpenIDConnectProvider(request), context);
288 }
289
AddRoleToInstanceProfile(const AddRoleToInstanceProfileRequest & request) const290 AddRoleToInstanceProfileOutcome IAMClient::AddRoleToInstanceProfile(const AddRoleToInstanceProfileRequest& request) const
291 {
292 Aws::Http::URI uri = m_uri;
293 return AddRoleToInstanceProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
294 }
295
AddRoleToInstanceProfileCallable(const AddRoleToInstanceProfileRequest & request) const296 AddRoleToInstanceProfileOutcomeCallable IAMClient::AddRoleToInstanceProfileCallable(const AddRoleToInstanceProfileRequest& request) const
297 {
298 auto task = Aws::MakeShared< std::packaged_task< AddRoleToInstanceProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AddRoleToInstanceProfile(request); } );
299 auto packagedFunction = [task]() { (*task)(); };
300 m_executor->Submit(packagedFunction);
301 return task->get_future();
302 }
303
AddRoleToInstanceProfileAsync(const AddRoleToInstanceProfileRequest & request,const AddRoleToInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const304 void IAMClient::AddRoleToInstanceProfileAsync(const AddRoleToInstanceProfileRequest& request, const AddRoleToInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
305 {
306 m_executor->Submit( [this, request, handler, context](){ this->AddRoleToInstanceProfileAsyncHelper( request, handler, context ); } );
307 }
308
AddRoleToInstanceProfileAsyncHelper(const AddRoleToInstanceProfileRequest & request,const AddRoleToInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const309 void IAMClient::AddRoleToInstanceProfileAsyncHelper(const AddRoleToInstanceProfileRequest& request, const AddRoleToInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
310 {
311 handler(this, request, AddRoleToInstanceProfile(request), context);
312 }
313
AddUserToGroup(const AddUserToGroupRequest & request) const314 AddUserToGroupOutcome IAMClient::AddUserToGroup(const AddUserToGroupRequest& request) const
315 {
316 Aws::Http::URI uri = m_uri;
317 return AddUserToGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
318 }
319
AddUserToGroupCallable(const AddUserToGroupRequest & request) const320 AddUserToGroupOutcomeCallable IAMClient::AddUserToGroupCallable(const AddUserToGroupRequest& request) const
321 {
322 auto task = Aws::MakeShared< std::packaged_task< AddUserToGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AddUserToGroup(request); } );
323 auto packagedFunction = [task]() { (*task)(); };
324 m_executor->Submit(packagedFunction);
325 return task->get_future();
326 }
327
AddUserToGroupAsync(const AddUserToGroupRequest & request,const AddUserToGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const328 void IAMClient::AddUserToGroupAsync(const AddUserToGroupRequest& request, const AddUserToGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
329 {
330 m_executor->Submit( [this, request, handler, context](){ this->AddUserToGroupAsyncHelper( request, handler, context ); } );
331 }
332
AddUserToGroupAsyncHelper(const AddUserToGroupRequest & request,const AddUserToGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const333 void IAMClient::AddUserToGroupAsyncHelper(const AddUserToGroupRequest& request, const AddUserToGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
334 {
335 handler(this, request, AddUserToGroup(request), context);
336 }
337
AttachGroupPolicy(const AttachGroupPolicyRequest & request) const338 AttachGroupPolicyOutcome IAMClient::AttachGroupPolicy(const AttachGroupPolicyRequest& request) const
339 {
340 Aws::Http::URI uri = m_uri;
341 return AttachGroupPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
342 }
343
AttachGroupPolicyCallable(const AttachGroupPolicyRequest & request) const344 AttachGroupPolicyOutcomeCallable IAMClient::AttachGroupPolicyCallable(const AttachGroupPolicyRequest& request) const
345 {
346 auto task = Aws::MakeShared< std::packaged_task< AttachGroupPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AttachGroupPolicy(request); } );
347 auto packagedFunction = [task]() { (*task)(); };
348 m_executor->Submit(packagedFunction);
349 return task->get_future();
350 }
351
AttachGroupPolicyAsync(const AttachGroupPolicyRequest & request,const AttachGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const352 void IAMClient::AttachGroupPolicyAsync(const AttachGroupPolicyRequest& request, const AttachGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
353 {
354 m_executor->Submit( [this, request, handler, context](){ this->AttachGroupPolicyAsyncHelper( request, handler, context ); } );
355 }
356
AttachGroupPolicyAsyncHelper(const AttachGroupPolicyRequest & request,const AttachGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const357 void IAMClient::AttachGroupPolicyAsyncHelper(const AttachGroupPolicyRequest& request, const AttachGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
358 {
359 handler(this, request, AttachGroupPolicy(request), context);
360 }
361
AttachRolePolicy(const AttachRolePolicyRequest & request) const362 AttachRolePolicyOutcome IAMClient::AttachRolePolicy(const AttachRolePolicyRequest& request) const
363 {
364 Aws::Http::URI uri = m_uri;
365 return AttachRolePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
366 }
367
AttachRolePolicyCallable(const AttachRolePolicyRequest & request) const368 AttachRolePolicyOutcomeCallable IAMClient::AttachRolePolicyCallable(const AttachRolePolicyRequest& request) const
369 {
370 auto task = Aws::MakeShared< std::packaged_task< AttachRolePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AttachRolePolicy(request); } );
371 auto packagedFunction = [task]() { (*task)(); };
372 m_executor->Submit(packagedFunction);
373 return task->get_future();
374 }
375
AttachRolePolicyAsync(const AttachRolePolicyRequest & request,const AttachRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const376 void IAMClient::AttachRolePolicyAsync(const AttachRolePolicyRequest& request, const AttachRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
377 {
378 m_executor->Submit( [this, request, handler, context](){ this->AttachRolePolicyAsyncHelper( request, handler, context ); } );
379 }
380
AttachRolePolicyAsyncHelper(const AttachRolePolicyRequest & request,const AttachRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const381 void IAMClient::AttachRolePolicyAsyncHelper(const AttachRolePolicyRequest& request, const AttachRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
382 {
383 handler(this, request, AttachRolePolicy(request), context);
384 }
385
AttachUserPolicy(const AttachUserPolicyRequest & request) const386 AttachUserPolicyOutcome IAMClient::AttachUserPolicy(const AttachUserPolicyRequest& request) const
387 {
388 Aws::Http::URI uri = m_uri;
389 return AttachUserPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
390 }
391
AttachUserPolicyCallable(const AttachUserPolicyRequest & request) const392 AttachUserPolicyOutcomeCallable IAMClient::AttachUserPolicyCallable(const AttachUserPolicyRequest& request) const
393 {
394 auto task = Aws::MakeShared< std::packaged_task< AttachUserPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AttachUserPolicy(request); } );
395 auto packagedFunction = [task]() { (*task)(); };
396 m_executor->Submit(packagedFunction);
397 return task->get_future();
398 }
399
AttachUserPolicyAsync(const AttachUserPolicyRequest & request,const AttachUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const400 void IAMClient::AttachUserPolicyAsync(const AttachUserPolicyRequest& request, const AttachUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
401 {
402 m_executor->Submit( [this, request, handler, context](){ this->AttachUserPolicyAsyncHelper( request, handler, context ); } );
403 }
404
AttachUserPolicyAsyncHelper(const AttachUserPolicyRequest & request,const AttachUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const405 void IAMClient::AttachUserPolicyAsyncHelper(const AttachUserPolicyRequest& request, const AttachUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
406 {
407 handler(this, request, AttachUserPolicy(request), context);
408 }
409
ChangePassword(const ChangePasswordRequest & request) const410 ChangePasswordOutcome IAMClient::ChangePassword(const ChangePasswordRequest& request) const
411 {
412 Aws::Http::URI uri = m_uri;
413 return ChangePasswordOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
414 }
415
ChangePasswordCallable(const ChangePasswordRequest & request) const416 ChangePasswordOutcomeCallable IAMClient::ChangePasswordCallable(const ChangePasswordRequest& request) const
417 {
418 auto task = Aws::MakeShared< std::packaged_task< ChangePasswordOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ChangePassword(request); } );
419 auto packagedFunction = [task]() { (*task)(); };
420 m_executor->Submit(packagedFunction);
421 return task->get_future();
422 }
423
ChangePasswordAsync(const ChangePasswordRequest & request,const ChangePasswordResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const424 void IAMClient::ChangePasswordAsync(const ChangePasswordRequest& request, const ChangePasswordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
425 {
426 m_executor->Submit( [this, request, handler, context](){ this->ChangePasswordAsyncHelper( request, handler, context ); } );
427 }
428
ChangePasswordAsyncHelper(const ChangePasswordRequest & request,const ChangePasswordResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const429 void IAMClient::ChangePasswordAsyncHelper(const ChangePasswordRequest& request, const ChangePasswordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
430 {
431 handler(this, request, ChangePassword(request), context);
432 }
433
CreateAccessKey(const CreateAccessKeyRequest & request) const434 CreateAccessKeyOutcome IAMClient::CreateAccessKey(const CreateAccessKeyRequest& request) const
435 {
436 Aws::Http::URI uri = m_uri;
437 return CreateAccessKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
438 }
439
CreateAccessKeyCallable(const CreateAccessKeyRequest & request) const440 CreateAccessKeyOutcomeCallable IAMClient::CreateAccessKeyCallable(const CreateAccessKeyRequest& request) const
441 {
442 auto task = Aws::MakeShared< std::packaged_task< CreateAccessKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAccessKey(request); } );
443 auto packagedFunction = [task]() { (*task)(); };
444 m_executor->Submit(packagedFunction);
445 return task->get_future();
446 }
447
CreateAccessKeyAsync(const CreateAccessKeyRequest & request,const CreateAccessKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const448 void IAMClient::CreateAccessKeyAsync(const CreateAccessKeyRequest& request, const CreateAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
449 {
450 m_executor->Submit( [this, request, handler, context](){ this->CreateAccessKeyAsyncHelper( request, handler, context ); } );
451 }
452
CreateAccessKeyAsyncHelper(const CreateAccessKeyRequest & request,const CreateAccessKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const453 void IAMClient::CreateAccessKeyAsyncHelper(const CreateAccessKeyRequest& request, const CreateAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
454 {
455 handler(this, request, CreateAccessKey(request), context);
456 }
457
CreateAccountAlias(const CreateAccountAliasRequest & request) const458 CreateAccountAliasOutcome IAMClient::CreateAccountAlias(const CreateAccountAliasRequest& request) const
459 {
460 Aws::Http::URI uri = m_uri;
461 return CreateAccountAliasOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
462 }
463
CreateAccountAliasCallable(const CreateAccountAliasRequest & request) const464 CreateAccountAliasOutcomeCallable IAMClient::CreateAccountAliasCallable(const CreateAccountAliasRequest& request) const
465 {
466 auto task = Aws::MakeShared< std::packaged_task< CreateAccountAliasOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAccountAlias(request); } );
467 auto packagedFunction = [task]() { (*task)(); };
468 m_executor->Submit(packagedFunction);
469 return task->get_future();
470 }
471
CreateAccountAliasAsync(const CreateAccountAliasRequest & request,const CreateAccountAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const472 void IAMClient::CreateAccountAliasAsync(const CreateAccountAliasRequest& request, const CreateAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
473 {
474 m_executor->Submit( [this, request, handler, context](){ this->CreateAccountAliasAsyncHelper( request, handler, context ); } );
475 }
476
CreateAccountAliasAsyncHelper(const CreateAccountAliasRequest & request,const CreateAccountAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const477 void IAMClient::CreateAccountAliasAsyncHelper(const CreateAccountAliasRequest& request, const CreateAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
478 {
479 handler(this, request, CreateAccountAlias(request), context);
480 }
481
CreateGroup(const CreateGroupRequest & request) const482 CreateGroupOutcome IAMClient::CreateGroup(const CreateGroupRequest& request) const
483 {
484 Aws::Http::URI uri = m_uri;
485 return CreateGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
486 }
487
CreateGroupCallable(const CreateGroupRequest & request) const488 CreateGroupOutcomeCallable IAMClient::CreateGroupCallable(const CreateGroupRequest& request) const
489 {
490 auto task = Aws::MakeShared< std::packaged_task< CreateGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateGroup(request); } );
491 auto packagedFunction = [task]() { (*task)(); };
492 m_executor->Submit(packagedFunction);
493 return task->get_future();
494 }
495
CreateGroupAsync(const CreateGroupRequest & request,const CreateGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const496 void IAMClient::CreateGroupAsync(const CreateGroupRequest& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
497 {
498 m_executor->Submit( [this, request, handler, context](){ this->CreateGroupAsyncHelper( request, handler, context ); } );
499 }
500
CreateGroupAsyncHelper(const CreateGroupRequest & request,const CreateGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const501 void IAMClient::CreateGroupAsyncHelper(const CreateGroupRequest& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
502 {
503 handler(this, request, CreateGroup(request), context);
504 }
505
CreateInstanceProfile(const CreateInstanceProfileRequest & request) const506 CreateInstanceProfileOutcome IAMClient::CreateInstanceProfile(const CreateInstanceProfileRequest& request) const
507 {
508 Aws::Http::URI uri = m_uri;
509 return CreateInstanceProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
510 }
511
CreateInstanceProfileCallable(const CreateInstanceProfileRequest & request) const512 CreateInstanceProfileOutcomeCallable IAMClient::CreateInstanceProfileCallable(const CreateInstanceProfileRequest& request) const
513 {
514 auto task = Aws::MakeShared< std::packaged_task< CreateInstanceProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateInstanceProfile(request); } );
515 auto packagedFunction = [task]() { (*task)(); };
516 m_executor->Submit(packagedFunction);
517 return task->get_future();
518 }
519
CreateInstanceProfileAsync(const CreateInstanceProfileRequest & request,const CreateInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const520 void IAMClient::CreateInstanceProfileAsync(const CreateInstanceProfileRequest& request, const CreateInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
521 {
522 m_executor->Submit( [this, request, handler, context](){ this->CreateInstanceProfileAsyncHelper( request, handler, context ); } );
523 }
524
CreateInstanceProfileAsyncHelper(const CreateInstanceProfileRequest & request,const CreateInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const525 void IAMClient::CreateInstanceProfileAsyncHelper(const CreateInstanceProfileRequest& request, const CreateInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
526 {
527 handler(this, request, CreateInstanceProfile(request), context);
528 }
529
CreateLoginProfile(const CreateLoginProfileRequest & request) const530 CreateLoginProfileOutcome IAMClient::CreateLoginProfile(const CreateLoginProfileRequest& request) const
531 {
532 Aws::Http::URI uri = m_uri;
533 return CreateLoginProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
534 }
535
CreateLoginProfileCallable(const CreateLoginProfileRequest & request) const536 CreateLoginProfileOutcomeCallable IAMClient::CreateLoginProfileCallable(const CreateLoginProfileRequest& request) const
537 {
538 auto task = Aws::MakeShared< std::packaged_task< CreateLoginProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateLoginProfile(request); } );
539 auto packagedFunction = [task]() { (*task)(); };
540 m_executor->Submit(packagedFunction);
541 return task->get_future();
542 }
543
CreateLoginProfileAsync(const CreateLoginProfileRequest & request,const CreateLoginProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const544 void IAMClient::CreateLoginProfileAsync(const CreateLoginProfileRequest& request, const CreateLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
545 {
546 m_executor->Submit( [this, request, handler, context](){ this->CreateLoginProfileAsyncHelper( request, handler, context ); } );
547 }
548
CreateLoginProfileAsyncHelper(const CreateLoginProfileRequest & request,const CreateLoginProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const549 void IAMClient::CreateLoginProfileAsyncHelper(const CreateLoginProfileRequest& request, const CreateLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
550 {
551 handler(this, request, CreateLoginProfile(request), context);
552 }
553
CreateOpenIDConnectProvider(const CreateOpenIDConnectProviderRequest & request) const554 CreateOpenIDConnectProviderOutcome IAMClient::CreateOpenIDConnectProvider(const CreateOpenIDConnectProviderRequest& request) const
555 {
556 Aws::Http::URI uri = m_uri;
557 return CreateOpenIDConnectProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
558 }
559
CreateOpenIDConnectProviderCallable(const CreateOpenIDConnectProviderRequest & request) const560 CreateOpenIDConnectProviderOutcomeCallable IAMClient::CreateOpenIDConnectProviderCallable(const CreateOpenIDConnectProviderRequest& request) const
561 {
562 auto task = Aws::MakeShared< std::packaged_task< CreateOpenIDConnectProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateOpenIDConnectProvider(request); } );
563 auto packagedFunction = [task]() { (*task)(); };
564 m_executor->Submit(packagedFunction);
565 return task->get_future();
566 }
567
CreateOpenIDConnectProviderAsync(const CreateOpenIDConnectProviderRequest & request,const CreateOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const568 void IAMClient::CreateOpenIDConnectProviderAsync(const CreateOpenIDConnectProviderRequest& request, const CreateOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
569 {
570 m_executor->Submit( [this, request, handler, context](){ this->CreateOpenIDConnectProviderAsyncHelper( request, handler, context ); } );
571 }
572
CreateOpenIDConnectProviderAsyncHelper(const CreateOpenIDConnectProviderRequest & request,const CreateOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const573 void IAMClient::CreateOpenIDConnectProviderAsyncHelper(const CreateOpenIDConnectProviderRequest& request, const CreateOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
574 {
575 handler(this, request, CreateOpenIDConnectProvider(request), context);
576 }
577
CreatePolicy(const CreatePolicyRequest & request) const578 CreatePolicyOutcome IAMClient::CreatePolicy(const CreatePolicyRequest& request) const
579 {
580 Aws::Http::URI uri = m_uri;
581 return CreatePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
582 }
583
CreatePolicyCallable(const CreatePolicyRequest & request) const584 CreatePolicyOutcomeCallable IAMClient::CreatePolicyCallable(const CreatePolicyRequest& request) const
585 {
586 auto task = Aws::MakeShared< std::packaged_task< CreatePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreatePolicy(request); } );
587 auto packagedFunction = [task]() { (*task)(); };
588 m_executor->Submit(packagedFunction);
589 return task->get_future();
590 }
591
CreatePolicyAsync(const CreatePolicyRequest & request,const CreatePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const592 void IAMClient::CreatePolicyAsync(const CreatePolicyRequest& request, const CreatePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
593 {
594 m_executor->Submit( [this, request, handler, context](){ this->CreatePolicyAsyncHelper( request, handler, context ); } );
595 }
596
CreatePolicyAsyncHelper(const CreatePolicyRequest & request,const CreatePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const597 void IAMClient::CreatePolicyAsyncHelper(const CreatePolicyRequest& request, const CreatePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
598 {
599 handler(this, request, CreatePolicy(request), context);
600 }
601
CreatePolicyVersion(const CreatePolicyVersionRequest & request) const602 CreatePolicyVersionOutcome IAMClient::CreatePolicyVersion(const CreatePolicyVersionRequest& request) const
603 {
604 Aws::Http::URI uri = m_uri;
605 return CreatePolicyVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
606 }
607
CreatePolicyVersionCallable(const CreatePolicyVersionRequest & request) const608 CreatePolicyVersionOutcomeCallable IAMClient::CreatePolicyVersionCallable(const CreatePolicyVersionRequest& request) const
609 {
610 auto task = Aws::MakeShared< std::packaged_task< CreatePolicyVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreatePolicyVersion(request); } );
611 auto packagedFunction = [task]() { (*task)(); };
612 m_executor->Submit(packagedFunction);
613 return task->get_future();
614 }
615
CreatePolicyVersionAsync(const CreatePolicyVersionRequest & request,const CreatePolicyVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const616 void IAMClient::CreatePolicyVersionAsync(const CreatePolicyVersionRequest& request, const CreatePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
617 {
618 m_executor->Submit( [this, request, handler, context](){ this->CreatePolicyVersionAsyncHelper( request, handler, context ); } );
619 }
620
CreatePolicyVersionAsyncHelper(const CreatePolicyVersionRequest & request,const CreatePolicyVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const621 void IAMClient::CreatePolicyVersionAsyncHelper(const CreatePolicyVersionRequest& request, const CreatePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
622 {
623 handler(this, request, CreatePolicyVersion(request), context);
624 }
625
CreateRole(const CreateRoleRequest & request) const626 CreateRoleOutcome IAMClient::CreateRole(const CreateRoleRequest& request) const
627 {
628 Aws::Http::URI uri = m_uri;
629 return CreateRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
630 }
631
CreateRoleCallable(const CreateRoleRequest & request) const632 CreateRoleOutcomeCallable IAMClient::CreateRoleCallable(const CreateRoleRequest& request) const
633 {
634 auto task = Aws::MakeShared< std::packaged_task< CreateRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateRole(request); } );
635 auto packagedFunction = [task]() { (*task)(); };
636 m_executor->Submit(packagedFunction);
637 return task->get_future();
638 }
639
CreateRoleAsync(const CreateRoleRequest & request,const CreateRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const640 void IAMClient::CreateRoleAsync(const CreateRoleRequest& request, const CreateRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
641 {
642 m_executor->Submit( [this, request, handler, context](){ this->CreateRoleAsyncHelper( request, handler, context ); } );
643 }
644
CreateRoleAsyncHelper(const CreateRoleRequest & request,const CreateRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const645 void IAMClient::CreateRoleAsyncHelper(const CreateRoleRequest& request, const CreateRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
646 {
647 handler(this, request, CreateRole(request), context);
648 }
649
CreateSAMLProvider(const CreateSAMLProviderRequest & request) const650 CreateSAMLProviderOutcome IAMClient::CreateSAMLProvider(const CreateSAMLProviderRequest& request) const
651 {
652 Aws::Http::URI uri = m_uri;
653 return CreateSAMLProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
654 }
655
CreateSAMLProviderCallable(const CreateSAMLProviderRequest & request) const656 CreateSAMLProviderOutcomeCallable IAMClient::CreateSAMLProviderCallable(const CreateSAMLProviderRequest& request) const
657 {
658 auto task = Aws::MakeShared< std::packaged_task< CreateSAMLProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateSAMLProvider(request); } );
659 auto packagedFunction = [task]() { (*task)(); };
660 m_executor->Submit(packagedFunction);
661 return task->get_future();
662 }
663
CreateSAMLProviderAsync(const CreateSAMLProviderRequest & request,const CreateSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const664 void IAMClient::CreateSAMLProviderAsync(const CreateSAMLProviderRequest& request, const CreateSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
665 {
666 m_executor->Submit( [this, request, handler, context](){ this->CreateSAMLProviderAsyncHelper( request, handler, context ); } );
667 }
668
CreateSAMLProviderAsyncHelper(const CreateSAMLProviderRequest & request,const CreateSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const669 void IAMClient::CreateSAMLProviderAsyncHelper(const CreateSAMLProviderRequest& request, const CreateSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
670 {
671 handler(this, request, CreateSAMLProvider(request), context);
672 }
673
CreateServiceLinkedRole(const CreateServiceLinkedRoleRequest & request) const674 CreateServiceLinkedRoleOutcome IAMClient::CreateServiceLinkedRole(const CreateServiceLinkedRoleRequest& request) const
675 {
676 Aws::Http::URI uri = m_uri;
677 return CreateServiceLinkedRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
678 }
679
CreateServiceLinkedRoleCallable(const CreateServiceLinkedRoleRequest & request) const680 CreateServiceLinkedRoleOutcomeCallable IAMClient::CreateServiceLinkedRoleCallable(const CreateServiceLinkedRoleRequest& request) const
681 {
682 auto task = Aws::MakeShared< std::packaged_task< CreateServiceLinkedRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateServiceLinkedRole(request); } );
683 auto packagedFunction = [task]() { (*task)(); };
684 m_executor->Submit(packagedFunction);
685 return task->get_future();
686 }
687
CreateServiceLinkedRoleAsync(const CreateServiceLinkedRoleRequest & request,const CreateServiceLinkedRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const688 void IAMClient::CreateServiceLinkedRoleAsync(const CreateServiceLinkedRoleRequest& request, const CreateServiceLinkedRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
689 {
690 m_executor->Submit( [this, request, handler, context](){ this->CreateServiceLinkedRoleAsyncHelper( request, handler, context ); } );
691 }
692
CreateServiceLinkedRoleAsyncHelper(const CreateServiceLinkedRoleRequest & request,const CreateServiceLinkedRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const693 void IAMClient::CreateServiceLinkedRoleAsyncHelper(const CreateServiceLinkedRoleRequest& request, const CreateServiceLinkedRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
694 {
695 handler(this, request, CreateServiceLinkedRole(request), context);
696 }
697
CreateServiceSpecificCredential(const CreateServiceSpecificCredentialRequest & request) const698 CreateServiceSpecificCredentialOutcome IAMClient::CreateServiceSpecificCredential(const CreateServiceSpecificCredentialRequest& request) const
699 {
700 Aws::Http::URI uri = m_uri;
701 return CreateServiceSpecificCredentialOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
702 }
703
CreateServiceSpecificCredentialCallable(const CreateServiceSpecificCredentialRequest & request) const704 CreateServiceSpecificCredentialOutcomeCallable IAMClient::CreateServiceSpecificCredentialCallable(const CreateServiceSpecificCredentialRequest& request) const
705 {
706 auto task = Aws::MakeShared< std::packaged_task< CreateServiceSpecificCredentialOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateServiceSpecificCredential(request); } );
707 auto packagedFunction = [task]() { (*task)(); };
708 m_executor->Submit(packagedFunction);
709 return task->get_future();
710 }
711
CreateServiceSpecificCredentialAsync(const CreateServiceSpecificCredentialRequest & request,const CreateServiceSpecificCredentialResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const712 void IAMClient::CreateServiceSpecificCredentialAsync(const CreateServiceSpecificCredentialRequest& request, const CreateServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
713 {
714 m_executor->Submit( [this, request, handler, context](){ this->CreateServiceSpecificCredentialAsyncHelper( request, handler, context ); } );
715 }
716
CreateServiceSpecificCredentialAsyncHelper(const CreateServiceSpecificCredentialRequest & request,const CreateServiceSpecificCredentialResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const717 void IAMClient::CreateServiceSpecificCredentialAsyncHelper(const CreateServiceSpecificCredentialRequest& request, const CreateServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
718 {
719 handler(this, request, CreateServiceSpecificCredential(request), context);
720 }
721
CreateUser(const CreateUserRequest & request) const722 CreateUserOutcome IAMClient::CreateUser(const CreateUserRequest& request) const
723 {
724 Aws::Http::URI uri = m_uri;
725 return CreateUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
726 }
727
CreateUserCallable(const CreateUserRequest & request) const728 CreateUserOutcomeCallable IAMClient::CreateUserCallable(const CreateUserRequest& request) const
729 {
730 auto task = Aws::MakeShared< std::packaged_task< CreateUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateUser(request); } );
731 auto packagedFunction = [task]() { (*task)(); };
732 m_executor->Submit(packagedFunction);
733 return task->get_future();
734 }
735
CreateUserAsync(const CreateUserRequest & request,const CreateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const736 void IAMClient::CreateUserAsync(const CreateUserRequest& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
737 {
738 m_executor->Submit( [this, request, handler, context](){ this->CreateUserAsyncHelper( request, handler, context ); } );
739 }
740
CreateUserAsyncHelper(const CreateUserRequest & request,const CreateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const741 void IAMClient::CreateUserAsyncHelper(const CreateUserRequest& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
742 {
743 handler(this, request, CreateUser(request), context);
744 }
745
CreateVirtualMFADevice(const CreateVirtualMFADeviceRequest & request) const746 CreateVirtualMFADeviceOutcome IAMClient::CreateVirtualMFADevice(const CreateVirtualMFADeviceRequest& request) const
747 {
748 Aws::Http::URI uri = m_uri;
749 return CreateVirtualMFADeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
750 }
751
CreateVirtualMFADeviceCallable(const CreateVirtualMFADeviceRequest & request) const752 CreateVirtualMFADeviceOutcomeCallable IAMClient::CreateVirtualMFADeviceCallable(const CreateVirtualMFADeviceRequest& request) const
753 {
754 auto task = Aws::MakeShared< std::packaged_task< CreateVirtualMFADeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateVirtualMFADevice(request); } );
755 auto packagedFunction = [task]() { (*task)(); };
756 m_executor->Submit(packagedFunction);
757 return task->get_future();
758 }
759
CreateVirtualMFADeviceAsync(const CreateVirtualMFADeviceRequest & request,const CreateVirtualMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const760 void IAMClient::CreateVirtualMFADeviceAsync(const CreateVirtualMFADeviceRequest& request, const CreateVirtualMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
761 {
762 m_executor->Submit( [this, request, handler, context](){ this->CreateVirtualMFADeviceAsyncHelper( request, handler, context ); } );
763 }
764
CreateVirtualMFADeviceAsyncHelper(const CreateVirtualMFADeviceRequest & request,const CreateVirtualMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const765 void IAMClient::CreateVirtualMFADeviceAsyncHelper(const CreateVirtualMFADeviceRequest& request, const CreateVirtualMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
766 {
767 handler(this, request, CreateVirtualMFADevice(request), context);
768 }
769
DeactivateMFADevice(const DeactivateMFADeviceRequest & request) const770 DeactivateMFADeviceOutcome IAMClient::DeactivateMFADevice(const DeactivateMFADeviceRequest& request) const
771 {
772 Aws::Http::URI uri = m_uri;
773 return DeactivateMFADeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
774 }
775
DeactivateMFADeviceCallable(const DeactivateMFADeviceRequest & request) const776 DeactivateMFADeviceOutcomeCallable IAMClient::DeactivateMFADeviceCallable(const DeactivateMFADeviceRequest& request) const
777 {
778 auto task = Aws::MakeShared< std::packaged_task< DeactivateMFADeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeactivateMFADevice(request); } );
779 auto packagedFunction = [task]() { (*task)(); };
780 m_executor->Submit(packagedFunction);
781 return task->get_future();
782 }
783
DeactivateMFADeviceAsync(const DeactivateMFADeviceRequest & request,const DeactivateMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const784 void IAMClient::DeactivateMFADeviceAsync(const DeactivateMFADeviceRequest& request, const DeactivateMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
785 {
786 m_executor->Submit( [this, request, handler, context](){ this->DeactivateMFADeviceAsyncHelper( request, handler, context ); } );
787 }
788
DeactivateMFADeviceAsyncHelper(const DeactivateMFADeviceRequest & request,const DeactivateMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const789 void IAMClient::DeactivateMFADeviceAsyncHelper(const DeactivateMFADeviceRequest& request, const DeactivateMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
790 {
791 handler(this, request, DeactivateMFADevice(request), context);
792 }
793
DeleteAccessKey(const DeleteAccessKeyRequest & request) const794 DeleteAccessKeyOutcome IAMClient::DeleteAccessKey(const DeleteAccessKeyRequest& request) const
795 {
796 Aws::Http::URI uri = m_uri;
797 return DeleteAccessKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
798 }
799
DeleteAccessKeyCallable(const DeleteAccessKeyRequest & request) const800 DeleteAccessKeyOutcomeCallable IAMClient::DeleteAccessKeyCallable(const DeleteAccessKeyRequest& request) const
801 {
802 auto task = Aws::MakeShared< std::packaged_task< DeleteAccessKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAccessKey(request); } );
803 auto packagedFunction = [task]() { (*task)(); };
804 m_executor->Submit(packagedFunction);
805 return task->get_future();
806 }
807
DeleteAccessKeyAsync(const DeleteAccessKeyRequest & request,const DeleteAccessKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const808 void IAMClient::DeleteAccessKeyAsync(const DeleteAccessKeyRequest& request, const DeleteAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
809 {
810 m_executor->Submit( [this, request, handler, context](){ this->DeleteAccessKeyAsyncHelper( request, handler, context ); } );
811 }
812
DeleteAccessKeyAsyncHelper(const DeleteAccessKeyRequest & request,const DeleteAccessKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const813 void IAMClient::DeleteAccessKeyAsyncHelper(const DeleteAccessKeyRequest& request, const DeleteAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
814 {
815 handler(this, request, DeleteAccessKey(request), context);
816 }
817
DeleteAccountAlias(const DeleteAccountAliasRequest & request) const818 DeleteAccountAliasOutcome IAMClient::DeleteAccountAlias(const DeleteAccountAliasRequest& request) const
819 {
820 Aws::Http::URI uri = m_uri;
821 return DeleteAccountAliasOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
822 }
823
DeleteAccountAliasCallable(const DeleteAccountAliasRequest & request) const824 DeleteAccountAliasOutcomeCallable IAMClient::DeleteAccountAliasCallable(const DeleteAccountAliasRequest& request) const
825 {
826 auto task = Aws::MakeShared< std::packaged_task< DeleteAccountAliasOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAccountAlias(request); } );
827 auto packagedFunction = [task]() { (*task)(); };
828 m_executor->Submit(packagedFunction);
829 return task->get_future();
830 }
831
DeleteAccountAliasAsync(const DeleteAccountAliasRequest & request,const DeleteAccountAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const832 void IAMClient::DeleteAccountAliasAsync(const DeleteAccountAliasRequest& request, const DeleteAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
833 {
834 m_executor->Submit( [this, request, handler, context](){ this->DeleteAccountAliasAsyncHelper( request, handler, context ); } );
835 }
836
DeleteAccountAliasAsyncHelper(const DeleteAccountAliasRequest & request,const DeleteAccountAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const837 void IAMClient::DeleteAccountAliasAsyncHelper(const DeleteAccountAliasRequest& request, const DeleteAccountAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
838 {
839 handler(this, request, DeleteAccountAlias(request), context);
840 }
841
DeleteAccountPasswordPolicy(const DeleteAccountPasswordPolicyRequest & request) const842 DeleteAccountPasswordPolicyOutcome IAMClient::DeleteAccountPasswordPolicy(const DeleteAccountPasswordPolicyRequest& request) const
843 {
844 Aws::Http::URI uri = m_uri;
845 return DeleteAccountPasswordPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
846 }
847
DeleteAccountPasswordPolicyCallable(const DeleteAccountPasswordPolicyRequest & request) const848 DeleteAccountPasswordPolicyOutcomeCallable IAMClient::DeleteAccountPasswordPolicyCallable(const DeleteAccountPasswordPolicyRequest& request) const
849 {
850 auto task = Aws::MakeShared< std::packaged_task< DeleteAccountPasswordPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAccountPasswordPolicy(request); } );
851 auto packagedFunction = [task]() { (*task)(); };
852 m_executor->Submit(packagedFunction);
853 return task->get_future();
854 }
855
DeleteAccountPasswordPolicyAsync(const DeleteAccountPasswordPolicyRequest & request,const DeleteAccountPasswordPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const856 void IAMClient::DeleteAccountPasswordPolicyAsync(const DeleteAccountPasswordPolicyRequest& request, const DeleteAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
857 {
858 m_executor->Submit( [this, request, handler, context](){ this->DeleteAccountPasswordPolicyAsyncHelper( request, handler, context ); } );
859 }
860
DeleteAccountPasswordPolicyAsyncHelper(const DeleteAccountPasswordPolicyRequest & request,const DeleteAccountPasswordPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const861 void IAMClient::DeleteAccountPasswordPolicyAsyncHelper(const DeleteAccountPasswordPolicyRequest& request, const DeleteAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
862 {
863 handler(this, request, DeleteAccountPasswordPolicy(request), context);
864 }
865
DeleteGroup(const DeleteGroupRequest & request) const866 DeleteGroupOutcome IAMClient::DeleteGroup(const DeleteGroupRequest& request) const
867 {
868 Aws::Http::URI uri = m_uri;
869 return DeleteGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
870 }
871
DeleteGroupCallable(const DeleteGroupRequest & request) const872 DeleteGroupOutcomeCallable IAMClient::DeleteGroupCallable(const DeleteGroupRequest& request) const
873 {
874 auto task = Aws::MakeShared< std::packaged_task< DeleteGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteGroup(request); } );
875 auto packagedFunction = [task]() { (*task)(); };
876 m_executor->Submit(packagedFunction);
877 return task->get_future();
878 }
879
DeleteGroupAsync(const DeleteGroupRequest & request,const DeleteGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const880 void IAMClient::DeleteGroupAsync(const DeleteGroupRequest& request, const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
881 {
882 m_executor->Submit( [this, request, handler, context](){ this->DeleteGroupAsyncHelper( request, handler, context ); } );
883 }
884
DeleteGroupAsyncHelper(const DeleteGroupRequest & request,const DeleteGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const885 void IAMClient::DeleteGroupAsyncHelper(const DeleteGroupRequest& request, const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
886 {
887 handler(this, request, DeleteGroup(request), context);
888 }
889
DeleteGroupPolicy(const DeleteGroupPolicyRequest & request) const890 DeleteGroupPolicyOutcome IAMClient::DeleteGroupPolicy(const DeleteGroupPolicyRequest& request) const
891 {
892 Aws::Http::URI uri = m_uri;
893 return DeleteGroupPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
894 }
895
DeleteGroupPolicyCallable(const DeleteGroupPolicyRequest & request) const896 DeleteGroupPolicyOutcomeCallable IAMClient::DeleteGroupPolicyCallable(const DeleteGroupPolicyRequest& request) const
897 {
898 auto task = Aws::MakeShared< std::packaged_task< DeleteGroupPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteGroupPolicy(request); } );
899 auto packagedFunction = [task]() { (*task)(); };
900 m_executor->Submit(packagedFunction);
901 return task->get_future();
902 }
903
DeleteGroupPolicyAsync(const DeleteGroupPolicyRequest & request,const DeleteGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const904 void IAMClient::DeleteGroupPolicyAsync(const DeleteGroupPolicyRequest& request, const DeleteGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
905 {
906 m_executor->Submit( [this, request, handler, context](){ this->DeleteGroupPolicyAsyncHelper( request, handler, context ); } );
907 }
908
DeleteGroupPolicyAsyncHelper(const DeleteGroupPolicyRequest & request,const DeleteGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const909 void IAMClient::DeleteGroupPolicyAsyncHelper(const DeleteGroupPolicyRequest& request, const DeleteGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
910 {
911 handler(this, request, DeleteGroupPolicy(request), context);
912 }
913
DeleteInstanceProfile(const DeleteInstanceProfileRequest & request) const914 DeleteInstanceProfileOutcome IAMClient::DeleteInstanceProfile(const DeleteInstanceProfileRequest& request) const
915 {
916 Aws::Http::URI uri = m_uri;
917 return DeleteInstanceProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
918 }
919
DeleteInstanceProfileCallable(const DeleteInstanceProfileRequest & request) const920 DeleteInstanceProfileOutcomeCallable IAMClient::DeleteInstanceProfileCallable(const DeleteInstanceProfileRequest& request) const
921 {
922 auto task = Aws::MakeShared< std::packaged_task< DeleteInstanceProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteInstanceProfile(request); } );
923 auto packagedFunction = [task]() { (*task)(); };
924 m_executor->Submit(packagedFunction);
925 return task->get_future();
926 }
927
DeleteInstanceProfileAsync(const DeleteInstanceProfileRequest & request,const DeleteInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const928 void IAMClient::DeleteInstanceProfileAsync(const DeleteInstanceProfileRequest& request, const DeleteInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
929 {
930 m_executor->Submit( [this, request, handler, context](){ this->DeleteInstanceProfileAsyncHelper( request, handler, context ); } );
931 }
932
DeleteInstanceProfileAsyncHelper(const DeleteInstanceProfileRequest & request,const DeleteInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const933 void IAMClient::DeleteInstanceProfileAsyncHelper(const DeleteInstanceProfileRequest& request, const DeleteInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
934 {
935 handler(this, request, DeleteInstanceProfile(request), context);
936 }
937
DeleteLoginProfile(const DeleteLoginProfileRequest & request) const938 DeleteLoginProfileOutcome IAMClient::DeleteLoginProfile(const DeleteLoginProfileRequest& request) const
939 {
940 Aws::Http::URI uri = m_uri;
941 return DeleteLoginProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
942 }
943
DeleteLoginProfileCallable(const DeleteLoginProfileRequest & request) const944 DeleteLoginProfileOutcomeCallable IAMClient::DeleteLoginProfileCallable(const DeleteLoginProfileRequest& request) const
945 {
946 auto task = Aws::MakeShared< std::packaged_task< DeleteLoginProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteLoginProfile(request); } );
947 auto packagedFunction = [task]() { (*task)(); };
948 m_executor->Submit(packagedFunction);
949 return task->get_future();
950 }
951
DeleteLoginProfileAsync(const DeleteLoginProfileRequest & request,const DeleteLoginProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const952 void IAMClient::DeleteLoginProfileAsync(const DeleteLoginProfileRequest& request, const DeleteLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
953 {
954 m_executor->Submit( [this, request, handler, context](){ this->DeleteLoginProfileAsyncHelper( request, handler, context ); } );
955 }
956
DeleteLoginProfileAsyncHelper(const DeleteLoginProfileRequest & request,const DeleteLoginProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const957 void IAMClient::DeleteLoginProfileAsyncHelper(const DeleteLoginProfileRequest& request, const DeleteLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
958 {
959 handler(this, request, DeleteLoginProfile(request), context);
960 }
961
DeleteOpenIDConnectProvider(const DeleteOpenIDConnectProviderRequest & request) const962 DeleteOpenIDConnectProviderOutcome IAMClient::DeleteOpenIDConnectProvider(const DeleteOpenIDConnectProviderRequest& request) const
963 {
964 Aws::Http::URI uri = m_uri;
965 return DeleteOpenIDConnectProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
966 }
967
DeleteOpenIDConnectProviderCallable(const DeleteOpenIDConnectProviderRequest & request) const968 DeleteOpenIDConnectProviderOutcomeCallable IAMClient::DeleteOpenIDConnectProviderCallable(const DeleteOpenIDConnectProviderRequest& request) const
969 {
970 auto task = Aws::MakeShared< std::packaged_task< DeleteOpenIDConnectProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteOpenIDConnectProvider(request); } );
971 auto packagedFunction = [task]() { (*task)(); };
972 m_executor->Submit(packagedFunction);
973 return task->get_future();
974 }
975
DeleteOpenIDConnectProviderAsync(const DeleteOpenIDConnectProviderRequest & request,const DeleteOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const976 void IAMClient::DeleteOpenIDConnectProviderAsync(const DeleteOpenIDConnectProviderRequest& request, const DeleteOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
977 {
978 m_executor->Submit( [this, request, handler, context](){ this->DeleteOpenIDConnectProviderAsyncHelper( request, handler, context ); } );
979 }
980
DeleteOpenIDConnectProviderAsyncHelper(const DeleteOpenIDConnectProviderRequest & request,const DeleteOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const981 void IAMClient::DeleteOpenIDConnectProviderAsyncHelper(const DeleteOpenIDConnectProviderRequest& request, const DeleteOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
982 {
983 handler(this, request, DeleteOpenIDConnectProvider(request), context);
984 }
985
DeletePolicy(const DeletePolicyRequest & request) const986 DeletePolicyOutcome IAMClient::DeletePolicy(const DeletePolicyRequest& request) const
987 {
988 Aws::Http::URI uri = m_uri;
989 return DeletePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
990 }
991
DeletePolicyCallable(const DeletePolicyRequest & request) const992 DeletePolicyOutcomeCallable IAMClient::DeletePolicyCallable(const DeletePolicyRequest& request) const
993 {
994 auto task = Aws::MakeShared< std::packaged_task< DeletePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePolicy(request); } );
995 auto packagedFunction = [task]() { (*task)(); };
996 m_executor->Submit(packagedFunction);
997 return task->get_future();
998 }
999
DeletePolicyAsync(const DeletePolicyRequest & request,const DeletePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1000 void IAMClient::DeletePolicyAsync(const DeletePolicyRequest& request, const DeletePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1001 {
1002 m_executor->Submit( [this, request, handler, context](){ this->DeletePolicyAsyncHelper( request, handler, context ); } );
1003 }
1004
DeletePolicyAsyncHelper(const DeletePolicyRequest & request,const DeletePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1005 void IAMClient::DeletePolicyAsyncHelper(const DeletePolicyRequest& request, const DeletePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1006 {
1007 handler(this, request, DeletePolicy(request), context);
1008 }
1009
DeletePolicyVersion(const DeletePolicyVersionRequest & request) const1010 DeletePolicyVersionOutcome IAMClient::DeletePolicyVersion(const DeletePolicyVersionRequest& request) const
1011 {
1012 Aws::Http::URI uri = m_uri;
1013 return DeletePolicyVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1014 }
1015
DeletePolicyVersionCallable(const DeletePolicyVersionRequest & request) const1016 DeletePolicyVersionOutcomeCallable IAMClient::DeletePolicyVersionCallable(const DeletePolicyVersionRequest& request) const
1017 {
1018 auto task = Aws::MakeShared< std::packaged_task< DeletePolicyVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePolicyVersion(request); } );
1019 auto packagedFunction = [task]() { (*task)(); };
1020 m_executor->Submit(packagedFunction);
1021 return task->get_future();
1022 }
1023
DeletePolicyVersionAsync(const DeletePolicyVersionRequest & request,const DeletePolicyVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1024 void IAMClient::DeletePolicyVersionAsync(const DeletePolicyVersionRequest& request, const DeletePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1025 {
1026 m_executor->Submit( [this, request, handler, context](){ this->DeletePolicyVersionAsyncHelper( request, handler, context ); } );
1027 }
1028
DeletePolicyVersionAsyncHelper(const DeletePolicyVersionRequest & request,const DeletePolicyVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1029 void IAMClient::DeletePolicyVersionAsyncHelper(const DeletePolicyVersionRequest& request, const DeletePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1030 {
1031 handler(this, request, DeletePolicyVersion(request), context);
1032 }
1033
DeleteRole(const DeleteRoleRequest & request) const1034 DeleteRoleOutcome IAMClient::DeleteRole(const DeleteRoleRequest& request) const
1035 {
1036 Aws::Http::URI uri = m_uri;
1037 return DeleteRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1038 }
1039
DeleteRoleCallable(const DeleteRoleRequest & request) const1040 DeleteRoleOutcomeCallable IAMClient::DeleteRoleCallable(const DeleteRoleRequest& request) const
1041 {
1042 auto task = Aws::MakeShared< std::packaged_task< DeleteRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteRole(request); } );
1043 auto packagedFunction = [task]() { (*task)(); };
1044 m_executor->Submit(packagedFunction);
1045 return task->get_future();
1046 }
1047
DeleteRoleAsync(const DeleteRoleRequest & request,const DeleteRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1048 void IAMClient::DeleteRoleAsync(const DeleteRoleRequest& request, const DeleteRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1049 {
1050 m_executor->Submit( [this, request, handler, context](){ this->DeleteRoleAsyncHelper( request, handler, context ); } );
1051 }
1052
DeleteRoleAsyncHelper(const DeleteRoleRequest & request,const DeleteRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1053 void IAMClient::DeleteRoleAsyncHelper(const DeleteRoleRequest& request, const DeleteRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1054 {
1055 handler(this, request, DeleteRole(request), context);
1056 }
1057
DeleteRolePermissionsBoundary(const DeleteRolePermissionsBoundaryRequest & request) const1058 DeleteRolePermissionsBoundaryOutcome IAMClient::DeleteRolePermissionsBoundary(const DeleteRolePermissionsBoundaryRequest& request) const
1059 {
1060 Aws::Http::URI uri = m_uri;
1061 return DeleteRolePermissionsBoundaryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1062 }
1063
DeleteRolePermissionsBoundaryCallable(const DeleteRolePermissionsBoundaryRequest & request) const1064 DeleteRolePermissionsBoundaryOutcomeCallable IAMClient::DeleteRolePermissionsBoundaryCallable(const DeleteRolePermissionsBoundaryRequest& request) const
1065 {
1066 auto task = Aws::MakeShared< std::packaged_task< DeleteRolePermissionsBoundaryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteRolePermissionsBoundary(request); } );
1067 auto packagedFunction = [task]() { (*task)(); };
1068 m_executor->Submit(packagedFunction);
1069 return task->get_future();
1070 }
1071
DeleteRolePermissionsBoundaryAsync(const DeleteRolePermissionsBoundaryRequest & request,const DeleteRolePermissionsBoundaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1072 void IAMClient::DeleteRolePermissionsBoundaryAsync(const DeleteRolePermissionsBoundaryRequest& request, const DeleteRolePermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1073 {
1074 m_executor->Submit( [this, request, handler, context](){ this->DeleteRolePermissionsBoundaryAsyncHelper( request, handler, context ); } );
1075 }
1076
DeleteRolePermissionsBoundaryAsyncHelper(const DeleteRolePermissionsBoundaryRequest & request,const DeleteRolePermissionsBoundaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1077 void IAMClient::DeleteRolePermissionsBoundaryAsyncHelper(const DeleteRolePermissionsBoundaryRequest& request, const DeleteRolePermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1078 {
1079 handler(this, request, DeleteRolePermissionsBoundary(request), context);
1080 }
1081
DeleteRolePolicy(const DeleteRolePolicyRequest & request) const1082 DeleteRolePolicyOutcome IAMClient::DeleteRolePolicy(const DeleteRolePolicyRequest& request) const
1083 {
1084 Aws::Http::URI uri = m_uri;
1085 return DeleteRolePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1086 }
1087
DeleteRolePolicyCallable(const DeleteRolePolicyRequest & request) const1088 DeleteRolePolicyOutcomeCallable IAMClient::DeleteRolePolicyCallable(const DeleteRolePolicyRequest& request) const
1089 {
1090 auto task = Aws::MakeShared< std::packaged_task< DeleteRolePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteRolePolicy(request); } );
1091 auto packagedFunction = [task]() { (*task)(); };
1092 m_executor->Submit(packagedFunction);
1093 return task->get_future();
1094 }
1095
DeleteRolePolicyAsync(const DeleteRolePolicyRequest & request,const DeleteRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1096 void IAMClient::DeleteRolePolicyAsync(const DeleteRolePolicyRequest& request, const DeleteRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1097 {
1098 m_executor->Submit( [this, request, handler, context](){ this->DeleteRolePolicyAsyncHelper( request, handler, context ); } );
1099 }
1100
DeleteRolePolicyAsyncHelper(const DeleteRolePolicyRequest & request,const DeleteRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1101 void IAMClient::DeleteRolePolicyAsyncHelper(const DeleteRolePolicyRequest& request, const DeleteRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1102 {
1103 handler(this, request, DeleteRolePolicy(request), context);
1104 }
1105
DeleteSAMLProvider(const DeleteSAMLProviderRequest & request) const1106 DeleteSAMLProviderOutcome IAMClient::DeleteSAMLProvider(const DeleteSAMLProviderRequest& request) const
1107 {
1108 Aws::Http::URI uri = m_uri;
1109 return DeleteSAMLProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1110 }
1111
DeleteSAMLProviderCallable(const DeleteSAMLProviderRequest & request) const1112 DeleteSAMLProviderOutcomeCallable IAMClient::DeleteSAMLProviderCallable(const DeleteSAMLProviderRequest& request) const
1113 {
1114 auto task = Aws::MakeShared< std::packaged_task< DeleteSAMLProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteSAMLProvider(request); } );
1115 auto packagedFunction = [task]() { (*task)(); };
1116 m_executor->Submit(packagedFunction);
1117 return task->get_future();
1118 }
1119
DeleteSAMLProviderAsync(const DeleteSAMLProviderRequest & request,const DeleteSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1120 void IAMClient::DeleteSAMLProviderAsync(const DeleteSAMLProviderRequest& request, const DeleteSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1121 {
1122 m_executor->Submit( [this, request, handler, context](){ this->DeleteSAMLProviderAsyncHelper( request, handler, context ); } );
1123 }
1124
DeleteSAMLProviderAsyncHelper(const DeleteSAMLProviderRequest & request,const DeleteSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1125 void IAMClient::DeleteSAMLProviderAsyncHelper(const DeleteSAMLProviderRequest& request, const DeleteSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1126 {
1127 handler(this, request, DeleteSAMLProvider(request), context);
1128 }
1129
DeleteSSHPublicKey(const DeleteSSHPublicKeyRequest & request) const1130 DeleteSSHPublicKeyOutcome IAMClient::DeleteSSHPublicKey(const DeleteSSHPublicKeyRequest& request) const
1131 {
1132 Aws::Http::URI uri = m_uri;
1133 return DeleteSSHPublicKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1134 }
1135
DeleteSSHPublicKeyCallable(const DeleteSSHPublicKeyRequest & request) const1136 DeleteSSHPublicKeyOutcomeCallable IAMClient::DeleteSSHPublicKeyCallable(const DeleteSSHPublicKeyRequest& request) const
1137 {
1138 auto task = Aws::MakeShared< std::packaged_task< DeleteSSHPublicKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteSSHPublicKey(request); } );
1139 auto packagedFunction = [task]() { (*task)(); };
1140 m_executor->Submit(packagedFunction);
1141 return task->get_future();
1142 }
1143
DeleteSSHPublicKeyAsync(const DeleteSSHPublicKeyRequest & request,const DeleteSSHPublicKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1144 void IAMClient::DeleteSSHPublicKeyAsync(const DeleteSSHPublicKeyRequest& request, const DeleteSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1145 {
1146 m_executor->Submit( [this, request, handler, context](){ this->DeleteSSHPublicKeyAsyncHelper( request, handler, context ); } );
1147 }
1148
DeleteSSHPublicKeyAsyncHelper(const DeleteSSHPublicKeyRequest & request,const DeleteSSHPublicKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1149 void IAMClient::DeleteSSHPublicKeyAsyncHelper(const DeleteSSHPublicKeyRequest& request, const DeleteSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1150 {
1151 handler(this, request, DeleteSSHPublicKey(request), context);
1152 }
1153
DeleteServerCertificate(const DeleteServerCertificateRequest & request) const1154 DeleteServerCertificateOutcome IAMClient::DeleteServerCertificate(const DeleteServerCertificateRequest& request) const
1155 {
1156 Aws::Http::URI uri = m_uri;
1157 return DeleteServerCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1158 }
1159
DeleteServerCertificateCallable(const DeleteServerCertificateRequest & request) const1160 DeleteServerCertificateOutcomeCallable IAMClient::DeleteServerCertificateCallable(const DeleteServerCertificateRequest& request) const
1161 {
1162 auto task = Aws::MakeShared< std::packaged_task< DeleteServerCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteServerCertificate(request); } );
1163 auto packagedFunction = [task]() { (*task)(); };
1164 m_executor->Submit(packagedFunction);
1165 return task->get_future();
1166 }
1167
DeleteServerCertificateAsync(const DeleteServerCertificateRequest & request,const DeleteServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1168 void IAMClient::DeleteServerCertificateAsync(const DeleteServerCertificateRequest& request, const DeleteServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1169 {
1170 m_executor->Submit( [this, request, handler, context](){ this->DeleteServerCertificateAsyncHelper( request, handler, context ); } );
1171 }
1172
DeleteServerCertificateAsyncHelper(const DeleteServerCertificateRequest & request,const DeleteServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1173 void IAMClient::DeleteServerCertificateAsyncHelper(const DeleteServerCertificateRequest& request, const DeleteServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1174 {
1175 handler(this, request, DeleteServerCertificate(request), context);
1176 }
1177
DeleteServiceLinkedRole(const DeleteServiceLinkedRoleRequest & request) const1178 DeleteServiceLinkedRoleOutcome IAMClient::DeleteServiceLinkedRole(const DeleteServiceLinkedRoleRequest& request) const
1179 {
1180 Aws::Http::URI uri = m_uri;
1181 return DeleteServiceLinkedRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1182 }
1183
DeleteServiceLinkedRoleCallable(const DeleteServiceLinkedRoleRequest & request) const1184 DeleteServiceLinkedRoleOutcomeCallable IAMClient::DeleteServiceLinkedRoleCallable(const DeleteServiceLinkedRoleRequest& request) const
1185 {
1186 auto task = Aws::MakeShared< std::packaged_task< DeleteServiceLinkedRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteServiceLinkedRole(request); } );
1187 auto packagedFunction = [task]() { (*task)(); };
1188 m_executor->Submit(packagedFunction);
1189 return task->get_future();
1190 }
1191
DeleteServiceLinkedRoleAsync(const DeleteServiceLinkedRoleRequest & request,const DeleteServiceLinkedRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1192 void IAMClient::DeleteServiceLinkedRoleAsync(const DeleteServiceLinkedRoleRequest& request, const DeleteServiceLinkedRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1193 {
1194 m_executor->Submit( [this, request, handler, context](){ this->DeleteServiceLinkedRoleAsyncHelper( request, handler, context ); } );
1195 }
1196
DeleteServiceLinkedRoleAsyncHelper(const DeleteServiceLinkedRoleRequest & request,const DeleteServiceLinkedRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1197 void IAMClient::DeleteServiceLinkedRoleAsyncHelper(const DeleteServiceLinkedRoleRequest& request, const DeleteServiceLinkedRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1198 {
1199 handler(this, request, DeleteServiceLinkedRole(request), context);
1200 }
1201
DeleteServiceSpecificCredential(const DeleteServiceSpecificCredentialRequest & request) const1202 DeleteServiceSpecificCredentialOutcome IAMClient::DeleteServiceSpecificCredential(const DeleteServiceSpecificCredentialRequest& request) const
1203 {
1204 Aws::Http::URI uri = m_uri;
1205 return DeleteServiceSpecificCredentialOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1206 }
1207
DeleteServiceSpecificCredentialCallable(const DeleteServiceSpecificCredentialRequest & request) const1208 DeleteServiceSpecificCredentialOutcomeCallable IAMClient::DeleteServiceSpecificCredentialCallable(const DeleteServiceSpecificCredentialRequest& request) const
1209 {
1210 auto task = Aws::MakeShared< std::packaged_task< DeleteServiceSpecificCredentialOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteServiceSpecificCredential(request); } );
1211 auto packagedFunction = [task]() { (*task)(); };
1212 m_executor->Submit(packagedFunction);
1213 return task->get_future();
1214 }
1215
DeleteServiceSpecificCredentialAsync(const DeleteServiceSpecificCredentialRequest & request,const DeleteServiceSpecificCredentialResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1216 void IAMClient::DeleteServiceSpecificCredentialAsync(const DeleteServiceSpecificCredentialRequest& request, const DeleteServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1217 {
1218 m_executor->Submit( [this, request, handler, context](){ this->DeleteServiceSpecificCredentialAsyncHelper( request, handler, context ); } );
1219 }
1220
DeleteServiceSpecificCredentialAsyncHelper(const DeleteServiceSpecificCredentialRequest & request,const DeleteServiceSpecificCredentialResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1221 void IAMClient::DeleteServiceSpecificCredentialAsyncHelper(const DeleteServiceSpecificCredentialRequest& request, const DeleteServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1222 {
1223 handler(this, request, DeleteServiceSpecificCredential(request), context);
1224 }
1225
DeleteSigningCertificate(const DeleteSigningCertificateRequest & request) const1226 DeleteSigningCertificateOutcome IAMClient::DeleteSigningCertificate(const DeleteSigningCertificateRequest& request) const
1227 {
1228 Aws::Http::URI uri = m_uri;
1229 return DeleteSigningCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1230 }
1231
DeleteSigningCertificateCallable(const DeleteSigningCertificateRequest & request) const1232 DeleteSigningCertificateOutcomeCallable IAMClient::DeleteSigningCertificateCallable(const DeleteSigningCertificateRequest& request) const
1233 {
1234 auto task = Aws::MakeShared< std::packaged_task< DeleteSigningCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteSigningCertificate(request); } );
1235 auto packagedFunction = [task]() { (*task)(); };
1236 m_executor->Submit(packagedFunction);
1237 return task->get_future();
1238 }
1239
DeleteSigningCertificateAsync(const DeleteSigningCertificateRequest & request,const DeleteSigningCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1240 void IAMClient::DeleteSigningCertificateAsync(const DeleteSigningCertificateRequest& request, const DeleteSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1241 {
1242 m_executor->Submit( [this, request, handler, context](){ this->DeleteSigningCertificateAsyncHelper( request, handler, context ); } );
1243 }
1244
DeleteSigningCertificateAsyncHelper(const DeleteSigningCertificateRequest & request,const DeleteSigningCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1245 void IAMClient::DeleteSigningCertificateAsyncHelper(const DeleteSigningCertificateRequest& request, const DeleteSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1246 {
1247 handler(this, request, DeleteSigningCertificate(request), context);
1248 }
1249
DeleteUser(const DeleteUserRequest & request) const1250 DeleteUserOutcome IAMClient::DeleteUser(const DeleteUserRequest& request) const
1251 {
1252 Aws::Http::URI uri = m_uri;
1253 return DeleteUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1254 }
1255
DeleteUserCallable(const DeleteUserRequest & request) const1256 DeleteUserOutcomeCallable IAMClient::DeleteUserCallable(const DeleteUserRequest& request) const
1257 {
1258 auto task = Aws::MakeShared< std::packaged_task< DeleteUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteUser(request); } );
1259 auto packagedFunction = [task]() { (*task)(); };
1260 m_executor->Submit(packagedFunction);
1261 return task->get_future();
1262 }
1263
DeleteUserAsync(const DeleteUserRequest & request,const DeleteUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1264 void IAMClient::DeleteUserAsync(const DeleteUserRequest& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1265 {
1266 m_executor->Submit( [this, request, handler, context](){ this->DeleteUserAsyncHelper( request, handler, context ); } );
1267 }
1268
DeleteUserAsyncHelper(const DeleteUserRequest & request,const DeleteUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1269 void IAMClient::DeleteUserAsyncHelper(const DeleteUserRequest& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1270 {
1271 handler(this, request, DeleteUser(request), context);
1272 }
1273
DeleteUserPermissionsBoundary(const DeleteUserPermissionsBoundaryRequest & request) const1274 DeleteUserPermissionsBoundaryOutcome IAMClient::DeleteUserPermissionsBoundary(const DeleteUserPermissionsBoundaryRequest& request) const
1275 {
1276 Aws::Http::URI uri = m_uri;
1277 return DeleteUserPermissionsBoundaryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1278 }
1279
DeleteUserPermissionsBoundaryCallable(const DeleteUserPermissionsBoundaryRequest & request) const1280 DeleteUserPermissionsBoundaryOutcomeCallable IAMClient::DeleteUserPermissionsBoundaryCallable(const DeleteUserPermissionsBoundaryRequest& request) const
1281 {
1282 auto task = Aws::MakeShared< std::packaged_task< DeleteUserPermissionsBoundaryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteUserPermissionsBoundary(request); } );
1283 auto packagedFunction = [task]() { (*task)(); };
1284 m_executor->Submit(packagedFunction);
1285 return task->get_future();
1286 }
1287
DeleteUserPermissionsBoundaryAsync(const DeleteUserPermissionsBoundaryRequest & request,const DeleteUserPermissionsBoundaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1288 void IAMClient::DeleteUserPermissionsBoundaryAsync(const DeleteUserPermissionsBoundaryRequest& request, const DeleteUserPermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1289 {
1290 m_executor->Submit( [this, request, handler, context](){ this->DeleteUserPermissionsBoundaryAsyncHelper( request, handler, context ); } );
1291 }
1292
DeleteUserPermissionsBoundaryAsyncHelper(const DeleteUserPermissionsBoundaryRequest & request,const DeleteUserPermissionsBoundaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1293 void IAMClient::DeleteUserPermissionsBoundaryAsyncHelper(const DeleteUserPermissionsBoundaryRequest& request, const DeleteUserPermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1294 {
1295 handler(this, request, DeleteUserPermissionsBoundary(request), context);
1296 }
1297
DeleteUserPolicy(const DeleteUserPolicyRequest & request) const1298 DeleteUserPolicyOutcome IAMClient::DeleteUserPolicy(const DeleteUserPolicyRequest& request) const
1299 {
1300 Aws::Http::URI uri = m_uri;
1301 return DeleteUserPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1302 }
1303
DeleteUserPolicyCallable(const DeleteUserPolicyRequest & request) const1304 DeleteUserPolicyOutcomeCallable IAMClient::DeleteUserPolicyCallable(const DeleteUserPolicyRequest& request) const
1305 {
1306 auto task = Aws::MakeShared< std::packaged_task< DeleteUserPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteUserPolicy(request); } );
1307 auto packagedFunction = [task]() { (*task)(); };
1308 m_executor->Submit(packagedFunction);
1309 return task->get_future();
1310 }
1311
DeleteUserPolicyAsync(const DeleteUserPolicyRequest & request,const DeleteUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1312 void IAMClient::DeleteUserPolicyAsync(const DeleteUserPolicyRequest& request, const DeleteUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1313 {
1314 m_executor->Submit( [this, request, handler, context](){ this->DeleteUserPolicyAsyncHelper( request, handler, context ); } );
1315 }
1316
DeleteUserPolicyAsyncHelper(const DeleteUserPolicyRequest & request,const DeleteUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1317 void IAMClient::DeleteUserPolicyAsyncHelper(const DeleteUserPolicyRequest& request, const DeleteUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1318 {
1319 handler(this, request, DeleteUserPolicy(request), context);
1320 }
1321
DeleteVirtualMFADevice(const DeleteVirtualMFADeviceRequest & request) const1322 DeleteVirtualMFADeviceOutcome IAMClient::DeleteVirtualMFADevice(const DeleteVirtualMFADeviceRequest& request) const
1323 {
1324 Aws::Http::URI uri = m_uri;
1325 return DeleteVirtualMFADeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1326 }
1327
DeleteVirtualMFADeviceCallable(const DeleteVirtualMFADeviceRequest & request) const1328 DeleteVirtualMFADeviceOutcomeCallable IAMClient::DeleteVirtualMFADeviceCallable(const DeleteVirtualMFADeviceRequest& request) const
1329 {
1330 auto task = Aws::MakeShared< std::packaged_task< DeleteVirtualMFADeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteVirtualMFADevice(request); } );
1331 auto packagedFunction = [task]() { (*task)(); };
1332 m_executor->Submit(packagedFunction);
1333 return task->get_future();
1334 }
1335
DeleteVirtualMFADeviceAsync(const DeleteVirtualMFADeviceRequest & request,const DeleteVirtualMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1336 void IAMClient::DeleteVirtualMFADeviceAsync(const DeleteVirtualMFADeviceRequest& request, const DeleteVirtualMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1337 {
1338 m_executor->Submit( [this, request, handler, context](){ this->DeleteVirtualMFADeviceAsyncHelper( request, handler, context ); } );
1339 }
1340
DeleteVirtualMFADeviceAsyncHelper(const DeleteVirtualMFADeviceRequest & request,const DeleteVirtualMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1341 void IAMClient::DeleteVirtualMFADeviceAsyncHelper(const DeleteVirtualMFADeviceRequest& request, const DeleteVirtualMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1342 {
1343 handler(this, request, DeleteVirtualMFADevice(request), context);
1344 }
1345
DetachGroupPolicy(const DetachGroupPolicyRequest & request) const1346 DetachGroupPolicyOutcome IAMClient::DetachGroupPolicy(const DetachGroupPolicyRequest& request) const
1347 {
1348 Aws::Http::URI uri = m_uri;
1349 return DetachGroupPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1350 }
1351
DetachGroupPolicyCallable(const DetachGroupPolicyRequest & request) const1352 DetachGroupPolicyOutcomeCallable IAMClient::DetachGroupPolicyCallable(const DetachGroupPolicyRequest& request) const
1353 {
1354 auto task = Aws::MakeShared< std::packaged_task< DetachGroupPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetachGroupPolicy(request); } );
1355 auto packagedFunction = [task]() { (*task)(); };
1356 m_executor->Submit(packagedFunction);
1357 return task->get_future();
1358 }
1359
DetachGroupPolicyAsync(const DetachGroupPolicyRequest & request,const DetachGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1360 void IAMClient::DetachGroupPolicyAsync(const DetachGroupPolicyRequest& request, const DetachGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1361 {
1362 m_executor->Submit( [this, request, handler, context](){ this->DetachGroupPolicyAsyncHelper( request, handler, context ); } );
1363 }
1364
DetachGroupPolicyAsyncHelper(const DetachGroupPolicyRequest & request,const DetachGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1365 void IAMClient::DetachGroupPolicyAsyncHelper(const DetachGroupPolicyRequest& request, const DetachGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1366 {
1367 handler(this, request, DetachGroupPolicy(request), context);
1368 }
1369
DetachRolePolicy(const DetachRolePolicyRequest & request) const1370 DetachRolePolicyOutcome IAMClient::DetachRolePolicy(const DetachRolePolicyRequest& request) const
1371 {
1372 Aws::Http::URI uri = m_uri;
1373 return DetachRolePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1374 }
1375
DetachRolePolicyCallable(const DetachRolePolicyRequest & request) const1376 DetachRolePolicyOutcomeCallable IAMClient::DetachRolePolicyCallable(const DetachRolePolicyRequest& request) const
1377 {
1378 auto task = Aws::MakeShared< std::packaged_task< DetachRolePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetachRolePolicy(request); } );
1379 auto packagedFunction = [task]() { (*task)(); };
1380 m_executor->Submit(packagedFunction);
1381 return task->get_future();
1382 }
1383
DetachRolePolicyAsync(const DetachRolePolicyRequest & request,const DetachRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1384 void IAMClient::DetachRolePolicyAsync(const DetachRolePolicyRequest& request, const DetachRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1385 {
1386 m_executor->Submit( [this, request, handler, context](){ this->DetachRolePolicyAsyncHelper( request, handler, context ); } );
1387 }
1388
DetachRolePolicyAsyncHelper(const DetachRolePolicyRequest & request,const DetachRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1389 void IAMClient::DetachRolePolicyAsyncHelper(const DetachRolePolicyRequest& request, const DetachRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1390 {
1391 handler(this, request, DetachRolePolicy(request), context);
1392 }
1393
DetachUserPolicy(const DetachUserPolicyRequest & request) const1394 DetachUserPolicyOutcome IAMClient::DetachUserPolicy(const DetachUserPolicyRequest& request) const
1395 {
1396 Aws::Http::URI uri = m_uri;
1397 return DetachUserPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1398 }
1399
DetachUserPolicyCallable(const DetachUserPolicyRequest & request) const1400 DetachUserPolicyOutcomeCallable IAMClient::DetachUserPolicyCallable(const DetachUserPolicyRequest& request) const
1401 {
1402 auto task = Aws::MakeShared< std::packaged_task< DetachUserPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetachUserPolicy(request); } );
1403 auto packagedFunction = [task]() { (*task)(); };
1404 m_executor->Submit(packagedFunction);
1405 return task->get_future();
1406 }
1407
DetachUserPolicyAsync(const DetachUserPolicyRequest & request,const DetachUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1408 void IAMClient::DetachUserPolicyAsync(const DetachUserPolicyRequest& request, const DetachUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1409 {
1410 m_executor->Submit( [this, request, handler, context](){ this->DetachUserPolicyAsyncHelper( request, handler, context ); } );
1411 }
1412
DetachUserPolicyAsyncHelper(const DetachUserPolicyRequest & request,const DetachUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1413 void IAMClient::DetachUserPolicyAsyncHelper(const DetachUserPolicyRequest& request, const DetachUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1414 {
1415 handler(this, request, DetachUserPolicy(request), context);
1416 }
1417
EnableMFADevice(const EnableMFADeviceRequest & request) const1418 EnableMFADeviceOutcome IAMClient::EnableMFADevice(const EnableMFADeviceRequest& request) const
1419 {
1420 Aws::Http::URI uri = m_uri;
1421 return EnableMFADeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1422 }
1423
EnableMFADeviceCallable(const EnableMFADeviceRequest & request) const1424 EnableMFADeviceOutcomeCallable IAMClient::EnableMFADeviceCallable(const EnableMFADeviceRequest& request) const
1425 {
1426 auto task = Aws::MakeShared< std::packaged_task< EnableMFADeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->EnableMFADevice(request); } );
1427 auto packagedFunction = [task]() { (*task)(); };
1428 m_executor->Submit(packagedFunction);
1429 return task->get_future();
1430 }
1431
EnableMFADeviceAsync(const EnableMFADeviceRequest & request,const EnableMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1432 void IAMClient::EnableMFADeviceAsync(const EnableMFADeviceRequest& request, const EnableMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1433 {
1434 m_executor->Submit( [this, request, handler, context](){ this->EnableMFADeviceAsyncHelper( request, handler, context ); } );
1435 }
1436
EnableMFADeviceAsyncHelper(const EnableMFADeviceRequest & request,const EnableMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1437 void IAMClient::EnableMFADeviceAsyncHelper(const EnableMFADeviceRequest& request, const EnableMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1438 {
1439 handler(this, request, EnableMFADevice(request), context);
1440 }
1441
GenerateCredentialReport(const GenerateCredentialReportRequest & request) const1442 GenerateCredentialReportOutcome IAMClient::GenerateCredentialReport(const GenerateCredentialReportRequest& request) const
1443 {
1444 Aws::Http::URI uri = m_uri;
1445 return GenerateCredentialReportOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1446 }
1447
GenerateCredentialReportCallable(const GenerateCredentialReportRequest & request) const1448 GenerateCredentialReportOutcomeCallable IAMClient::GenerateCredentialReportCallable(const GenerateCredentialReportRequest& request) const
1449 {
1450 auto task = Aws::MakeShared< std::packaged_task< GenerateCredentialReportOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GenerateCredentialReport(request); } );
1451 auto packagedFunction = [task]() { (*task)(); };
1452 m_executor->Submit(packagedFunction);
1453 return task->get_future();
1454 }
1455
GenerateCredentialReportAsync(const GenerateCredentialReportRequest & request,const GenerateCredentialReportResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1456 void IAMClient::GenerateCredentialReportAsync(const GenerateCredentialReportRequest& request, const GenerateCredentialReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1457 {
1458 m_executor->Submit( [this, request, handler, context](){ this->GenerateCredentialReportAsyncHelper( request, handler, context ); } );
1459 }
1460
GenerateCredentialReportAsyncHelper(const GenerateCredentialReportRequest & request,const GenerateCredentialReportResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1461 void IAMClient::GenerateCredentialReportAsyncHelper(const GenerateCredentialReportRequest& request, const GenerateCredentialReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1462 {
1463 handler(this, request, GenerateCredentialReport(request), context);
1464 }
1465
GenerateOrganizationsAccessReport(const GenerateOrganizationsAccessReportRequest & request) const1466 GenerateOrganizationsAccessReportOutcome IAMClient::GenerateOrganizationsAccessReport(const GenerateOrganizationsAccessReportRequest& request) const
1467 {
1468 Aws::Http::URI uri = m_uri;
1469 return GenerateOrganizationsAccessReportOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1470 }
1471
GenerateOrganizationsAccessReportCallable(const GenerateOrganizationsAccessReportRequest & request) const1472 GenerateOrganizationsAccessReportOutcomeCallable IAMClient::GenerateOrganizationsAccessReportCallable(const GenerateOrganizationsAccessReportRequest& request) const
1473 {
1474 auto task = Aws::MakeShared< std::packaged_task< GenerateOrganizationsAccessReportOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GenerateOrganizationsAccessReport(request); } );
1475 auto packagedFunction = [task]() { (*task)(); };
1476 m_executor->Submit(packagedFunction);
1477 return task->get_future();
1478 }
1479
GenerateOrganizationsAccessReportAsync(const GenerateOrganizationsAccessReportRequest & request,const GenerateOrganizationsAccessReportResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1480 void IAMClient::GenerateOrganizationsAccessReportAsync(const GenerateOrganizationsAccessReportRequest& request, const GenerateOrganizationsAccessReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1481 {
1482 m_executor->Submit( [this, request, handler, context](){ this->GenerateOrganizationsAccessReportAsyncHelper( request, handler, context ); } );
1483 }
1484
GenerateOrganizationsAccessReportAsyncHelper(const GenerateOrganizationsAccessReportRequest & request,const GenerateOrganizationsAccessReportResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1485 void IAMClient::GenerateOrganizationsAccessReportAsyncHelper(const GenerateOrganizationsAccessReportRequest& request, const GenerateOrganizationsAccessReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1486 {
1487 handler(this, request, GenerateOrganizationsAccessReport(request), context);
1488 }
1489
GenerateServiceLastAccessedDetails(const GenerateServiceLastAccessedDetailsRequest & request) const1490 GenerateServiceLastAccessedDetailsOutcome IAMClient::GenerateServiceLastAccessedDetails(const GenerateServiceLastAccessedDetailsRequest& request) const
1491 {
1492 Aws::Http::URI uri = m_uri;
1493 return GenerateServiceLastAccessedDetailsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1494 }
1495
GenerateServiceLastAccessedDetailsCallable(const GenerateServiceLastAccessedDetailsRequest & request) const1496 GenerateServiceLastAccessedDetailsOutcomeCallable IAMClient::GenerateServiceLastAccessedDetailsCallable(const GenerateServiceLastAccessedDetailsRequest& request) const
1497 {
1498 auto task = Aws::MakeShared< std::packaged_task< GenerateServiceLastAccessedDetailsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GenerateServiceLastAccessedDetails(request); } );
1499 auto packagedFunction = [task]() { (*task)(); };
1500 m_executor->Submit(packagedFunction);
1501 return task->get_future();
1502 }
1503
GenerateServiceLastAccessedDetailsAsync(const GenerateServiceLastAccessedDetailsRequest & request,const GenerateServiceLastAccessedDetailsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1504 void IAMClient::GenerateServiceLastAccessedDetailsAsync(const GenerateServiceLastAccessedDetailsRequest& request, const GenerateServiceLastAccessedDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1505 {
1506 m_executor->Submit( [this, request, handler, context](){ this->GenerateServiceLastAccessedDetailsAsyncHelper( request, handler, context ); } );
1507 }
1508
GenerateServiceLastAccessedDetailsAsyncHelper(const GenerateServiceLastAccessedDetailsRequest & request,const GenerateServiceLastAccessedDetailsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1509 void IAMClient::GenerateServiceLastAccessedDetailsAsyncHelper(const GenerateServiceLastAccessedDetailsRequest& request, const GenerateServiceLastAccessedDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1510 {
1511 handler(this, request, GenerateServiceLastAccessedDetails(request), context);
1512 }
1513
GetAccessKeyLastUsed(const GetAccessKeyLastUsedRequest & request) const1514 GetAccessKeyLastUsedOutcome IAMClient::GetAccessKeyLastUsed(const GetAccessKeyLastUsedRequest& request) const
1515 {
1516 Aws::Http::URI uri = m_uri;
1517 return GetAccessKeyLastUsedOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1518 }
1519
GetAccessKeyLastUsedCallable(const GetAccessKeyLastUsedRequest & request) const1520 GetAccessKeyLastUsedOutcomeCallable IAMClient::GetAccessKeyLastUsedCallable(const GetAccessKeyLastUsedRequest& request) const
1521 {
1522 auto task = Aws::MakeShared< std::packaged_task< GetAccessKeyLastUsedOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAccessKeyLastUsed(request); } );
1523 auto packagedFunction = [task]() { (*task)(); };
1524 m_executor->Submit(packagedFunction);
1525 return task->get_future();
1526 }
1527
GetAccessKeyLastUsedAsync(const GetAccessKeyLastUsedRequest & request,const GetAccessKeyLastUsedResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1528 void IAMClient::GetAccessKeyLastUsedAsync(const GetAccessKeyLastUsedRequest& request, const GetAccessKeyLastUsedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1529 {
1530 m_executor->Submit( [this, request, handler, context](){ this->GetAccessKeyLastUsedAsyncHelper( request, handler, context ); } );
1531 }
1532
GetAccessKeyLastUsedAsyncHelper(const GetAccessKeyLastUsedRequest & request,const GetAccessKeyLastUsedResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1533 void IAMClient::GetAccessKeyLastUsedAsyncHelper(const GetAccessKeyLastUsedRequest& request, const GetAccessKeyLastUsedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1534 {
1535 handler(this, request, GetAccessKeyLastUsed(request), context);
1536 }
1537
GetAccountAuthorizationDetails(const GetAccountAuthorizationDetailsRequest & request) const1538 GetAccountAuthorizationDetailsOutcome IAMClient::GetAccountAuthorizationDetails(const GetAccountAuthorizationDetailsRequest& request) const
1539 {
1540 Aws::Http::URI uri = m_uri;
1541 return GetAccountAuthorizationDetailsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1542 }
1543
GetAccountAuthorizationDetailsCallable(const GetAccountAuthorizationDetailsRequest & request) const1544 GetAccountAuthorizationDetailsOutcomeCallable IAMClient::GetAccountAuthorizationDetailsCallable(const GetAccountAuthorizationDetailsRequest& request) const
1545 {
1546 auto task = Aws::MakeShared< std::packaged_task< GetAccountAuthorizationDetailsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAccountAuthorizationDetails(request); } );
1547 auto packagedFunction = [task]() { (*task)(); };
1548 m_executor->Submit(packagedFunction);
1549 return task->get_future();
1550 }
1551
GetAccountAuthorizationDetailsAsync(const GetAccountAuthorizationDetailsRequest & request,const GetAccountAuthorizationDetailsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1552 void IAMClient::GetAccountAuthorizationDetailsAsync(const GetAccountAuthorizationDetailsRequest& request, const GetAccountAuthorizationDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1553 {
1554 m_executor->Submit( [this, request, handler, context](){ this->GetAccountAuthorizationDetailsAsyncHelper( request, handler, context ); } );
1555 }
1556
GetAccountAuthorizationDetailsAsyncHelper(const GetAccountAuthorizationDetailsRequest & request,const GetAccountAuthorizationDetailsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1557 void IAMClient::GetAccountAuthorizationDetailsAsyncHelper(const GetAccountAuthorizationDetailsRequest& request, const GetAccountAuthorizationDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1558 {
1559 handler(this, request, GetAccountAuthorizationDetails(request), context);
1560 }
1561
GetAccountPasswordPolicy(const GetAccountPasswordPolicyRequest & request) const1562 GetAccountPasswordPolicyOutcome IAMClient::GetAccountPasswordPolicy(const GetAccountPasswordPolicyRequest& request) const
1563 {
1564 Aws::Http::URI uri = m_uri;
1565 return GetAccountPasswordPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1566 }
1567
GetAccountPasswordPolicyCallable(const GetAccountPasswordPolicyRequest & request) const1568 GetAccountPasswordPolicyOutcomeCallable IAMClient::GetAccountPasswordPolicyCallable(const GetAccountPasswordPolicyRequest& request) const
1569 {
1570 auto task = Aws::MakeShared< std::packaged_task< GetAccountPasswordPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAccountPasswordPolicy(request); } );
1571 auto packagedFunction = [task]() { (*task)(); };
1572 m_executor->Submit(packagedFunction);
1573 return task->get_future();
1574 }
1575
GetAccountPasswordPolicyAsync(const GetAccountPasswordPolicyRequest & request,const GetAccountPasswordPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1576 void IAMClient::GetAccountPasswordPolicyAsync(const GetAccountPasswordPolicyRequest& request, const GetAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1577 {
1578 m_executor->Submit( [this, request, handler, context](){ this->GetAccountPasswordPolicyAsyncHelper( request, handler, context ); } );
1579 }
1580
GetAccountPasswordPolicyAsyncHelper(const GetAccountPasswordPolicyRequest & request,const GetAccountPasswordPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1581 void IAMClient::GetAccountPasswordPolicyAsyncHelper(const GetAccountPasswordPolicyRequest& request, const GetAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1582 {
1583 handler(this, request, GetAccountPasswordPolicy(request), context);
1584 }
1585
GetAccountSummary(const GetAccountSummaryRequest & request) const1586 GetAccountSummaryOutcome IAMClient::GetAccountSummary(const GetAccountSummaryRequest& request) const
1587 {
1588 Aws::Http::URI uri = m_uri;
1589 return GetAccountSummaryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1590 }
1591
GetAccountSummaryCallable(const GetAccountSummaryRequest & request) const1592 GetAccountSummaryOutcomeCallable IAMClient::GetAccountSummaryCallable(const GetAccountSummaryRequest& request) const
1593 {
1594 auto task = Aws::MakeShared< std::packaged_task< GetAccountSummaryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAccountSummary(request); } );
1595 auto packagedFunction = [task]() { (*task)(); };
1596 m_executor->Submit(packagedFunction);
1597 return task->get_future();
1598 }
1599
GetAccountSummaryAsync(const GetAccountSummaryRequest & request,const GetAccountSummaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1600 void IAMClient::GetAccountSummaryAsync(const GetAccountSummaryRequest& request, const GetAccountSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1601 {
1602 m_executor->Submit( [this, request, handler, context](){ this->GetAccountSummaryAsyncHelper( request, handler, context ); } );
1603 }
1604
GetAccountSummaryAsyncHelper(const GetAccountSummaryRequest & request,const GetAccountSummaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1605 void IAMClient::GetAccountSummaryAsyncHelper(const GetAccountSummaryRequest& request, const GetAccountSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1606 {
1607 handler(this, request, GetAccountSummary(request), context);
1608 }
1609
GetContextKeysForCustomPolicy(const GetContextKeysForCustomPolicyRequest & request) const1610 GetContextKeysForCustomPolicyOutcome IAMClient::GetContextKeysForCustomPolicy(const GetContextKeysForCustomPolicyRequest& request) const
1611 {
1612 Aws::Http::URI uri = m_uri;
1613 return GetContextKeysForCustomPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1614 }
1615
GetContextKeysForCustomPolicyCallable(const GetContextKeysForCustomPolicyRequest & request) const1616 GetContextKeysForCustomPolicyOutcomeCallable IAMClient::GetContextKeysForCustomPolicyCallable(const GetContextKeysForCustomPolicyRequest& request) const
1617 {
1618 auto task = Aws::MakeShared< std::packaged_task< GetContextKeysForCustomPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetContextKeysForCustomPolicy(request); } );
1619 auto packagedFunction = [task]() { (*task)(); };
1620 m_executor->Submit(packagedFunction);
1621 return task->get_future();
1622 }
1623
GetContextKeysForCustomPolicyAsync(const GetContextKeysForCustomPolicyRequest & request,const GetContextKeysForCustomPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1624 void IAMClient::GetContextKeysForCustomPolicyAsync(const GetContextKeysForCustomPolicyRequest& request, const GetContextKeysForCustomPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1625 {
1626 m_executor->Submit( [this, request, handler, context](){ this->GetContextKeysForCustomPolicyAsyncHelper( request, handler, context ); } );
1627 }
1628
GetContextKeysForCustomPolicyAsyncHelper(const GetContextKeysForCustomPolicyRequest & request,const GetContextKeysForCustomPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1629 void IAMClient::GetContextKeysForCustomPolicyAsyncHelper(const GetContextKeysForCustomPolicyRequest& request, const GetContextKeysForCustomPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1630 {
1631 handler(this, request, GetContextKeysForCustomPolicy(request), context);
1632 }
1633
GetContextKeysForPrincipalPolicy(const GetContextKeysForPrincipalPolicyRequest & request) const1634 GetContextKeysForPrincipalPolicyOutcome IAMClient::GetContextKeysForPrincipalPolicy(const GetContextKeysForPrincipalPolicyRequest& request) const
1635 {
1636 Aws::Http::URI uri = m_uri;
1637 return GetContextKeysForPrincipalPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1638 }
1639
GetContextKeysForPrincipalPolicyCallable(const GetContextKeysForPrincipalPolicyRequest & request) const1640 GetContextKeysForPrincipalPolicyOutcomeCallable IAMClient::GetContextKeysForPrincipalPolicyCallable(const GetContextKeysForPrincipalPolicyRequest& request) const
1641 {
1642 auto task = Aws::MakeShared< std::packaged_task< GetContextKeysForPrincipalPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetContextKeysForPrincipalPolicy(request); } );
1643 auto packagedFunction = [task]() { (*task)(); };
1644 m_executor->Submit(packagedFunction);
1645 return task->get_future();
1646 }
1647
GetContextKeysForPrincipalPolicyAsync(const GetContextKeysForPrincipalPolicyRequest & request,const GetContextKeysForPrincipalPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1648 void IAMClient::GetContextKeysForPrincipalPolicyAsync(const GetContextKeysForPrincipalPolicyRequest& request, const GetContextKeysForPrincipalPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1649 {
1650 m_executor->Submit( [this, request, handler, context](){ this->GetContextKeysForPrincipalPolicyAsyncHelper( request, handler, context ); } );
1651 }
1652
GetContextKeysForPrincipalPolicyAsyncHelper(const GetContextKeysForPrincipalPolicyRequest & request,const GetContextKeysForPrincipalPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1653 void IAMClient::GetContextKeysForPrincipalPolicyAsyncHelper(const GetContextKeysForPrincipalPolicyRequest& request, const GetContextKeysForPrincipalPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1654 {
1655 handler(this, request, GetContextKeysForPrincipalPolicy(request), context);
1656 }
1657
GetCredentialReport(const GetCredentialReportRequest & request) const1658 GetCredentialReportOutcome IAMClient::GetCredentialReport(const GetCredentialReportRequest& request) const
1659 {
1660 Aws::Http::URI uri = m_uri;
1661 return GetCredentialReportOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1662 }
1663
GetCredentialReportCallable(const GetCredentialReportRequest & request) const1664 GetCredentialReportOutcomeCallable IAMClient::GetCredentialReportCallable(const GetCredentialReportRequest& request) const
1665 {
1666 auto task = Aws::MakeShared< std::packaged_task< GetCredentialReportOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetCredentialReport(request); } );
1667 auto packagedFunction = [task]() { (*task)(); };
1668 m_executor->Submit(packagedFunction);
1669 return task->get_future();
1670 }
1671
GetCredentialReportAsync(const GetCredentialReportRequest & request,const GetCredentialReportResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1672 void IAMClient::GetCredentialReportAsync(const GetCredentialReportRequest& request, const GetCredentialReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1673 {
1674 m_executor->Submit( [this, request, handler, context](){ this->GetCredentialReportAsyncHelper( request, handler, context ); } );
1675 }
1676
GetCredentialReportAsyncHelper(const GetCredentialReportRequest & request,const GetCredentialReportResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1677 void IAMClient::GetCredentialReportAsyncHelper(const GetCredentialReportRequest& request, const GetCredentialReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1678 {
1679 handler(this, request, GetCredentialReport(request), context);
1680 }
1681
GetGroup(const GetGroupRequest & request) const1682 GetGroupOutcome IAMClient::GetGroup(const GetGroupRequest& request) const
1683 {
1684 Aws::Http::URI uri = m_uri;
1685 return GetGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1686 }
1687
GetGroupCallable(const GetGroupRequest & request) const1688 GetGroupOutcomeCallable IAMClient::GetGroupCallable(const GetGroupRequest& request) const
1689 {
1690 auto task = Aws::MakeShared< std::packaged_task< GetGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetGroup(request); } );
1691 auto packagedFunction = [task]() { (*task)(); };
1692 m_executor->Submit(packagedFunction);
1693 return task->get_future();
1694 }
1695
GetGroupAsync(const GetGroupRequest & request,const GetGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1696 void IAMClient::GetGroupAsync(const GetGroupRequest& request, const GetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1697 {
1698 m_executor->Submit( [this, request, handler, context](){ this->GetGroupAsyncHelper( request, handler, context ); } );
1699 }
1700
GetGroupAsyncHelper(const GetGroupRequest & request,const GetGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1701 void IAMClient::GetGroupAsyncHelper(const GetGroupRequest& request, const GetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1702 {
1703 handler(this, request, GetGroup(request), context);
1704 }
1705
GetGroupPolicy(const GetGroupPolicyRequest & request) const1706 GetGroupPolicyOutcome IAMClient::GetGroupPolicy(const GetGroupPolicyRequest& request) const
1707 {
1708 Aws::Http::URI uri = m_uri;
1709 return GetGroupPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1710 }
1711
GetGroupPolicyCallable(const GetGroupPolicyRequest & request) const1712 GetGroupPolicyOutcomeCallable IAMClient::GetGroupPolicyCallable(const GetGroupPolicyRequest& request) const
1713 {
1714 auto task = Aws::MakeShared< std::packaged_task< GetGroupPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetGroupPolicy(request); } );
1715 auto packagedFunction = [task]() { (*task)(); };
1716 m_executor->Submit(packagedFunction);
1717 return task->get_future();
1718 }
1719
GetGroupPolicyAsync(const GetGroupPolicyRequest & request,const GetGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1720 void IAMClient::GetGroupPolicyAsync(const GetGroupPolicyRequest& request, const GetGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1721 {
1722 m_executor->Submit( [this, request, handler, context](){ this->GetGroupPolicyAsyncHelper( request, handler, context ); } );
1723 }
1724
GetGroupPolicyAsyncHelper(const GetGroupPolicyRequest & request,const GetGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1725 void IAMClient::GetGroupPolicyAsyncHelper(const GetGroupPolicyRequest& request, const GetGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1726 {
1727 handler(this, request, GetGroupPolicy(request), context);
1728 }
1729
GetInstanceProfile(const GetInstanceProfileRequest & request) const1730 GetInstanceProfileOutcome IAMClient::GetInstanceProfile(const GetInstanceProfileRequest& request) const
1731 {
1732 Aws::Http::URI uri = m_uri;
1733 return GetInstanceProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1734 }
1735
GetInstanceProfileCallable(const GetInstanceProfileRequest & request) const1736 GetInstanceProfileOutcomeCallable IAMClient::GetInstanceProfileCallable(const GetInstanceProfileRequest& request) const
1737 {
1738 auto task = Aws::MakeShared< std::packaged_task< GetInstanceProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetInstanceProfile(request); } );
1739 auto packagedFunction = [task]() { (*task)(); };
1740 m_executor->Submit(packagedFunction);
1741 return task->get_future();
1742 }
1743
GetInstanceProfileAsync(const GetInstanceProfileRequest & request,const GetInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1744 void IAMClient::GetInstanceProfileAsync(const GetInstanceProfileRequest& request, const GetInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1745 {
1746 m_executor->Submit( [this, request, handler, context](){ this->GetInstanceProfileAsyncHelper( request, handler, context ); } );
1747 }
1748
GetInstanceProfileAsyncHelper(const GetInstanceProfileRequest & request,const GetInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1749 void IAMClient::GetInstanceProfileAsyncHelper(const GetInstanceProfileRequest& request, const GetInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1750 {
1751 handler(this, request, GetInstanceProfile(request), context);
1752 }
1753
GetLoginProfile(const GetLoginProfileRequest & request) const1754 GetLoginProfileOutcome IAMClient::GetLoginProfile(const GetLoginProfileRequest& request) const
1755 {
1756 Aws::Http::URI uri = m_uri;
1757 return GetLoginProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1758 }
1759
GetLoginProfileCallable(const GetLoginProfileRequest & request) const1760 GetLoginProfileOutcomeCallable IAMClient::GetLoginProfileCallable(const GetLoginProfileRequest& request) const
1761 {
1762 auto task = Aws::MakeShared< std::packaged_task< GetLoginProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetLoginProfile(request); } );
1763 auto packagedFunction = [task]() { (*task)(); };
1764 m_executor->Submit(packagedFunction);
1765 return task->get_future();
1766 }
1767
GetLoginProfileAsync(const GetLoginProfileRequest & request,const GetLoginProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1768 void IAMClient::GetLoginProfileAsync(const GetLoginProfileRequest& request, const GetLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1769 {
1770 m_executor->Submit( [this, request, handler, context](){ this->GetLoginProfileAsyncHelper( request, handler, context ); } );
1771 }
1772
GetLoginProfileAsyncHelper(const GetLoginProfileRequest & request,const GetLoginProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1773 void IAMClient::GetLoginProfileAsyncHelper(const GetLoginProfileRequest& request, const GetLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1774 {
1775 handler(this, request, GetLoginProfile(request), context);
1776 }
1777
GetOpenIDConnectProvider(const GetOpenIDConnectProviderRequest & request) const1778 GetOpenIDConnectProviderOutcome IAMClient::GetOpenIDConnectProvider(const GetOpenIDConnectProviderRequest& request) const
1779 {
1780 Aws::Http::URI uri = m_uri;
1781 return GetOpenIDConnectProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1782 }
1783
GetOpenIDConnectProviderCallable(const GetOpenIDConnectProviderRequest & request) const1784 GetOpenIDConnectProviderOutcomeCallable IAMClient::GetOpenIDConnectProviderCallable(const GetOpenIDConnectProviderRequest& request) const
1785 {
1786 auto task = Aws::MakeShared< std::packaged_task< GetOpenIDConnectProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetOpenIDConnectProvider(request); } );
1787 auto packagedFunction = [task]() { (*task)(); };
1788 m_executor->Submit(packagedFunction);
1789 return task->get_future();
1790 }
1791
GetOpenIDConnectProviderAsync(const GetOpenIDConnectProviderRequest & request,const GetOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1792 void IAMClient::GetOpenIDConnectProviderAsync(const GetOpenIDConnectProviderRequest& request, const GetOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1793 {
1794 m_executor->Submit( [this, request, handler, context](){ this->GetOpenIDConnectProviderAsyncHelper( request, handler, context ); } );
1795 }
1796
GetOpenIDConnectProviderAsyncHelper(const GetOpenIDConnectProviderRequest & request,const GetOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1797 void IAMClient::GetOpenIDConnectProviderAsyncHelper(const GetOpenIDConnectProviderRequest& request, const GetOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1798 {
1799 handler(this, request, GetOpenIDConnectProvider(request), context);
1800 }
1801
GetOrganizationsAccessReport(const GetOrganizationsAccessReportRequest & request) const1802 GetOrganizationsAccessReportOutcome IAMClient::GetOrganizationsAccessReport(const GetOrganizationsAccessReportRequest& request) const
1803 {
1804 Aws::Http::URI uri = m_uri;
1805 return GetOrganizationsAccessReportOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1806 }
1807
GetOrganizationsAccessReportCallable(const GetOrganizationsAccessReportRequest & request) const1808 GetOrganizationsAccessReportOutcomeCallable IAMClient::GetOrganizationsAccessReportCallable(const GetOrganizationsAccessReportRequest& request) const
1809 {
1810 auto task = Aws::MakeShared< std::packaged_task< GetOrganizationsAccessReportOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetOrganizationsAccessReport(request); } );
1811 auto packagedFunction = [task]() { (*task)(); };
1812 m_executor->Submit(packagedFunction);
1813 return task->get_future();
1814 }
1815
GetOrganizationsAccessReportAsync(const GetOrganizationsAccessReportRequest & request,const GetOrganizationsAccessReportResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1816 void IAMClient::GetOrganizationsAccessReportAsync(const GetOrganizationsAccessReportRequest& request, const GetOrganizationsAccessReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1817 {
1818 m_executor->Submit( [this, request, handler, context](){ this->GetOrganizationsAccessReportAsyncHelper( request, handler, context ); } );
1819 }
1820
GetOrganizationsAccessReportAsyncHelper(const GetOrganizationsAccessReportRequest & request,const GetOrganizationsAccessReportResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1821 void IAMClient::GetOrganizationsAccessReportAsyncHelper(const GetOrganizationsAccessReportRequest& request, const GetOrganizationsAccessReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1822 {
1823 handler(this, request, GetOrganizationsAccessReport(request), context);
1824 }
1825
GetPolicy(const GetPolicyRequest & request) const1826 GetPolicyOutcome IAMClient::GetPolicy(const GetPolicyRequest& request) const
1827 {
1828 Aws::Http::URI uri = m_uri;
1829 return GetPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1830 }
1831
GetPolicyCallable(const GetPolicyRequest & request) const1832 GetPolicyOutcomeCallable IAMClient::GetPolicyCallable(const GetPolicyRequest& request) const
1833 {
1834 auto task = Aws::MakeShared< std::packaged_task< GetPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPolicy(request); } );
1835 auto packagedFunction = [task]() { (*task)(); };
1836 m_executor->Submit(packagedFunction);
1837 return task->get_future();
1838 }
1839
GetPolicyAsync(const GetPolicyRequest & request,const GetPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1840 void IAMClient::GetPolicyAsync(const GetPolicyRequest& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1841 {
1842 m_executor->Submit( [this, request, handler, context](){ this->GetPolicyAsyncHelper( request, handler, context ); } );
1843 }
1844
GetPolicyAsyncHelper(const GetPolicyRequest & request,const GetPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1845 void IAMClient::GetPolicyAsyncHelper(const GetPolicyRequest& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1846 {
1847 handler(this, request, GetPolicy(request), context);
1848 }
1849
GetPolicyVersion(const GetPolicyVersionRequest & request) const1850 GetPolicyVersionOutcome IAMClient::GetPolicyVersion(const GetPolicyVersionRequest& request) const
1851 {
1852 Aws::Http::URI uri = m_uri;
1853 return GetPolicyVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1854 }
1855
GetPolicyVersionCallable(const GetPolicyVersionRequest & request) const1856 GetPolicyVersionOutcomeCallable IAMClient::GetPolicyVersionCallable(const GetPolicyVersionRequest& request) const
1857 {
1858 auto task = Aws::MakeShared< std::packaged_task< GetPolicyVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPolicyVersion(request); } );
1859 auto packagedFunction = [task]() { (*task)(); };
1860 m_executor->Submit(packagedFunction);
1861 return task->get_future();
1862 }
1863
GetPolicyVersionAsync(const GetPolicyVersionRequest & request,const GetPolicyVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1864 void IAMClient::GetPolicyVersionAsync(const GetPolicyVersionRequest& request, const GetPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1865 {
1866 m_executor->Submit( [this, request, handler, context](){ this->GetPolicyVersionAsyncHelper( request, handler, context ); } );
1867 }
1868
GetPolicyVersionAsyncHelper(const GetPolicyVersionRequest & request,const GetPolicyVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1869 void IAMClient::GetPolicyVersionAsyncHelper(const GetPolicyVersionRequest& request, const GetPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1870 {
1871 handler(this, request, GetPolicyVersion(request), context);
1872 }
1873
GetRole(const GetRoleRequest & request) const1874 GetRoleOutcome IAMClient::GetRole(const GetRoleRequest& request) const
1875 {
1876 Aws::Http::URI uri = m_uri;
1877 return GetRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1878 }
1879
GetRoleCallable(const GetRoleRequest & request) const1880 GetRoleOutcomeCallable IAMClient::GetRoleCallable(const GetRoleRequest& request) const
1881 {
1882 auto task = Aws::MakeShared< std::packaged_task< GetRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetRole(request); } );
1883 auto packagedFunction = [task]() { (*task)(); };
1884 m_executor->Submit(packagedFunction);
1885 return task->get_future();
1886 }
1887
GetRoleAsync(const GetRoleRequest & request,const GetRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1888 void IAMClient::GetRoleAsync(const GetRoleRequest& request, const GetRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1889 {
1890 m_executor->Submit( [this, request, handler, context](){ this->GetRoleAsyncHelper( request, handler, context ); } );
1891 }
1892
GetRoleAsyncHelper(const GetRoleRequest & request,const GetRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1893 void IAMClient::GetRoleAsyncHelper(const GetRoleRequest& request, const GetRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1894 {
1895 handler(this, request, GetRole(request), context);
1896 }
1897
GetRolePolicy(const GetRolePolicyRequest & request) const1898 GetRolePolicyOutcome IAMClient::GetRolePolicy(const GetRolePolicyRequest& request) const
1899 {
1900 Aws::Http::URI uri = m_uri;
1901 return GetRolePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1902 }
1903
GetRolePolicyCallable(const GetRolePolicyRequest & request) const1904 GetRolePolicyOutcomeCallable IAMClient::GetRolePolicyCallable(const GetRolePolicyRequest& request) const
1905 {
1906 auto task = Aws::MakeShared< std::packaged_task< GetRolePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetRolePolicy(request); } );
1907 auto packagedFunction = [task]() { (*task)(); };
1908 m_executor->Submit(packagedFunction);
1909 return task->get_future();
1910 }
1911
GetRolePolicyAsync(const GetRolePolicyRequest & request,const GetRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1912 void IAMClient::GetRolePolicyAsync(const GetRolePolicyRequest& request, const GetRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1913 {
1914 m_executor->Submit( [this, request, handler, context](){ this->GetRolePolicyAsyncHelper( request, handler, context ); } );
1915 }
1916
GetRolePolicyAsyncHelper(const GetRolePolicyRequest & request,const GetRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1917 void IAMClient::GetRolePolicyAsyncHelper(const GetRolePolicyRequest& request, const GetRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1918 {
1919 handler(this, request, GetRolePolicy(request), context);
1920 }
1921
GetSAMLProvider(const GetSAMLProviderRequest & request) const1922 GetSAMLProviderOutcome IAMClient::GetSAMLProvider(const GetSAMLProviderRequest& request) const
1923 {
1924 Aws::Http::URI uri = m_uri;
1925 return GetSAMLProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1926 }
1927
GetSAMLProviderCallable(const GetSAMLProviderRequest & request) const1928 GetSAMLProviderOutcomeCallable IAMClient::GetSAMLProviderCallable(const GetSAMLProviderRequest& request) const
1929 {
1930 auto task = Aws::MakeShared< std::packaged_task< GetSAMLProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetSAMLProvider(request); } );
1931 auto packagedFunction = [task]() { (*task)(); };
1932 m_executor->Submit(packagedFunction);
1933 return task->get_future();
1934 }
1935
GetSAMLProviderAsync(const GetSAMLProviderRequest & request,const GetSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1936 void IAMClient::GetSAMLProviderAsync(const GetSAMLProviderRequest& request, const GetSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1937 {
1938 m_executor->Submit( [this, request, handler, context](){ this->GetSAMLProviderAsyncHelper( request, handler, context ); } );
1939 }
1940
GetSAMLProviderAsyncHelper(const GetSAMLProviderRequest & request,const GetSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1941 void IAMClient::GetSAMLProviderAsyncHelper(const GetSAMLProviderRequest& request, const GetSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1942 {
1943 handler(this, request, GetSAMLProvider(request), context);
1944 }
1945
GetSSHPublicKey(const GetSSHPublicKeyRequest & request) const1946 GetSSHPublicKeyOutcome IAMClient::GetSSHPublicKey(const GetSSHPublicKeyRequest& request) const
1947 {
1948 Aws::Http::URI uri = m_uri;
1949 return GetSSHPublicKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1950 }
1951
GetSSHPublicKeyCallable(const GetSSHPublicKeyRequest & request) const1952 GetSSHPublicKeyOutcomeCallable IAMClient::GetSSHPublicKeyCallable(const GetSSHPublicKeyRequest& request) const
1953 {
1954 auto task = Aws::MakeShared< std::packaged_task< GetSSHPublicKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetSSHPublicKey(request); } );
1955 auto packagedFunction = [task]() { (*task)(); };
1956 m_executor->Submit(packagedFunction);
1957 return task->get_future();
1958 }
1959
GetSSHPublicKeyAsync(const GetSSHPublicKeyRequest & request,const GetSSHPublicKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1960 void IAMClient::GetSSHPublicKeyAsync(const GetSSHPublicKeyRequest& request, const GetSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1961 {
1962 m_executor->Submit( [this, request, handler, context](){ this->GetSSHPublicKeyAsyncHelper( request, handler, context ); } );
1963 }
1964
GetSSHPublicKeyAsyncHelper(const GetSSHPublicKeyRequest & request,const GetSSHPublicKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1965 void IAMClient::GetSSHPublicKeyAsyncHelper(const GetSSHPublicKeyRequest& request, const GetSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1966 {
1967 handler(this, request, GetSSHPublicKey(request), context);
1968 }
1969
GetServerCertificate(const GetServerCertificateRequest & request) const1970 GetServerCertificateOutcome IAMClient::GetServerCertificate(const GetServerCertificateRequest& request) const
1971 {
1972 Aws::Http::URI uri = m_uri;
1973 return GetServerCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1974 }
1975
GetServerCertificateCallable(const GetServerCertificateRequest & request) const1976 GetServerCertificateOutcomeCallable IAMClient::GetServerCertificateCallable(const GetServerCertificateRequest& request) const
1977 {
1978 auto task = Aws::MakeShared< std::packaged_task< GetServerCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetServerCertificate(request); } );
1979 auto packagedFunction = [task]() { (*task)(); };
1980 m_executor->Submit(packagedFunction);
1981 return task->get_future();
1982 }
1983
GetServerCertificateAsync(const GetServerCertificateRequest & request,const GetServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1984 void IAMClient::GetServerCertificateAsync(const GetServerCertificateRequest& request, const GetServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1985 {
1986 m_executor->Submit( [this, request, handler, context](){ this->GetServerCertificateAsyncHelper( request, handler, context ); } );
1987 }
1988
GetServerCertificateAsyncHelper(const GetServerCertificateRequest & request,const GetServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1989 void IAMClient::GetServerCertificateAsyncHelper(const GetServerCertificateRequest& request, const GetServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1990 {
1991 handler(this, request, GetServerCertificate(request), context);
1992 }
1993
GetServiceLastAccessedDetails(const GetServiceLastAccessedDetailsRequest & request) const1994 GetServiceLastAccessedDetailsOutcome IAMClient::GetServiceLastAccessedDetails(const GetServiceLastAccessedDetailsRequest& request) const
1995 {
1996 Aws::Http::URI uri = m_uri;
1997 return GetServiceLastAccessedDetailsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1998 }
1999
GetServiceLastAccessedDetailsCallable(const GetServiceLastAccessedDetailsRequest & request) const2000 GetServiceLastAccessedDetailsOutcomeCallable IAMClient::GetServiceLastAccessedDetailsCallable(const GetServiceLastAccessedDetailsRequest& request) const
2001 {
2002 auto task = Aws::MakeShared< std::packaged_task< GetServiceLastAccessedDetailsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetServiceLastAccessedDetails(request); } );
2003 auto packagedFunction = [task]() { (*task)(); };
2004 m_executor->Submit(packagedFunction);
2005 return task->get_future();
2006 }
2007
GetServiceLastAccessedDetailsAsync(const GetServiceLastAccessedDetailsRequest & request,const GetServiceLastAccessedDetailsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2008 void IAMClient::GetServiceLastAccessedDetailsAsync(const GetServiceLastAccessedDetailsRequest& request, const GetServiceLastAccessedDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2009 {
2010 m_executor->Submit( [this, request, handler, context](){ this->GetServiceLastAccessedDetailsAsyncHelper( request, handler, context ); } );
2011 }
2012
GetServiceLastAccessedDetailsAsyncHelper(const GetServiceLastAccessedDetailsRequest & request,const GetServiceLastAccessedDetailsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2013 void IAMClient::GetServiceLastAccessedDetailsAsyncHelper(const GetServiceLastAccessedDetailsRequest& request, const GetServiceLastAccessedDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2014 {
2015 handler(this, request, GetServiceLastAccessedDetails(request), context);
2016 }
2017
GetServiceLastAccessedDetailsWithEntities(const GetServiceLastAccessedDetailsWithEntitiesRequest & request) const2018 GetServiceLastAccessedDetailsWithEntitiesOutcome IAMClient::GetServiceLastAccessedDetailsWithEntities(const GetServiceLastAccessedDetailsWithEntitiesRequest& request) const
2019 {
2020 Aws::Http::URI uri = m_uri;
2021 return GetServiceLastAccessedDetailsWithEntitiesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2022 }
2023
GetServiceLastAccessedDetailsWithEntitiesCallable(const GetServiceLastAccessedDetailsWithEntitiesRequest & request) const2024 GetServiceLastAccessedDetailsWithEntitiesOutcomeCallable IAMClient::GetServiceLastAccessedDetailsWithEntitiesCallable(const GetServiceLastAccessedDetailsWithEntitiesRequest& request) const
2025 {
2026 auto task = Aws::MakeShared< std::packaged_task< GetServiceLastAccessedDetailsWithEntitiesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetServiceLastAccessedDetailsWithEntities(request); } );
2027 auto packagedFunction = [task]() { (*task)(); };
2028 m_executor->Submit(packagedFunction);
2029 return task->get_future();
2030 }
2031
GetServiceLastAccessedDetailsWithEntitiesAsync(const GetServiceLastAccessedDetailsWithEntitiesRequest & request,const GetServiceLastAccessedDetailsWithEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2032 void IAMClient::GetServiceLastAccessedDetailsWithEntitiesAsync(const GetServiceLastAccessedDetailsWithEntitiesRequest& request, const GetServiceLastAccessedDetailsWithEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2033 {
2034 m_executor->Submit( [this, request, handler, context](){ this->GetServiceLastAccessedDetailsWithEntitiesAsyncHelper( request, handler, context ); } );
2035 }
2036
GetServiceLastAccessedDetailsWithEntitiesAsyncHelper(const GetServiceLastAccessedDetailsWithEntitiesRequest & request,const GetServiceLastAccessedDetailsWithEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2037 void IAMClient::GetServiceLastAccessedDetailsWithEntitiesAsyncHelper(const GetServiceLastAccessedDetailsWithEntitiesRequest& request, const GetServiceLastAccessedDetailsWithEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2038 {
2039 handler(this, request, GetServiceLastAccessedDetailsWithEntities(request), context);
2040 }
2041
GetServiceLinkedRoleDeletionStatus(const GetServiceLinkedRoleDeletionStatusRequest & request) const2042 GetServiceLinkedRoleDeletionStatusOutcome IAMClient::GetServiceLinkedRoleDeletionStatus(const GetServiceLinkedRoleDeletionStatusRequest& request) const
2043 {
2044 Aws::Http::URI uri = m_uri;
2045 return GetServiceLinkedRoleDeletionStatusOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2046 }
2047
GetServiceLinkedRoleDeletionStatusCallable(const GetServiceLinkedRoleDeletionStatusRequest & request) const2048 GetServiceLinkedRoleDeletionStatusOutcomeCallable IAMClient::GetServiceLinkedRoleDeletionStatusCallable(const GetServiceLinkedRoleDeletionStatusRequest& request) const
2049 {
2050 auto task = Aws::MakeShared< std::packaged_task< GetServiceLinkedRoleDeletionStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetServiceLinkedRoleDeletionStatus(request); } );
2051 auto packagedFunction = [task]() { (*task)(); };
2052 m_executor->Submit(packagedFunction);
2053 return task->get_future();
2054 }
2055
GetServiceLinkedRoleDeletionStatusAsync(const GetServiceLinkedRoleDeletionStatusRequest & request,const GetServiceLinkedRoleDeletionStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2056 void IAMClient::GetServiceLinkedRoleDeletionStatusAsync(const GetServiceLinkedRoleDeletionStatusRequest& request, const GetServiceLinkedRoleDeletionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2057 {
2058 m_executor->Submit( [this, request, handler, context](){ this->GetServiceLinkedRoleDeletionStatusAsyncHelper( request, handler, context ); } );
2059 }
2060
GetServiceLinkedRoleDeletionStatusAsyncHelper(const GetServiceLinkedRoleDeletionStatusRequest & request,const GetServiceLinkedRoleDeletionStatusResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2061 void IAMClient::GetServiceLinkedRoleDeletionStatusAsyncHelper(const GetServiceLinkedRoleDeletionStatusRequest& request, const GetServiceLinkedRoleDeletionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2062 {
2063 handler(this, request, GetServiceLinkedRoleDeletionStatus(request), context);
2064 }
2065
GetUser(const GetUserRequest & request) const2066 GetUserOutcome IAMClient::GetUser(const GetUserRequest& request) const
2067 {
2068 Aws::Http::URI uri = m_uri;
2069 return GetUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2070 }
2071
GetUserCallable(const GetUserRequest & request) const2072 GetUserOutcomeCallable IAMClient::GetUserCallable(const GetUserRequest& request) const
2073 {
2074 auto task = Aws::MakeShared< std::packaged_task< GetUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetUser(request); } );
2075 auto packagedFunction = [task]() { (*task)(); };
2076 m_executor->Submit(packagedFunction);
2077 return task->get_future();
2078 }
2079
GetUserAsync(const GetUserRequest & request,const GetUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2080 void IAMClient::GetUserAsync(const GetUserRequest& request, const GetUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2081 {
2082 m_executor->Submit( [this, request, handler, context](){ this->GetUserAsyncHelper( request, handler, context ); } );
2083 }
2084
GetUserAsyncHelper(const GetUserRequest & request,const GetUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2085 void IAMClient::GetUserAsyncHelper(const GetUserRequest& request, const GetUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2086 {
2087 handler(this, request, GetUser(request), context);
2088 }
2089
GetUserPolicy(const GetUserPolicyRequest & request) const2090 GetUserPolicyOutcome IAMClient::GetUserPolicy(const GetUserPolicyRequest& request) const
2091 {
2092 Aws::Http::URI uri = m_uri;
2093 return GetUserPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2094 }
2095
GetUserPolicyCallable(const GetUserPolicyRequest & request) const2096 GetUserPolicyOutcomeCallable IAMClient::GetUserPolicyCallable(const GetUserPolicyRequest& request) const
2097 {
2098 auto task = Aws::MakeShared< std::packaged_task< GetUserPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetUserPolicy(request); } );
2099 auto packagedFunction = [task]() { (*task)(); };
2100 m_executor->Submit(packagedFunction);
2101 return task->get_future();
2102 }
2103
GetUserPolicyAsync(const GetUserPolicyRequest & request,const GetUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2104 void IAMClient::GetUserPolicyAsync(const GetUserPolicyRequest& request, const GetUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2105 {
2106 m_executor->Submit( [this, request, handler, context](){ this->GetUserPolicyAsyncHelper( request, handler, context ); } );
2107 }
2108
GetUserPolicyAsyncHelper(const GetUserPolicyRequest & request,const GetUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2109 void IAMClient::GetUserPolicyAsyncHelper(const GetUserPolicyRequest& request, const GetUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2110 {
2111 handler(this, request, GetUserPolicy(request), context);
2112 }
2113
ListAccessKeys(const ListAccessKeysRequest & request) const2114 ListAccessKeysOutcome IAMClient::ListAccessKeys(const ListAccessKeysRequest& request) const
2115 {
2116 Aws::Http::URI uri = m_uri;
2117 return ListAccessKeysOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2118 }
2119
ListAccessKeysCallable(const ListAccessKeysRequest & request) const2120 ListAccessKeysOutcomeCallable IAMClient::ListAccessKeysCallable(const ListAccessKeysRequest& request) const
2121 {
2122 auto task = Aws::MakeShared< std::packaged_task< ListAccessKeysOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAccessKeys(request); } );
2123 auto packagedFunction = [task]() { (*task)(); };
2124 m_executor->Submit(packagedFunction);
2125 return task->get_future();
2126 }
2127
ListAccessKeysAsync(const ListAccessKeysRequest & request,const ListAccessKeysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2128 void IAMClient::ListAccessKeysAsync(const ListAccessKeysRequest& request, const ListAccessKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2129 {
2130 m_executor->Submit( [this, request, handler, context](){ this->ListAccessKeysAsyncHelper( request, handler, context ); } );
2131 }
2132
ListAccessKeysAsyncHelper(const ListAccessKeysRequest & request,const ListAccessKeysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2133 void IAMClient::ListAccessKeysAsyncHelper(const ListAccessKeysRequest& request, const ListAccessKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2134 {
2135 handler(this, request, ListAccessKeys(request), context);
2136 }
2137
ListAccountAliases(const ListAccountAliasesRequest & request) const2138 ListAccountAliasesOutcome IAMClient::ListAccountAliases(const ListAccountAliasesRequest& request) const
2139 {
2140 Aws::Http::URI uri = m_uri;
2141 return ListAccountAliasesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2142 }
2143
ListAccountAliasesCallable(const ListAccountAliasesRequest & request) const2144 ListAccountAliasesOutcomeCallable IAMClient::ListAccountAliasesCallable(const ListAccountAliasesRequest& request) const
2145 {
2146 auto task = Aws::MakeShared< std::packaged_task< ListAccountAliasesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAccountAliases(request); } );
2147 auto packagedFunction = [task]() { (*task)(); };
2148 m_executor->Submit(packagedFunction);
2149 return task->get_future();
2150 }
2151
ListAccountAliasesAsync(const ListAccountAliasesRequest & request,const ListAccountAliasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2152 void IAMClient::ListAccountAliasesAsync(const ListAccountAliasesRequest& request, const ListAccountAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2153 {
2154 m_executor->Submit( [this, request, handler, context](){ this->ListAccountAliasesAsyncHelper( request, handler, context ); } );
2155 }
2156
ListAccountAliasesAsyncHelper(const ListAccountAliasesRequest & request,const ListAccountAliasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2157 void IAMClient::ListAccountAliasesAsyncHelper(const ListAccountAliasesRequest& request, const ListAccountAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2158 {
2159 handler(this, request, ListAccountAliases(request), context);
2160 }
2161
ListAttachedGroupPolicies(const ListAttachedGroupPoliciesRequest & request) const2162 ListAttachedGroupPoliciesOutcome IAMClient::ListAttachedGroupPolicies(const ListAttachedGroupPoliciesRequest& request) const
2163 {
2164 Aws::Http::URI uri = m_uri;
2165 return ListAttachedGroupPoliciesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2166 }
2167
ListAttachedGroupPoliciesCallable(const ListAttachedGroupPoliciesRequest & request) const2168 ListAttachedGroupPoliciesOutcomeCallable IAMClient::ListAttachedGroupPoliciesCallable(const ListAttachedGroupPoliciesRequest& request) const
2169 {
2170 auto task = Aws::MakeShared< std::packaged_task< ListAttachedGroupPoliciesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAttachedGroupPolicies(request); } );
2171 auto packagedFunction = [task]() { (*task)(); };
2172 m_executor->Submit(packagedFunction);
2173 return task->get_future();
2174 }
2175
ListAttachedGroupPoliciesAsync(const ListAttachedGroupPoliciesRequest & request,const ListAttachedGroupPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2176 void IAMClient::ListAttachedGroupPoliciesAsync(const ListAttachedGroupPoliciesRequest& request, const ListAttachedGroupPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2177 {
2178 m_executor->Submit( [this, request, handler, context](){ this->ListAttachedGroupPoliciesAsyncHelper( request, handler, context ); } );
2179 }
2180
ListAttachedGroupPoliciesAsyncHelper(const ListAttachedGroupPoliciesRequest & request,const ListAttachedGroupPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2181 void IAMClient::ListAttachedGroupPoliciesAsyncHelper(const ListAttachedGroupPoliciesRequest& request, const ListAttachedGroupPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2182 {
2183 handler(this, request, ListAttachedGroupPolicies(request), context);
2184 }
2185
ListAttachedRolePolicies(const ListAttachedRolePoliciesRequest & request) const2186 ListAttachedRolePoliciesOutcome IAMClient::ListAttachedRolePolicies(const ListAttachedRolePoliciesRequest& request) const
2187 {
2188 Aws::Http::URI uri = m_uri;
2189 return ListAttachedRolePoliciesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2190 }
2191
ListAttachedRolePoliciesCallable(const ListAttachedRolePoliciesRequest & request) const2192 ListAttachedRolePoliciesOutcomeCallable IAMClient::ListAttachedRolePoliciesCallable(const ListAttachedRolePoliciesRequest& request) const
2193 {
2194 auto task = Aws::MakeShared< std::packaged_task< ListAttachedRolePoliciesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAttachedRolePolicies(request); } );
2195 auto packagedFunction = [task]() { (*task)(); };
2196 m_executor->Submit(packagedFunction);
2197 return task->get_future();
2198 }
2199
ListAttachedRolePoliciesAsync(const ListAttachedRolePoliciesRequest & request,const ListAttachedRolePoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2200 void IAMClient::ListAttachedRolePoliciesAsync(const ListAttachedRolePoliciesRequest& request, const ListAttachedRolePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2201 {
2202 m_executor->Submit( [this, request, handler, context](){ this->ListAttachedRolePoliciesAsyncHelper( request, handler, context ); } );
2203 }
2204
ListAttachedRolePoliciesAsyncHelper(const ListAttachedRolePoliciesRequest & request,const ListAttachedRolePoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2205 void IAMClient::ListAttachedRolePoliciesAsyncHelper(const ListAttachedRolePoliciesRequest& request, const ListAttachedRolePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2206 {
2207 handler(this, request, ListAttachedRolePolicies(request), context);
2208 }
2209
ListAttachedUserPolicies(const ListAttachedUserPoliciesRequest & request) const2210 ListAttachedUserPoliciesOutcome IAMClient::ListAttachedUserPolicies(const ListAttachedUserPoliciesRequest& request) const
2211 {
2212 Aws::Http::URI uri = m_uri;
2213 return ListAttachedUserPoliciesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2214 }
2215
ListAttachedUserPoliciesCallable(const ListAttachedUserPoliciesRequest & request) const2216 ListAttachedUserPoliciesOutcomeCallable IAMClient::ListAttachedUserPoliciesCallable(const ListAttachedUserPoliciesRequest& request) const
2217 {
2218 auto task = Aws::MakeShared< std::packaged_task< ListAttachedUserPoliciesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAttachedUserPolicies(request); } );
2219 auto packagedFunction = [task]() { (*task)(); };
2220 m_executor->Submit(packagedFunction);
2221 return task->get_future();
2222 }
2223
ListAttachedUserPoliciesAsync(const ListAttachedUserPoliciesRequest & request,const ListAttachedUserPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2224 void IAMClient::ListAttachedUserPoliciesAsync(const ListAttachedUserPoliciesRequest& request, const ListAttachedUserPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2225 {
2226 m_executor->Submit( [this, request, handler, context](){ this->ListAttachedUserPoliciesAsyncHelper( request, handler, context ); } );
2227 }
2228
ListAttachedUserPoliciesAsyncHelper(const ListAttachedUserPoliciesRequest & request,const ListAttachedUserPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2229 void IAMClient::ListAttachedUserPoliciesAsyncHelper(const ListAttachedUserPoliciesRequest& request, const ListAttachedUserPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2230 {
2231 handler(this, request, ListAttachedUserPolicies(request), context);
2232 }
2233
ListEntitiesForPolicy(const ListEntitiesForPolicyRequest & request) const2234 ListEntitiesForPolicyOutcome IAMClient::ListEntitiesForPolicy(const ListEntitiesForPolicyRequest& request) const
2235 {
2236 Aws::Http::URI uri = m_uri;
2237 return ListEntitiesForPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2238 }
2239
ListEntitiesForPolicyCallable(const ListEntitiesForPolicyRequest & request) const2240 ListEntitiesForPolicyOutcomeCallable IAMClient::ListEntitiesForPolicyCallable(const ListEntitiesForPolicyRequest& request) const
2241 {
2242 auto task = Aws::MakeShared< std::packaged_task< ListEntitiesForPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListEntitiesForPolicy(request); } );
2243 auto packagedFunction = [task]() { (*task)(); };
2244 m_executor->Submit(packagedFunction);
2245 return task->get_future();
2246 }
2247
ListEntitiesForPolicyAsync(const ListEntitiesForPolicyRequest & request,const ListEntitiesForPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2248 void IAMClient::ListEntitiesForPolicyAsync(const ListEntitiesForPolicyRequest& request, const ListEntitiesForPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2249 {
2250 m_executor->Submit( [this, request, handler, context](){ this->ListEntitiesForPolicyAsyncHelper( request, handler, context ); } );
2251 }
2252
ListEntitiesForPolicyAsyncHelper(const ListEntitiesForPolicyRequest & request,const ListEntitiesForPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2253 void IAMClient::ListEntitiesForPolicyAsyncHelper(const ListEntitiesForPolicyRequest& request, const ListEntitiesForPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2254 {
2255 handler(this, request, ListEntitiesForPolicy(request), context);
2256 }
2257
ListGroupPolicies(const ListGroupPoliciesRequest & request) const2258 ListGroupPoliciesOutcome IAMClient::ListGroupPolicies(const ListGroupPoliciesRequest& request) const
2259 {
2260 Aws::Http::URI uri = m_uri;
2261 return ListGroupPoliciesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2262 }
2263
ListGroupPoliciesCallable(const ListGroupPoliciesRequest & request) const2264 ListGroupPoliciesOutcomeCallable IAMClient::ListGroupPoliciesCallable(const ListGroupPoliciesRequest& request) const
2265 {
2266 auto task = Aws::MakeShared< std::packaged_task< ListGroupPoliciesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListGroupPolicies(request); } );
2267 auto packagedFunction = [task]() { (*task)(); };
2268 m_executor->Submit(packagedFunction);
2269 return task->get_future();
2270 }
2271
ListGroupPoliciesAsync(const ListGroupPoliciesRequest & request,const ListGroupPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2272 void IAMClient::ListGroupPoliciesAsync(const ListGroupPoliciesRequest& request, const ListGroupPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2273 {
2274 m_executor->Submit( [this, request, handler, context](){ this->ListGroupPoliciesAsyncHelper( request, handler, context ); } );
2275 }
2276
ListGroupPoliciesAsyncHelper(const ListGroupPoliciesRequest & request,const ListGroupPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2277 void IAMClient::ListGroupPoliciesAsyncHelper(const ListGroupPoliciesRequest& request, const ListGroupPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2278 {
2279 handler(this, request, ListGroupPolicies(request), context);
2280 }
2281
ListGroups(const ListGroupsRequest & request) const2282 ListGroupsOutcome IAMClient::ListGroups(const ListGroupsRequest& request) const
2283 {
2284 Aws::Http::URI uri = m_uri;
2285 return ListGroupsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2286 }
2287
ListGroupsCallable(const ListGroupsRequest & request) const2288 ListGroupsOutcomeCallable IAMClient::ListGroupsCallable(const ListGroupsRequest& request) const
2289 {
2290 auto task = Aws::MakeShared< std::packaged_task< ListGroupsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListGroups(request); } );
2291 auto packagedFunction = [task]() { (*task)(); };
2292 m_executor->Submit(packagedFunction);
2293 return task->get_future();
2294 }
2295
ListGroupsAsync(const ListGroupsRequest & request,const ListGroupsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2296 void IAMClient::ListGroupsAsync(const ListGroupsRequest& request, const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2297 {
2298 m_executor->Submit( [this, request, handler, context](){ this->ListGroupsAsyncHelper( request, handler, context ); } );
2299 }
2300
ListGroupsAsyncHelper(const ListGroupsRequest & request,const ListGroupsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2301 void IAMClient::ListGroupsAsyncHelper(const ListGroupsRequest& request, const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2302 {
2303 handler(this, request, ListGroups(request), context);
2304 }
2305
ListGroupsForUser(const ListGroupsForUserRequest & request) const2306 ListGroupsForUserOutcome IAMClient::ListGroupsForUser(const ListGroupsForUserRequest& request) const
2307 {
2308 Aws::Http::URI uri = m_uri;
2309 return ListGroupsForUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2310 }
2311
ListGroupsForUserCallable(const ListGroupsForUserRequest & request) const2312 ListGroupsForUserOutcomeCallable IAMClient::ListGroupsForUserCallable(const ListGroupsForUserRequest& request) const
2313 {
2314 auto task = Aws::MakeShared< std::packaged_task< ListGroupsForUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListGroupsForUser(request); } );
2315 auto packagedFunction = [task]() { (*task)(); };
2316 m_executor->Submit(packagedFunction);
2317 return task->get_future();
2318 }
2319
ListGroupsForUserAsync(const ListGroupsForUserRequest & request,const ListGroupsForUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2320 void IAMClient::ListGroupsForUserAsync(const ListGroupsForUserRequest& request, const ListGroupsForUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2321 {
2322 m_executor->Submit( [this, request, handler, context](){ this->ListGroupsForUserAsyncHelper( request, handler, context ); } );
2323 }
2324
ListGroupsForUserAsyncHelper(const ListGroupsForUserRequest & request,const ListGroupsForUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2325 void IAMClient::ListGroupsForUserAsyncHelper(const ListGroupsForUserRequest& request, const ListGroupsForUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2326 {
2327 handler(this, request, ListGroupsForUser(request), context);
2328 }
2329
ListInstanceProfileTags(const ListInstanceProfileTagsRequest & request) const2330 ListInstanceProfileTagsOutcome IAMClient::ListInstanceProfileTags(const ListInstanceProfileTagsRequest& request) const
2331 {
2332 Aws::Http::URI uri = m_uri;
2333 return ListInstanceProfileTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2334 }
2335
ListInstanceProfileTagsCallable(const ListInstanceProfileTagsRequest & request) const2336 ListInstanceProfileTagsOutcomeCallable IAMClient::ListInstanceProfileTagsCallable(const ListInstanceProfileTagsRequest& request) const
2337 {
2338 auto task = Aws::MakeShared< std::packaged_task< ListInstanceProfileTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListInstanceProfileTags(request); } );
2339 auto packagedFunction = [task]() { (*task)(); };
2340 m_executor->Submit(packagedFunction);
2341 return task->get_future();
2342 }
2343
ListInstanceProfileTagsAsync(const ListInstanceProfileTagsRequest & request,const ListInstanceProfileTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2344 void IAMClient::ListInstanceProfileTagsAsync(const ListInstanceProfileTagsRequest& request, const ListInstanceProfileTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2345 {
2346 m_executor->Submit( [this, request, handler, context](){ this->ListInstanceProfileTagsAsyncHelper( request, handler, context ); } );
2347 }
2348
ListInstanceProfileTagsAsyncHelper(const ListInstanceProfileTagsRequest & request,const ListInstanceProfileTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2349 void IAMClient::ListInstanceProfileTagsAsyncHelper(const ListInstanceProfileTagsRequest& request, const ListInstanceProfileTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2350 {
2351 handler(this, request, ListInstanceProfileTags(request), context);
2352 }
2353
ListInstanceProfiles(const ListInstanceProfilesRequest & request) const2354 ListInstanceProfilesOutcome IAMClient::ListInstanceProfiles(const ListInstanceProfilesRequest& request) const
2355 {
2356 Aws::Http::URI uri = m_uri;
2357 return ListInstanceProfilesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2358 }
2359
ListInstanceProfilesCallable(const ListInstanceProfilesRequest & request) const2360 ListInstanceProfilesOutcomeCallable IAMClient::ListInstanceProfilesCallable(const ListInstanceProfilesRequest& request) const
2361 {
2362 auto task = Aws::MakeShared< std::packaged_task< ListInstanceProfilesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListInstanceProfiles(request); } );
2363 auto packagedFunction = [task]() { (*task)(); };
2364 m_executor->Submit(packagedFunction);
2365 return task->get_future();
2366 }
2367
ListInstanceProfilesAsync(const ListInstanceProfilesRequest & request,const ListInstanceProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2368 void IAMClient::ListInstanceProfilesAsync(const ListInstanceProfilesRequest& request, const ListInstanceProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2369 {
2370 m_executor->Submit( [this, request, handler, context](){ this->ListInstanceProfilesAsyncHelper( request, handler, context ); } );
2371 }
2372
ListInstanceProfilesAsyncHelper(const ListInstanceProfilesRequest & request,const ListInstanceProfilesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2373 void IAMClient::ListInstanceProfilesAsyncHelper(const ListInstanceProfilesRequest& request, const ListInstanceProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2374 {
2375 handler(this, request, ListInstanceProfiles(request), context);
2376 }
2377
ListInstanceProfilesForRole(const ListInstanceProfilesForRoleRequest & request) const2378 ListInstanceProfilesForRoleOutcome IAMClient::ListInstanceProfilesForRole(const ListInstanceProfilesForRoleRequest& request) const
2379 {
2380 Aws::Http::URI uri = m_uri;
2381 return ListInstanceProfilesForRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2382 }
2383
ListInstanceProfilesForRoleCallable(const ListInstanceProfilesForRoleRequest & request) const2384 ListInstanceProfilesForRoleOutcomeCallable IAMClient::ListInstanceProfilesForRoleCallable(const ListInstanceProfilesForRoleRequest& request) const
2385 {
2386 auto task = Aws::MakeShared< std::packaged_task< ListInstanceProfilesForRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListInstanceProfilesForRole(request); } );
2387 auto packagedFunction = [task]() { (*task)(); };
2388 m_executor->Submit(packagedFunction);
2389 return task->get_future();
2390 }
2391
ListInstanceProfilesForRoleAsync(const ListInstanceProfilesForRoleRequest & request,const ListInstanceProfilesForRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2392 void IAMClient::ListInstanceProfilesForRoleAsync(const ListInstanceProfilesForRoleRequest& request, const ListInstanceProfilesForRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2393 {
2394 m_executor->Submit( [this, request, handler, context](){ this->ListInstanceProfilesForRoleAsyncHelper( request, handler, context ); } );
2395 }
2396
ListInstanceProfilesForRoleAsyncHelper(const ListInstanceProfilesForRoleRequest & request,const ListInstanceProfilesForRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2397 void IAMClient::ListInstanceProfilesForRoleAsyncHelper(const ListInstanceProfilesForRoleRequest& request, const ListInstanceProfilesForRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2398 {
2399 handler(this, request, ListInstanceProfilesForRole(request), context);
2400 }
2401
ListMFADeviceTags(const ListMFADeviceTagsRequest & request) const2402 ListMFADeviceTagsOutcome IAMClient::ListMFADeviceTags(const ListMFADeviceTagsRequest& request) const
2403 {
2404 Aws::Http::URI uri = m_uri;
2405 return ListMFADeviceTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2406 }
2407
ListMFADeviceTagsCallable(const ListMFADeviceTagsRequest & request) const2408 ListMFADeviceTagsOutcomeCallable IAMClient::ListMFADeviceTagsCallable(const ListMFADeviceTagsRequest& request) const
2409 {
2410 auto task = Aws::MakeShared< std::packaged_task< ListMFADeviceTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListMFADeviceTags(request); } );
2411 auto packagedFunction = [task]() { (*task)(); };
2412 m_executor->Submit(packagedFunction);
2413 return task->get_future();
2414 }
2415
ListMFADeviceTagsAsync(const ListMFADeviceTagsRequest & request,const ListMFADeviceTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2416 void IAMClient::ListMFADeviceTagsAsync(const ListMFADeviceTagsRequest& request, const ListMFADeviceTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2417 {
2418 m_executor->Submit( [this, request, handler, context](){ this->ListMFADeviceTagsAsyncHelper( request, handler, context ); } );
2419 }
2420
ListMFADeviceTagsAsyncHelper(const ListMFADeviceTagsRequest & request,const ListMFADeviceTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2421 void IAMClient::ListMFADeviceTagsAsyncHelper(const ListMFADeviceTagsRequest& request, const ListMFADeviceTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2422 {
2423 handler(this, request, ListMFADeviceTags(request), context);
2424 }
2425
ListMFADevices(const ListMFADevicesRequest & request) const2426 ListMFADevicesOutcome IAMClient::ListMFADevices(const ListMFADevicesRequest& request) const
2427 {
2428 Aws::Http::URI uri = m_uri;
2429 return ListMFADevicesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2430 }
2431
ListMFADevicesCallable(const ListMFADevicesRequest & request) const2432 ListMFADevicesOutcomeCallable IAMClient::ListMFADevicesCallable(const ListMFADevicesRequest& request) const
2433 {
2434 auto task = Aws::MakeShared< std::packaged_task< ListMFADevicesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListMFADevices(request); } );
2435 auto packagedFunction = [task]() { (*task)(); };
2436 m_executor->Submit(packagedFunction);
2437 return task->get_future();
2438 }
2439
ListMFADevicesAsync(const ListMFADevicesRequest & request,const ListMFADevicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2440 void IAMClient::ListMFADevicesAsync(const ListMFADevicesRequest& request, const ListMFADevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2441 {
2442 m_executor->Submit( [this, request, handler, context](){ this->ListMFADevicesAsyncHelper( request, handler, context ); } );
2443 }
2444
ListMFADevicesAsyncHelper(const ListMFADevicesRequest & request,const ListMFADevicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2445 void IAMClient::ListMFADevicesAsyncHelper(const ListMFADevicesRequest& request, const ListMFADevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2446 {
2447 handler(this, request, ListMFADevices(request), context);
2448 }
2449
ListOpenIDConnectProviderTags(const ListOpenIDConnectProviderTagsRequest & request) const2450 ListOpenIDConnectProviderTagsOutcome IAMClient::ListOpenIDConnectProviderTags(const ListOpenIDConnectProviderTagsRequest& request) const
2451 {
2452 Aws::Http::URI uri = m_uri;
2453 return ListOpenIDConnectProviderTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2454 }
2455
ListOpenIDConnectProviderTagsCallable(const ListOpenIDConnectProviderTagsRequest & request) const2456 ListOpenIDConnectProviderTagsOutcomeCallable IAMClient::ListOpenIDConnectProviderTagsCallable(const ListOpenIDConnectProviderTagsRequest& request) const
2457 {
2458 auto task = Aws::MakeShared< std::packaged_task< ListOpenIDConnectProviderTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListOpenIDConnectProviderTags(request); } );
2459 auto packagedFunction = [task]() { (*task)(); };
2460 m_executor->Submit(packagedFunction);
2461 return task->get_future();
2462 }
2463
ListOpenIDConnectProviderTagsAsync(const ListOpenIDConnectProviderTagsRequest & request,const ListOpenIDConnectProviderTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2464 void IAMClient::ListOpenIDConnectProviderTagsAsync(const ListOpenIDConnectProviderTagsRequest& request, const ListOpenIDConnectProviderTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2465 {
2466 m_executor->Submit( [this, request, handler, context](){ this->ListOpenIDConnectProviderTagsAsyncHelper( request, handler, context ); } );
2467 }
2468
ListOpenIDConnectProviderTagsAsyncHelper(const ListOpenIDConnectProviderTagsRequest & request,const ListOpenIDConnectProviderTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2469 void IAMClient::ListOpenIDConnectProviderTagsAsyncHelper(const ListOpenIDConnectProviderTagsRequest& request, const ListOpenIDConnectProviderTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2470 {
2471 handler(this, request, ListOpenIDConnectProviderTags(request), context);
2472 }
2473
ListOpenIDConnectProviders(const ListOpenIDConnectProvidersRequest & request) const2474 ListOpenIDConnectProvidersOutcome IAMClient::ListOpenIDConnectProviders(const ListOpenIDConnectProvidersRequest& request) const
2475 {
2476 Aws::Http::URI uri = m_uri;
2477 return ListOpenIDConnectProvidersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2478 }
2479
ListOpenIDConnectProvidersCallable(const ListOpenIDConnectProvidersRequest & request) const2480 ListOpenIDConnectProvidersOutcomeCallable IAMClient::ListOpenIDConnectProvidersCallable(const ListOpenIDConnectProvidersRequest& request) const
2481 {
2482 auto task = Aws::MakeShared< std::packaged_task< ListOpenIDConnectProvidersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListOpenIDConnectProviders(request); } );
2483 auto packagedFunction = [task]() { (*task)(); };
2484 m_executor->Submit(packagedFunction);
2485 return task->get_future();
2486 }
2487
ListOpenIDConnectProvidersAsync(const ListOpenIDConnectProvidersRequest & request,const ListOpenIDConnectProvidersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2488 void IAMClient::ListOpenIDConnectProvidersAsync(const ListOpenIDConnectProvidersRequest& request, const ListOpenIDConnectProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2489 {
2490 m_executor->Submit( [this, request, handler, context](){ this->ListOpenIDConnectProvidersAsyncHelper( request, handler, context ); } );
2491 }
2492
ListOpenIDConnectProvidersAsyncHelper(const ListOpenIDConnectProvidersRequest & request,const ListOpenIDConnectProvidersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2493 void IAMClient::ListOpenIDConnectProvidersAsyncHelper(const ListOpenIDConnectProvidersRequest& request, const ListOpenIDConnectProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2494 {
2495 handler(this, request, ListOpenIDConnectProviders(request), context);
2496 }
2497
ListPolicies(const ListPoliciesRequest & request) const2498 ListPoliciesOutcome IAMClient::ListPolicies(const ListPoliciesRequest& request) const
2499 {
2500 Aws::Http::URI uri = m_uri;
2501 return ListPoliciesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2502 }
2503
ListPoliciesCallable(const ListPoliciesRequest & request) const2504 ListPoliciesOutcomeCallable IAMClient::ListPoliciesCallable(const ListPoliciesRequest& request) const
2505 {
2506 auto task = Aws::MakeShared< std::packaged_task< ListPoliciesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPolicies(request); } );
2507 auto packagedFunction = [task]() { (*task)(); };
2508 m_executor->Submit(packagedFunction);
2509 return task->get_future();
2510 }
2511
ListPoliciesAsync(const ListPoliciesRequest & request,const ListPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2512 void IAMClient::ListPoliciesAsync(const ListPoliciesRequest& request, const ListPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2513 {
2514 m_executor->Submit( [this, request, handler, context](){ this->ListPoliciesAsyncHelper( request, handler, context ); } );
2515 }
2516
ListPoliciesAsyncHelper(const ListPoliciesRequest & request,const ListPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2517 void IAMClient::ListPoliciesAsyncHelper(const ListPoliciesRequest& request, const ListPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2518 {
2519 handler(this, request, ListPolicies(request), context);
2520 }
2521
ListPoliciesGrantingServiceAccess(const ListPoliciesGrantingServiceAccessRequest & request) const2522 ListPoliciesGrantingServiceAccessOutcome IAMClient::ListPoliciesGrantingServiceAccess(const ListPoliciesGrantingServiceAccessRequest& request) const
2523 {
2524 Aws::Http::URI uri = m_uri;
2525 return ListPoliciesGrantingServiceAccessOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2526 }
2527
ListPoliciesGrantingServiceAccessCallable(const ListPoliciesGrantingServiceAccessRequest & request) const2528 ListPoliciesGrantingServiceAccessOutcomeCallable IAMClient::ListPoliciesGrantingServiceAccessCallable(const ListPoliciesGrantingServiceAccessRequest& request) const
2529 {
2530 auto task = Aws::MakeShared< std::packaged_task< ListPoliciesGrantingServiceAccessOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPoliciesGrantingServiceAccess(request); } );
2531 auto packagedFunction = [task]() { (*task)(); };
2532 m_executor->Submit(packagedFunction);
2533 return task->get_future();
2534 }
2535
ListPoliciesGrantingServiceAccessAsync(const ListPoliciesGrantingServiceAccessRequest & request,const ListPoliciesGrantingServiceAccessResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2536 void IAMClient::ListPoliciesGrantingServiceAccessAsync(const ListPoliciesGrantingServiceAccessRequest& request, const ListPoliciesGrantingServiceAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2537 {
2538 m_executor->Submit( [this, request, handler, context](){ this->ListPoliciesGrantingServiceAccessAsyncHelper( request, handler, context ); } );
2539 }
2540
ListPoliciesGrantingServiceAccessAsyncHelper(const ListPoliciesGrantingServiceAccessRequest & request,const ListPoliciesGrantingServiceAccessResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2541 void IAMClient::ListPoliciesGrantingServiceAccessAsyncHelper(const ListPoliciesGrantingServiceAccessRequest& request, const ListPoliciesGrantingServiceAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2542 {
2543 handler(this, request, ListPoliciesGrantingServiceAccess(request), context);
2544 }
2545
ListPolicyTags(const ListPolicyTagsRequest & request) const2546 ListPolicyTagsOutcome IAMClient::ListPolicyTags(const ListPolicyTagsRequest& request) const
2547 {
2548 Aws::Http::URI uri = m_uri;
2549 return ListPolicyTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2550 }
2551
ListPolicyTagsCallable(const ListPolicyTagsRequest & request) const2552 ListPolicyTagsOutcomeCallable IAMClient::ListPolicyTagsCallable(const ListPolicyTagsRequest& request) const
2553 {
2554 auto task = Aws::MakeShared< std::packaged_task< ListPolicyTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPolicyTags(request); } );
2555 auto packagedFunction = [task]() { (*task)(); };
2556 m_executor->Submit(packagedFunction);
2557 return task->get_future();
2558 }
2559
ListPolicyTagsAsync(const ListPolicyTagsRequest & request,const ListPolicyTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2560 void IAMClient::ListPolicyTagsAsync(const ListPolicyTagsRequest& request, const ListPolicyTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2561 {
2562 m_executor->Submit( [this, request, handler, context](){ this->ListPolicyTagsAsyncHelper( request, handler, context ); } );
2563 }
2564
ListPolicyTagsAsyncHelper(const ListPolicyTagsRequest & request,const ListPolicyTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2565 void IAMClient::ListPolicyTagsAsyncHelper(const ListPolicyTagsRequest& request, const ListPolicyTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2566 {
2567 handler(this, request, ListPolicyTags(request), context);
2568 }
2569
ListPolicyVersions(const ListPolicyVersionsRequest & request) const2570 ListPolicyVersionsOutcome IAMClient::ListPolicyVersions(const ListPolicyVersionsRequest& request) const
2571 {
2572 Aws::Http::URI uri = m_uri;
2573 return ListPolicyVersionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2574 }
2575
ListPolicyVersionsCallable(const ListPolicyVersionsRequest & request) const2576 ListPolicyVersionsOutcomeCallable IAMClient::ListPolicyVersionsCallable(const ListPolicyVersionsRequest& request) const
2577 {
2578 auto task = Aws::MakeShared< std::packaged_task< ListPolicyVersionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPolicyVersions(request); } );
2579 auto packagedFunction = [task]() { (*task)(); };
2580 m_executor->Submit(packagedFunction);
2581 return task->get_future();
2582 }
2583
ListPolicyVersionsAsync(const ListPolicyVersionsRequest & request,const ListPolicyVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2584 void IAMClient::ListPolicyVersionsAsync(const ListPolicyVersionsRequest& request, const ListPolicyVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2585 {
2586 m_executor->Submit( [this, request, handler, context](){ this->ListPolicyVersionsAsyncHelper( request, handler, context ); } );
2587 }
2588
ListPolicyVersionsAsyncHelper(const ListPolicyVersionsRequest & request,const ListPolicyVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2589 void IAMClient::ListPolicyVersionsAsyncHelper(const ListPolicyVersionsRequest& request, const ListPolicyVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2590 {
2591 handler(this, request, ListPolicyVersions(request), context);
2592 }
2593
ListRolePolicies(const ListRolePoliciesRequest & request) const2594 ListRolePoliciesOutcome IAMClient::ListRolePolicies(const ListRolePoliciesRequest& request) const
2595 {
2596 Aws::Http::URI uri = m_uri;
2597 return ListRolePoliciesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2598 }
2599
ListRolePoliciesCallable(const ListRolePoliciesRequest & request) const2600 ListRolePoliciesOutcomeCallable IAMClient::ListRolePoliciesCallable(const ListRolePoliciesRequest& request) const
2601 {
2602 auto task = Aws::MakeShared< std::packaged_task< ListRolePoliciesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRolePolicies(request); } );
2603 auto packagedFunction = [task]() { (*task)(); };
2604 m_executor->Submit(packagedFunction);
2605 return task->get_future();
2606 }
2607
ListRolePoliciesAsync(const ListRolePoliciesRequest & request,const ListRolePoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2608 void IAMClient::ListRolePoliciesAsync(const ListRolePoliciesRequest& request, const ListRolePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2609 {
2610 m_executor->Submit( [this, request, handler, context](){ this->ListRolePoliciesAsyncHelper( request, handler, context ); } );
2611 }
2612
ListRolePoliciesAsyncHelper(const ListRolePoliciesRequest & request,const ListRolePoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2613 void IAMClient::ListRolePoliciesAsyncHelper(const ListRolePoliciesRequest& request, const ListRolePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2614 {
2615 handler(this, request, ListRolePolicies(request), context);
2616 }
2617
ListRoleTags(const ListRoleTagsRequest & request) const2618 ListRoleTagsOutcome IAMClient::ListRoleTags(const ListRoleTagsRequest& request) const
2619 {
2620 Aws::Http::URI uri = m_uri;
2621 return ListRoleTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2622 }
2623
ListRoleTagsCallable(const ListRoleTagsRequest & request) const2624 ListRoleTagsOutcomeCallable IAMClient::ListRoleTagsCallable(const ListRoleTagsRequest& request) const
2625 {
2626 auto task = Aws::MakeShared< std::packaged_task< ListRoleTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRoleTags(request); } );
2627 auto packagedFunction = [task]() { (*task)(); };
2628 m_executor->Submit(packagedFunction);
2629 return task->get_future();
2630 }
2631
ListRoleTagsAsync(const ListRoleTagsRequest & request,const ListRoleTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2632 void IAMClient::ListRoleTagsAsync(const ListRoleTagsRequest& request, const ListRoleTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2633 {
2634 m_executor->Submit( [this, request, handler, context](){ this->ListRoleTagsAsyncHelper( request, handler, context ); } );
2635 }
2636
ListRoleTagsAsyncHelper(const ListRoleTagsRequest & request,const ListRoleTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2637 void IAMClient::ListRoleTagsAsyncHelper(const ListRoleTagsRequest& request, const ListRoleTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2638 {
2639 handler(this, request, ListRoleTags(request), context);
2640 }
2641
ListRoles(const ListRolesRequest & request) const2642 ListRolesOutcome IAMClient::ListRoles(const ListRolesRequest& request) const
2643 {
2644 Aws::Http::URI uri = m_uri;
2645 return ListRolesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2646 }
2647
ListRolesCallable(const ListRolesRequest & request) const2648 ListRolesOutcomeCallable IAMClient::ListRolesCallable(const ListRolesRequest& request) const
2649 {
2650 auto task = Aws::MakeShared< std::packaged_task< ListRolesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRoles(request); } );
2651 auto packagedFunction = [task]() { (*task)(); };
2652 m_executor->Submit(packagedFunction);
2653 return task->get_future();
2654 }
2655
ListRolesAsync(const ListRolesRequest & request,const ListRolesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2656 void IAMClient::ListRolesAsync(const ListRolesRequest& request, const ListRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2657 {
2658 m_executor->Submit( [this, request, handler, context](){ this->ListRolesAsyncHelper( request, handler, context ); } );
2659 }
2660
ListRolesAsyncHelper(const ListRolesRequest & request,const ListRolesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2661 void IAMClient::ListRolesAsyncHelper(const ListRolesRequest& request, const ListRolesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2662 {
2663 handler(this, request, ListRoles(request), context);
2664 }
2665
ListSAMLProviderTags(const ListSAMLProviderTagsRequest & request) const2666 ListSAMLProviderTagsOutcome IAMClient::ListSAMLProviderTags(const ListSAMLProviderTagsRequest& request) const
2667 {
2668 Aws::Http::URI uri = m_uri;
2669 return ListSAMLProviderTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2670 }
2671
ListSAMLProviderTagsCallable(const ListSAMLProviderTagsRequest & request) const2672 ListSAMLProviderTagsOutcomeCallable IAMClient::ListSAMLProviderTagsCallable(const ListSAMLProviderTagsRequest& request) const
2673 {
2674 auto task = Aws::MakeShared< std::packaged_task< ListSAMLProviderTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSAMLProviderTags(request); } );
2675 auto packagedFunction = [task]() { (*task)(); };
2676 m_executor->Submit(packagedFunction);
2677 return task->get_future();
2678 }
2679
ListSAMLProviderTagsAsync(const ListSAMLProviderTagsRequest & request,const ListSAMLProviderTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2680 void IAMClient::ListSAMLProviderTagsAsync(const ListSAMLProviderTagsRequest& request, const ListSAMLProviderTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2681 {
2682 m_executor->Submit( [this, request, handler, context](){ this->ListSAMLProviderTagsAsyncHelper( request, handler, context ); } );
2683 }
2684
ListSAMLProviderTagsAsyncHelper(const ListSAMLProviderTagsRequest & request,const ListSAMLProviderTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2685 void IAMClient::ListSAMLProviderTagsAsyncHelper(const ListSAMLProviderTagsRequest& request, const ListSAMLProviderTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2686 {
2687 handler(this, request, ListSAMLProviderTags(request), context);
2688 }
2689
ListSAMLProviders(const ListSAMLProvidersRequest & request) const2690 ListSAMLProvidersOutcome IAMClient::ListSAMLProviders(const ListSAMLProvidersRequest& request) const
2691 {
2692 Aws::Http::URI uri = m_uri;
2693 return ListSAMLProvidersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2694 }
2695
ListSAMLProvidersCallable(const ListSAMLProvidersRequest & request) const2696 ListSAMLProvidersOutcomeCallable IAMClient::ListSAMLProvidersCallable(const ListSAMLProvidersRequest& request) const
2697 {
2698 auto task = Aws::MakeShared< std::packaged_task< ListSAMLProvidersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSAMLProviders(request); } );
2699 auto packagedFunction = [task]() { (*task)(); };
2700 m_executor->Submit(packagedFunction);
2701 return task->get_future();
2702 }
2703
ListSAMLProvidersAsync(const ListSAMLProvidersRequest & request,const ListSAMLProvidersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2704 void IAMClient::ListSAMLProvidersAsync(const ListSAMLProvidersRequest& request, const ListSAMLProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2705 {
2706 m_executor->Submit( [this, request, handler, context](){ this->ListSAMLProvidersAsyncHelper( request, handler, context ); } );
2707 }
2708
ListSAMLProvidersAsyncHelper(const ListSAMLProvidersRequest & request,const ListSAMLProvidersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2709 void IAMClient::ListSAMLProvidersAsyncHelper(const ListSAMLProvidersRequest& request, const ListSAMLProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2710 {
2711 handler(this, request, ListSAMLProviders(request), context);
2712 }
2713
ListSSHPublicKeys(const ListSSHPublicKeysRequest & request) const2714 ListSSHPublicKeysOutcome IAMClient::ListSSHPublicKeys(const ListSSHPublicKeysRequest& request) const
2715 {
2716 Aws::Http::URI uri = m_uri;
2717 return ListSSHPublicKeysOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2718 }
2719
ListSSHPublicKeysCallable(const ListSSHPublicKeysRequest & request) const2720 ListSSHPublicKeysOutcomeCallable IAMClient::ListSSHPublicKeysCallable(const ListSSHPublicKeysRequest& request) const
2721 {
2722 auto task = Aws::MakeShared< std::packaged_task< ListSSHPublicKeysOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSSHPublicKeys(request); } );
2723 auto packagedFunction = [task]() { (*task)(); };
2724 m_executor->Submit(packagedFunction);
2725 return task->get_future();
2726 }
2727
ListSSHPublicKeysAsync(const ListSSHPublicKeysRequest & request,const ListSSHPublicKeysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2728 void IAMClient::ListSSHPublicKeysAsync(const ListSSHPublicKeysRequest& request, const ListSSHPublicKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2729 {
2730 m_executor->Submit( [this, request, handler, context](){ this->ListSSHPublicKeysAsyncHelper( request, handler, context ); } );
2731 }
2732
ListSSHPublicKeysAsyncHelper(const ListSSHPublicKeysRequest & request,const ListSSHPublicKeysResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2733 void IAMClient::ListSSHPublicKeysAsyncHelper(const ListSSHPublicKeysRequest& request, const ListSSHPublicKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2734 {
2735 handler(this, request, ListSSHPublicKeys(request), context);
2736 }
2737
ListServerCertificateTags(const ListServerCertificateTagsRequest & request) const2738 ListServerCertificateTagsOutcome IAMClient::ListServerCertificateTags(const ListServerCertificateTagsRequest& request) const
2739 {
2740 Aws::Http::URI uri = m_uri;
2741 return ListServerCertificateTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2742 }
2743
ListServerCertificateTagsCallable(const ListServerCertificateTagsRequest & request) const2744 ListServerCertificateTagsOutcomeCallable IAMClient::ListServerCertificateTagsCallable(const ListServerCertificateTagsRequest& request) const
2745 {
2746 auto task = Aws::MakeShared< std::packaged_task< ListServerCertificateTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListServerCertificateTags(request); } );
2747 auto packagedFunction = [task]() { (*task)(); };
2748 m_executor->Submit(packagedFunction);
2749 return task->get_future();
2750 }
2751
ListServerCertificateTagsAsync(const ListServerCertificateTagsRequest & request,const ListServerCertificateTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2752 void IAMClient::ListServerCertificateTagsAsync(const ListServerCertificateTagsRequest& request, const ListServerCertificateTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2753 {
2754 m_executor->Submit( [this, request, handler, context](){ this->ListServerCertificateTagsAsyncHelper( request, handler, context ); } );
2755 }
2756
ListServerCertificateTagsAsyncHelper(const ListServerCertificateTagsRequest & request,const ListServerCertificateTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2757 void IAMClient::ListServerCertificateTagsAsyncHelper(const ListServerCertificateTagsRequest& request, const ListServerCertificateTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2758 {
2759 handler(this, request, ListServerCertificateTags(request), context);
2760 }
2761
ListServerCertificates(const ListServerCertificatesRequest & request) const2762 ListServerCertificatesOutcome IAMClient::ListServerCertificates(const ListServerCertificatesRequest& request) const
2763 {
2764 Aws::Http::URI uri = m_uri;
2765 return ListServerCertificatesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2766 }
2767
ListServerCertificatesCallable(const ListServerCertificatesRequest & request) const2768 ListServerCertificatesOutcomeCallable IAMClient::ListServerCertificatesCallable(const ListServerCertificatesRequest& request) const
2769 {
2770 auto task = Aws::MakeShared< std::packaged_task< ListServerCertificatesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListServerCertificates(request); } );
2771 auto packagedFunction = [task]() { (*task)(); };
2772 m_executor->Submit(packagedFunction);
2773 return task->get_future();
2774 }
2775
ListServerCertificatesAsync(const ListServerCertificatesRequest & request,const ListServerCertificatesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2776 void IAMClient::ListServerCertificatesAsync(const ListServerCertificatesRequest& request, const ListServerCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2777 {
2778 m_executor->Submit( [this, request, handler, context](){ this->ListServerCertificatesAsyncHelper( request, handler, context ); } );
2779 }
2780
ListServerCertificatesAsyncHelper(const ListServerCertificatesRequest & request,const ListServerCertificatesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2781 void IAMClient::ListServerCertificatesAsyncHelper(const ListServerCertificatesRequest& request, const ListServerCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2782 {
2783 handler(this, request, ListServerCertificates(request), context);
2784 }
2785
ListServiceSpecificCredentials(const ListServiceSpecificCredentialsRequest & request) const2786 ListServiceSpecificCredentialsOutcome IAMClient::ListServiceSpecificCredentials(const ListServiceSpecificCredentialsRequest& request) const
2787 {
2788 Aws::Http::URI uri = m_uri;
2789 return ListServiceSpecificCredentialsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2790 }
2791
ListServiceSpecificCredentialsCallable(const ListServiceSpecificCredentialsRequest & request) const2792 ListServiceSpecificCredentialsOutcomeCallable IAMClient::ListServiceSpecificCredentialsCallable(const ListServiceSpecificCredentialsRequest& request) const
2793 {
2794 auto task = Aws::MakeShared< std::packaged_task< ListServiceSpecificCredentialsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListServiceSpecificCredentials(request); } );
2795 auto packagedFunction = [task]() { (*task)(); };
2796 m_executor->Submit(packagedFunction);
2797 return task->get_future();
2798 }
2799
ListServiceSpecificCredentialsAsync(const ListServiceSpecificCredentialsRequest & request,const ListServiceSpecificCredentialsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2800 void IAMClient::ListServiceSpecificCredentialsAsync(const ListServiceSpecificCredentialsRequest& request, const ListServiceSpecificCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2801 {
2802 m_executor->Submit( [this, request, handler, context](){ this->ListServiceSpecificCredentialsAsyncHelper( request, handler, context ); } );
2803 }
2804
ListServiceSpecificCredentialsAsyncHelper(const ListServiceSpecificCredentialsRequest & request,const ListServiceSpecificCredentialsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2805 void IAMClient::ListServiceSpecificCredentialsAsyncHelper(const ListServiceSpecificCredentialsRequest& request, const ListServiceSpecificCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2806 {
2807 handler(this, request, ListServiceSpecificCredentials(request), context);
2808 }
2809
ListSigningCertificates(const ListSigningCertificatesRequest & request) const2810 ListSigningCertificatesOutcome IAMClient::ListSigningCertificates(const ListSigningCertificatesRequest& request) const
2811 {
2812 Aws::Http::URI uri = m_uri;
2813 return ListSigningCertificatesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2814 }
2815
ListSigningCertificatesCallable(const ListSigningCertificatesRequest & request) const2816 ListSigningCertificatesOutcomeCallable IAMClient::ListSigningCertificatesCallable(const ListSigningCertificatesRequest& request) const
2817 {
2818 auto task = Aws::MakeShared< std::packaged_task< ListSigningCertificatesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSigningCertificates(request); } );
2819 auto packagedFunction = [task]() { (*task)(); };
2820 m_executor->Submit(packagedFunction);
2821 return task->get_future();
2822 }
2823
ListSigningCertificatesAsync(const ListSigningCertificatesRequest & request,const ListSigningCertificatesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2824 void IAMClient::ListSigningCertificatesAsync(const ListSigningCertificatesRequest& request, const ListSigningCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2825 {
2826 m_executor->Submit( [this, request, handler, context](){ this->ListSigningCertificatesAsyncHelper( request, handler, context ); } );
2827 }
2828
ListSigningCertificatesAsyncHelper(const ListSigningCertificatesRequest & request,const ListSigningCertificatesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2829 void IAMClient::ListSigningCertificatesAsyncHelper(const ListSigningCertificatesRequest& request, const ListSigningCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2830 {
2831 handler(this, request, ListSigningCertificates(request), context);
2832 }
2833
ListUserPolicies(const ListUserPoliciesRequest & request) const2834 ListUserPoliciesOutcome IAMClient::ListUserPolicies(const ListUserPoliciesRequest& request) const
2835 {
2836 Aws::Http::URI uri = m_uri;
2837 return ListUserPoliciesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2838 }
2839
ListUserPoliciesCallable(const ListUserPoliciesRequest & request) const2840 ListUserPoliciesOutcomeCallable IAMClient::ListUserPoliciesCallable(const ListUserPoliciesRequest& request) const
2841 {
2842 auto task = Aws::MakeShared< std::packaged_task< ListUserPoliciesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListUserPolicies(request); } );
2843 auto packagedFunction = [task]() { (*task)(); };
2844 m_executor->Submit(packagedFunction);
2845 return task->get_future();
2846 }
2847
ListUserPoliciesAsync(const ListUserPoliciesRequest & request,const ListUserPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2848 void IAMClient::ListUserPoliciesAsync(const ListUserPoliciesRequest& request, const ListUserPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2849 {
2850 m_executor->Submit( [this, request, handler, context](){ this->ListUserPoliciesAsyncHelper( request, handler, context ); } );
2851 }
2852
ListUserPoliciesAsyncHelper(const ListUserPoliciesRequest & request,const ListUserPoliciesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2853 void IAMClient::ListUserPoliciesAsyncHelper(const ListUserPoliciesRequest& request, const ListUserPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2854 {
2855 handler(this, request, ListUserPolicies(request), context);
2856 }
2857
ListUserTags(const ListUserTagsRequest & request) const2858 ListUserTagsOutcome IAMClient::ListUserTags(const ListUserTagsRequest& request) const
2859 {
2860 Aws::Http::URI uri = m_uri;
2861 return ListUserTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2862 }
2863
ListUserTagsCallable(const ListUserTagsRequest & request) const2864 ListUserTagsOutcomeCallable IAMClient::ListUserTagsCallable(const ListUserTagsRequest& request) const
2865 {
2866 auto task = Aws::MakeShared< std::packaged_task< ListUserTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListUserTags(request); } );
2867 auto packagedFunction = [task]() { (*task)(); };
2868 m_executor->Submit(packagedFunction);
2869 return task->get_future();
2870 }
2871
ListUserTagsAsync(const ListUserTagsRequest & request,const ListUserTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2872 void IAMClient::ListUserTagsAsync(const ListUserTagsRequest& request, const ListUserTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2873 {
2874 m_executor->Submit( [this, request, handler, context](){ this->ListUserTagsAsyncHelper( request, handler, context ); } );
2875 }
2876
ListUserTagsAsyncHelper(const ListUserTagsRequest & request,const ListUserTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2877 void IAMClient::ListUserTagsAsyncHelper(const ListUserTagsRequest& request, const ListUserTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2878 {
2879 handler(this, request, ListUserTags(request), context);
2880 }
2881
ListUsers(const ListUsersRequest & request) const2882 ListUsersOutcome IAMClient::ListUsers(const ListUsersRequest& request) const
2883 {
2884 Aws::Http::URI uri = m_uri;
2885 return ListUsersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2886 }
2887
ListUsersCallable(const ListUsersRequest & request) const2888 ListUsersOutcomeCallable IAMClient::ListUsersCallable(const ListUsersRequest& request) const
2889 {
2890 auto task = Aws::MakeShared< std::packaged_task< ListUsersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListUsers(request); } );
2891 auto packagedFunction = [task]() { (*task)(); };
2892 m_executor->Submit(packagedFunction);
2893 return task->get_future();
2894 }
2895
ListUsersAsync(const ListUsersRequest & request,const ListUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2896 void IAMClient::ListUsersAsync(const ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2897 {
2898 m_executor->Submit( [this, request, handler, context](){ this->ListUsersAsyncHelper( request, handler, context ); } );
2899 }
2900
ListUsersAsyncHelper(const ListUsersRequest & request,const ListUsersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2901 void IAMClient::ListUsersAsyncHelper(const ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2902 {
2903 handler(this, request, ListUsers(request), context);
2904 }
2905
ListVirtualMFADevices(const ListVirtualMFADevicesRequest & request) const2906 ListVirtualMFADevicesOutcome IAMClient::ListVirtualMFADevices(const ListVirtualMFADevicesRequest& request) const
2907 {
2908 Aws::Http::URI uri = m_uri;
2909 return ListVirtualMFADevicesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2910 }
2911
ListVirtualMFADevicesCallable(const ListVirtualMFADevicesRequest & request) const2912 ListVirtualMFADevicesOutcomeCallable IAMClient::ListVirtualMFADevicesCallable(const ListVirtualMFADevicesRequest& request) const
2913 {
2914 auto task = Aws::MakeShared< std::packaged_task< ListVirtualMFADevicesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVirtualMFADevices(request); } );
2915 auto packagedFunction = [task]() { (*task)(); };
2916 m_executor->Submit(packagedFunction);
2917 return task->get_future();
2918 }
2919
ListVirtualMFADevicesAsync(const ListVirtualMFADevicesRequest & request,const ListVirtualMFADevicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2920 void IAMClient::ListVirtualMFADevicesAsync(const ListVirtualMFADevicesRequest& request, const ListVirtualMFADevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2921 {
2922 m_executor->Submit( [this, request, handler, context](){ this->ListVirtualMFADevicesAsyncHelper( request, handler, context ); } );
2923 }
2924
ListVirtualMFADevicesAsyncHelper(const ListVirtualMFADevicesRequest & request,const ListVirtualMFADevicesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2925 void IAMClient::ListVirtualMFADevicesAsyncHelper(const ListVirtualMFADevicesRequest& request, const ListVirtualMFADevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2926 {
2927 handler(this, request, ListVirtualMFADevices(request), context);
2928 }
2929
PutGroupPolicy(const PutGroupPolicyRequest & request) const2930 PutGroupPolicyOutcome IAMClient::PutGroupPolicy(const PutGroupPolicyRequest& request) const
2931 {
2932 Aws::Http::URI uri = m_uri;
2933 return PutGroupPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2934 }
2935
PutGroupPolicyCallable(const PutGroupPolicyRequest & request) const2936 PutGroupPolicyOutcomeCallable IAMClient::PutGroupPolicyCallable(const PutGroupPolicyRequest& request) const
2937 {
2938 auto task = Aws::MakeShared< std::packaged_task< PutGroupPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutGroupPolicy(request); } );
2939 auto packagedFunction = [task]() { (*task)(); };
2940 m_executor->Submit(packagedFunction);
2941 return task->get_future();
2942 }
2943
PutGroupPolicyAsync(const PutGroupPolicyRequest & request,const PutGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2944 void IAMClient::PutGroupPolicyAsync(const PutGroupPolicyRequest& request, const PutGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2945 {
2946 m_executor->Submit( [this, request, handler, context](){ this->PutGroupPolicyAsyncHelper( request, handler, context ); } );
2947 }
2948
PutGroupPolicyAsyncHelper(const PutGroupPolicyRequest & request,const PutGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2949 void IAMClient::PutGroupPolicyAsyncHelper(const PutGroupPolicyRequest& request, const PutGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2950 {
2951 handler(this, request, PutGroupPolicy(request), context);
2952 }
2953
PutRolePermissionsBoundary(const PutRolePermissionsBoundaryRequest & request) const2954 PutRolePermissionsBoundaryOutcome IAMClient::PutRolePermissionsBoundary(const PutRolePermissionsBoundaryRequest& request) const
2955 {
2956 Aws::Http::URI uri = m_uri;
2957 return PutRolePermissionsBoundaryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2958 }
2959
PutRolePermissionsBoundaryCallable(const PutRolePermissionsBoundaryRequest & request) const2960 PutRolePermissionsBoundaryOutcomeCallable IAMClient::PutRolePermissionsBoundaryCallable(const PutRolePermissionsBoundaryRequest& request) const
2961 {
2962 auto task = Aws::MakeShared< std::packaged_task< PutRolePermissionsBoundaryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutRolePermissionsBoundary(request); } );
2963 auto packagedFunction = [task]() { (*task)(); };
2964 m_executor->Submit(packagedFunction);
2965 return task->get_future();
2966 }
2967
PutRolePermissionsBoundaryAsync(const PutRolePermissionsBoundaryRequest & request,const PutRolePermissionsBoundaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2968 void IAMClient::PutRolePermissionsBoundaryAsync(const PutRolePermissionsBoundaryRequest& request, const PutRolePermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2969 {
2970 m_executor->Submit( [this, request, handler, context](){ this->PutRolePermissionsBoundaryAsyncHelper( request, handler, context ); } );
2971 }
2972
PutRolePermissionsBoundaryAsyncHelper(const PutRolePermissionsBoundaryRequest & request,const PutRolePermissionsBoundaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2973 void IAMClient::PutRolePermissionsBoundaryAsyncHelper(const PutRolePermissionsBoundaryRequest& request, const PutRolePermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2974 {
2975 handler(this, request, PutRolePermissionsBoundary(request), context);
2976 }
2977
PutRolePolicy(const PutRolePolicyRequest & request) const2978 PutRolePolicyOutcome IAMClient::PutRolePolicy(const PutRolePolicyRequest& request) const
2979 {
2980 Aws::Http::URI uri = m_uri;
2981 return PutRolePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
2982 }
2983
PutRolePolicyCallable(const PutRolePolicyRequest & request) const2984 PutRolePolicyOutcomeCallable IAMClient::PutRolePolicyCallable(const PutRolePolicyRequest& request) const
2985 {
2986 auto task = Aws::MakeShared< std::packaged_task< PutRolePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutRolePolicy(request); } );
2987 auto packagedFunction = [task]() { (*task)(); };
2988 m_executor->Submit(packagedFunction);
2989 return task->get_future();
2990 }
2991
PutRolePolicyAsync(const PutRolePolicyRequest & request,const PutRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2992 void IAMClient::PutRolePolicyAsync(const PutRolePolicyRequest& request, const PutRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2993 {
2994 m_executor->Submit( [this, request, handler, context](){ this->PutRolePolicyAsyncHelper( request, handler, context ); } );
2995 }
2996
PutRolePolicyAsyncHelper(const PutRolePolicyRequest & request,const PutRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2997 void IAMClient::PutRolePolicyAsyncHelper(const PutRolePolicyRequest& request, const PutRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2998 {
2999 handler(this, request, PutRolePolicy(request), context);
3000 }
3001
PutUserPermissionsBoundary(const PutUserPermissionsBoundaryRequest & request) const3002 PutUserPermissionsBoundaryOutcome IAMClient::PutUserPermissionsBoundary(const PutUserPermissionsBoundaryRequest& request) const
3003 {
3004 Aws::Http::URI uri = m_uri;
3005 return PutUserPermissionsBoundaryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3006 }
3007
PutUserPermissionsBoundaryCallable(const PutUserPermissionsBoundaryRequest & request) const3008 PutUserPermissionsBoundaryOutcomeCallable IAMClient::PutUserPermissionsBoundaryCallable(const PutUserPermissionsBoundaryRequest& request) const
3009 {
3010 auto task = Aws::MakeShared< std::packaged_task< PutUserPermissionsBoundaryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutUserPermissionsBoundary(request); } );
3011 auto packagedFunction = [task]() { (*task)(); };
3012 m_executor->Submit(packagedFunction);
3013 return task->get_future();
3014 }
3015
PutUserPermissionsBoundaryAsync(const PutUserPermissionsBoundaryRequest & request,const PutUserPermissionsBoundaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3016 void IAMClient::PutUserPermissionsBoundaryAsync(const PutUserPermissionsBoundaryRequest& request, const PutUserPermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3017 {
3018 m_executor->Submit( [this, request, handler, context](){ this->PutUserPermissionsBoundaryAsyncHelper( request, handler, context ); } );
3019 }
3020
PutUserPermissionsBoundaryAsyncHelper(const PutUserPermissionsBoundaryRequest & request,const PutUserPermissionsBoundaryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3021 void IAMClient::PutUserPermissionsBoundaryAsyncHelper(const PutUserPermissionsBoundaryRequest& request, const PutUserPermissionsBoundaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3022 {
3023 handler(this, request, PutUserPermissionsBoundary(request), context);
3024 }
3025
PutUserPolicy(const PutUserPolicyRequest & request) const3026 PutUserPolicyOutcome IAMClient::PutUserPolicy(const PutUserPolicyRequest& request) const
3027 {
3028 Aws::Http::URI uri = m_uri;
3029 return PutUserPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3030 }
3031
PutUserPolicyCallable(const PutUserPolicyRequest & request) const3032 PutUserPolicyOutcomeCallable IAMClient::PutUserPolicyCallable(const PutUserPolicyRequest& request) const
3033 {
3034 auto task = Aws::MakeShared< std::packaged_task< PutUserPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutUserPolicy(request); } );
3035 auto packagedFunction = [task]() { (*task)(); };
3036 m_executor->Submit(packagedFunction);
3037 return task->get_future();
3038 }
3039
PutUserPolicyAsync(const PutUserPolicyRequest & request,const PutUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3040 void IAMClient::PutUserPolicyAsync(const PutUserPolicyRequest& request, const PutUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3041 {
3042 m_executor->Submit( [this, request, handler, context](){ this->PutUserPolicyAsyncHelper( request, handler, context ); } );
3043 }
3044
PutUserPolicyAsyncHelper(const PutUserPolicyRequest & request,const PutUserPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3045 void IAMClient::PutUserPolicyAsyncHelper(const PutUserPolicyRequest& request, const PutUserPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3046 {
3047 handler(this, request, PutUserPolicy(request), context);
3048 }
3049
RemoveClientIDFromOpenIDConnectProvider(const RemoveClientIDFromOpenIDConnectProviderRequest & request) const3050 RemoveClientIDFromOpenIDConnectProviderOutcome IAMClient::RemoveClientIDFromOpenIDConnectProvider(const RemoveClientIDFromOpenIDConnectProviderRequest& request) const
3051 {
3052 Aws::Http::URI uri = m_uri;
3053 return RemoveClientIDFromOpenIDConnectProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3054 }
3055
RemoveClientIDFromOpenIDConnectProviderCallable(const RemoveClientIDFromOpenIDConnectProviderRequest & request) const3056 RemoveClientIDFromOpenIDConnectProviderOutcomeCallable IAMClient::RemoveClientIDFromOpenIDConnectProviderCallable(const RemoveClientIDFromOpenIDConnectProviderRequest& request) const
3057 {
3058 auto task = Aws::MakeShared< std::packaged_task< RemoveClientIDFromOpenIDConnectProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RemoveClientIDFromOpenIDConnectProvider(request); } );
3059 auto packagedFunction = [task]() { (*task)(); };
3060 m_executor->Submit(packagedFunction);
3061 return task->get_future();
3062 }
3063
RemoveClientIDFromOpenIDConnectProviderAsync(const RemoveClientIDFromOpenIDConnectProviderRequest & request,const RemoveClientIDFromOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3064 void IAMClient::RemoveClientIDFromOpenIDConnectProviderAsync(const RemoveClientIDFromOpenIDConnectProviderRequest& request, const RemoveClientIDFromOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3065 {
3066 m_executor->Submit( [this, request, handler, context](){ this->RemoveClientIDFromOpenIDConnectProviderAsyncHelper( request, handler, context ); } );
3067 }
3068
RemoveClientIDFromOpenIDConnectProviderAsyncHelper(const RemoveClientIDFromOpenIDConnectProviderRequest & request,const RemoveClientIDFromOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3069 void IAMClient::RemoveClientIDFromOpenIDConnectProviderAsyncHelper(const RemoveClientIDFromOpenIDConnectProviderRequest& request, const RemoveClientIDFromOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3070 {
3071 handler(this, request, RemoveClientIDFromOpenIDConnectProvider(request), context);
3072 }
3073
RemoveRoleFromInstanceProfile(const RemoveRoleFromInstanceProfileRequest & request) const3074 RemoveRoleFromInstanceProfileOutcome IAMClient::RemoveRoleFromInstanceProfile(const RemoveRoleFromInstanceProfileRequest& request) const
3075 {
3076 Aws::Http::URI uri = m_uri;
3077 return RemoveRoleFromInstanceProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3078 }
3079
RemoveRoleFromInstanceProfileCallable(const RemoveRoleFromInstanceProfileRequest & request) const3080 RemoveRoleFromInstanceProfileOutcomeCallable IAMClient::RemoveRoleFromInstanceProfileCallable(const RemoveRoleFromInstanceProfileRequest& request) const
3081 {
3082 auto task = Aws::MakeShared< std::packaged_task< RemoveRoleFromInstanceProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RemoveRoleFromInstanceProfile(request); } );
3083 auto packagedFunction = [task]() { (*task)(); };
3084 m_executor->Submit(packagedFunction);
3085 return task->get_future();
3086 }
3087
RemoveRoleFromInstanceProfileAsync(const RemoveRoleFromInstanceProfileRequest & request,const RemoveRoleFromInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3088 void IAMClient::RemoveRoleFromInstanceProfileAsync(const RemoveRoleFromInstanceProfileRequest& request, const RemoveRoleFromInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3089 {
3090 m_executor->Submit( [this, request, handler, context](){ this->RemoveRoleFromInstanceProfileAsyncHelper( request, handler, context ); } );
3091 }
3092
RemoveRoleFromInstanceProfileAsyncHelper(const RemoveRoleFromInstanceProfileRequest & request,const RemoveRoleFromInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3093 void IAMClient::RemoveRoleFromInstanceProfileAsyncHelper(const RemoveRoleFromInstanceProfileRequest& request, const RemoveRoleFromInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3094 {
3095 handler(this, request, RemoveRoleFromInstanceProfile(request), context);
3096 }
3097
RemoveUserFromGroup(const RemoveUserFromGroupRequest & request) const3098 RemoveUserFromGroupOutcome IAMClient::RemoveUserFromGroup(const RemoveUserFromGroupRequest& request) const
3099 {
3100 Aws::Http::URI uri = m_uri;
3101 return RemoveUserFromGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3102 }
3103
RemoveUserFromGroupCallable(const RemoveUserFromGroupRequest & request) const3104 RemoveUserFromGroupOutcomeCallable IAMClient::RemoveUserFromGroupCallable(const RemoveUserFromGroupRequest& request) const
3105 {
3106 auto task = Aws::MakeShared< std::packaged_task< RemoveUserFromGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RemoveUserFromGroup(request); } );
3107 auto packagedFunction = [task]() { (*task)(); };
3108 m_executor->Submit(packagedFunction);
3109 return task->get_future();
3110 }
3111
RemoveUserFromGroupAsync(const RemoveUserFromGroupRequest & request,const RemoveUserFromGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3112 void IAMClient::RemoveUserFromGroupAsync(const RemoveUserFromGroupRequest& request, const RemoveUserFromGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3113 {
3114 m_executor->Submit( [this, request, handler, context](){ this->RemoveUserFromGroupAsyncHelper( request, handler, context ); } );
3115 }
3116
RemoveUserFromGroupAsyncHelper(const RemoveUserFromGroupRequest & request,const RemoveUserFromGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3117 void IAMClient::RemoveUserFromGroupAsyncHelper(const RemoveUserFromGroupRequest& request, const RemoveUserFromGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3118 {
3119 handler(this, request, RemoveUserFromGroup(request), context);
3120 }
3121
ResetServiceSpecificCredential(const ResetServiceSpecificCredentialRequest & request) const3122 ResetServiceSpecificCredentialOutcome IAMClient::ResetServiceSpecificCredential(const ResetServiceSpecificCredentialRequest& request) const
3123 {
3124 Aws::Http::URI uri = m_uri;
3125 return ResetServiceSpecificCredentialOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3126 }
3127
ResetServiceSpecificCredentialCallable(const ResetServiceSpecificCredentialRequest & request) const3128 ResetServiceSpecificCredentialOutcomeCallable IAMClient::ResetServiceSpecificCredentialCallable(const ResetServiceSpecificCredentialRequest& request) const
3129 {
3130 auto task = Aws::MakeShared< std::packaged_task< ResetServiceSpecificCredentialOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ResetServiceSpecificCredential(request); } );
3131 auto packagedFunction = [task]() { (*task)(); };
3132 m_executor->Submit(packagedFunction);
3133 return task->get_future();
3134 }
3135
ResetServiceSpecificCredentialAsync(const ResetServiceSpecificCredentialRequest & request,const ResetServiceSpecificCredentialResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3136 void IAMClient::ResetServiceSpecificCredentialAsync(const ResetServiceSpecificCredentialRequest& request, const ResetServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3137 {
3138 m_executor->Submit( [this, request, handler, context](){ this->ResetServiceSpecificCredentialAsyncHelper( request, handler, context ); } );
3139 }
3140
ResetServiceSpecificCredentialAsyncHelper(const ResetServiceSpecificCredentialRequest & request,const ResetServiceSpecificCredentialResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3141 void IAMClient::ResetServiceSpecificCredentialAsyncHelper(const ResetServiceSpecificCredentialRequest& request, const ResetServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3142 {
3143 handler(this, request, ResetServiceSpecificCredential(request), context);
3144 }
3145
ResyncMFADevice(const ResyncMFADeviceRequest & request) const3146 ResyncMFADeviceOutcome IAMClient::ResyncMFADevice(const ResyncMFADeviceRequest& request) const
3147 {
3148 Aws::Http::URI uri = m_uri;
3149 return ResyncMFADeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3150 }
3151
ResyncMFADeviceCallable(const ResyncMFADeviceRequest & request) const3152 ResyncMFADeviceOutcomeCallable IAMClient::ResyncMFADeviceCallable(const ResyncMFADeviceRequest& request) const
3153 {
3154 auto task = Aws::MakeShared< std::packaged_task< ResyncMFADeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ResyncMFADevice(request); } );
3155 auto packagedFunction = [task]() { (*task)(); };
3156 m_executor->Submit(packagedFunction);
3157 return task->get_future();
3158 }
3159
ResyncMFADeviceAsync(const ResyncMFADeviceRequest & request,const ResyncMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3160 void IAMClient::ResyncMFADeviceAsync(const ResyncMFADeviceRequest& request, const ResyncMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3161 {
3162 m_executor->Submit( [this, request, handler, context](){ this->ResyncMFADeviceAsyncHelper( request, handler, context ); } );
3163 }
3164
ResyncMFADeviceAsyncHelper(const ResyncMFADeviceRequest & request,const ResyncMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3165 void IAMClient::ResyncMFADeviceAsyncHelper(const ResyncMFADeviceRequest& request, const ResyncMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3166 {
3167 handler(this, request, ResyncMFADevice(request), context);
3168 }
3169
SetDefaultPolicyVersion(const SetDefaultPolicyVersionRequest & request) const3170 SetDefaultPolicyVersionOutcome IAMClient::SetDefaultPolicyVersion(const SetDefaultPolicyVersionRequest& request) const
3171 {
3172 Aws::Http::URI uri = m_uri;
3173 return SetDefaultPolicyVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3174 }
3175
SetDefaultPolicyVersionCallable(const SetDefaultPolicyVersionRequest & request) const3176 SetDefaultPolicyVersionOutcomeCallable IAMClient::SetDefaultPolicyVersionCallable(const SetDefaultPolicyVersionRequest& request) const
3177 {
3178 auto task = Aws::MakeShared< std::packaged_task< SetDefaultPolicyVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SetDefaultPolicyVersion(request); } );
3179 auto packagedFunction = [task]() { (*task)(); };
3180 m_executor->Submit(packagedFunction);
3181 return task->get_future();
3182 }
3183
SetDefaultPolicyVersionAsync(const SetDefaultPolicyVersionRequest & request,const SetDefaultPolicyVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3184 void IAMClient::SetDefaultPolicyVersionAsync(const SetDefaultPolicyVersionRequest& request, const SetDefaultPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3185 {
3186 m_executor->Submit( [this, request, handler, context](){ this->SetDefaultPolicyVersionAsyncHelper( request, handler, context ); } );
3187 }
3188
SetDefaultPolicyVersionAsyncHelper(const SetDefaultPolicyVersionRequest & request,const SetDefaultPolicyVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3189 void IAMClient::SetDefaultPolicyVersionAsyncHelper(const SetDefaultPolicyVersionRequest& request, const SetDefaultPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3190 {
3191 handler(this, request, SetDefaultPolicyVersion(request), context);
3192 }
3193
SetSecurityTokenServicePreferences(const SetSecurityTokenServicePreferencesRequest & request) const3194 SetSecurityTokenServicePreferencesOutcome IAMClient::SetSecurityTokenServicePreferences(const SetSecurityTokenServicePreferencesRequest& request) const
3195 {
3196 Aws::Http::URI uri = m_uri;
3197 return SetSecurityTokenServicePreferencesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3198 }
3199
SetSecurityTokenServicePreferencesCallable(const SetSecurityTokenServicePreferencesRequest & request) const3200 SetSecurityTokenServicePreferencesOutcomeCallable IAMClient::SetSecurityTokenServicePreferencesCallable(const SetSecurityTokenServicePreferencesRequest& request) const
3201 {
3202 auto task = Aws::MakeShared< std::packaged_task< SetSecurityTokenServicePreferencesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SetSecurityTokenServicePreferences(request); } );
3203 auto packagedFunction = [task]() { (*task)(); };
3204 m_executor->Submit(packagedFunction);
3205 return task->get_future();
3206 }
3207
SetSecurityTokenServicePreferencesAsync(const SetSecurityTokenServicePreferencesRequest & request,const SetSecurityTokenServicePreferencesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3208 void IAMClient::SetSecurityTokenServicePreferencesAsync(const SetSecurityTokenServicePreferencesRequest& request, const SetSecurityTokenServicePreferencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3209 {
3210 m_executor->Submit( [this, request, handler, context](){ this->SetSecurityTokenServicePreferencesAsyncHelper( request, handler, context ); } );
3211 }
3212
SetSecurityTokenServicePreferencesAsyncHelper(const SetSecurityTokenServicePreferencesRequest & request,const SetSecurityTokenServicePreferencesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3213 void IAMClient::SetSecurityTokenServicePreferencesAsyncHelper(const SetSecurityTokenServicePreferencesRequest& request, const SetSecurityTokenServicePreferencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3214 {
3215 handler(this, request, SetSecurityTokenServicePreferences(request), context);
3216 }
3217
SimulateCustomPolicy(const SimulateCustomPolicyRequest & request) const3218 SimulateCustomPolicyOutcome IAMClient::SimulateCustomPolicy(const SimulateCustomPolicyRequest& request) const
3219 {
3220 Aws::Http::URI uri = m_uri;
3221 return SimulateCustomPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3222 }
3223
SimulateCustomPolicyCallable(const SimulateCustomPolicyRequest & request) const3224 SimulateCustomPolicyOutcomeCallable IAMClient::SimulateCustomPolicyCallable(const SimulateCustomPolicyRequest& request) const
3225 {
3226 auto task = Aws::MakeShared< std::packaged_task< SimulateCustomPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SimulateCustomPolicy(request); } );
3227 auto packagedFunction = [task]() { (*task)(); };
3228 m_executor->Submit(packagedFunction);
3229 return task->get_future();
3230 }
3231
SimulateCustomPolicyAsync(const SimulateCustomPolicyRequest & request,const SimulateCustomPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3232 void IAMClient::SimulateCustomPolicyAsync(const SimulateCustomPolicyRequest& request, const SimulateCustomPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3233 {
3234 m_executor->Submit( [this, request, handler, context](){ this->SimulateCustomPolicyAsyncHelper( request, handler, context ); } );
3235 }
3236
SimulateCustomPolicyAsyncHelper(const SimulateCustomPolicyRequest & request,const SimulateCustomPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3237 void IAMClient::SimulateCustomPolicyAsyncHelper(const SimulateCustomPolicyRequest& request, const SimulateCustomPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3238 {
3239 handler(this, request, SimulateCustomPolicy(request), context);
3240 }
3241
SimulatePrincipalPolicy(const SimulatePrincipalPolicyRequest & request) const3242 SimulatePrincipalPolicyOutcome IAMClient::SimulatePrincipalPolicy(const SimulatePrincipalPolicyRequest& request) const
3243 {
3244 Aws::Http::URI uri = m_uri;
3245 return SimulatePrincipalPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3246 }
3247
SimulatePrincipalPolicyCallable(const SimulatePrincipalPolicyRequest & request) const3248 SimulatePrincipalPolicyOutcomeCallable IAMClient::SimulatePrincipalPolicyCallable(const SimulatePrincipalPolicyRequest& request) const
3249 {
3250 auto task = Aws::MakeShared< std::packaged_task< SimulatePrincipalPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SimulatePrincipalPolicy(request); } );
3251 auto packagedFunction = [task]() { (*task)(); };
3252 m_executor->Submit(packagedFunction);
3253 return task->get_future();
3254 }
3255
SimulatePrincipalPolicyAsync(const SimulatePrincipalPolicyRequest & request,const SimulatePrincipalPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3256 void IAMClient::SimulatePrincipalPolicyAsync(const SimulatePrincipalPolicyRequest& request, const SimulatePrincipalPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3257 {
3258 m_executor->Submit( [this, request, handler, context](){ this->SimulatePrincipalPolicyAsyncHelper( request, handler, context ); } );
3259 }
3260
SimulatePrincipalPolicyAsyncHelper(const SimulatePrincipalPolicyRequest & request,const SimulatePrincipalPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3261 void IAMClient::SimulatePrincipalPolicyAsyncHelper(const SimulatePrincipalPolicyRequest& request, const SimulatePrincipalPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3262 {
3263 handler(this, request, SimulatePrincipalPolicy(request), context);
3264 }
3265
TagInstanceProfile(const TagInstanceProfileRequest & request) const3266 TagInstanceProfileOutcome IAMClient::TagInstanceProfile(const TagInstanceProfileRequest& request) const
3267 {
3268 Aws::Http::URI uri = m_uri;
3269 return TagInstanceProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3270 }
3271
TagInstanceProfileCallable(const TagInstanceProfileRequest & request) const3272 TagInstanceProfileOutcomeCallable IAMClient::TagInstanceProfileCallable(const TagInstanceProfileRequest& request) const
3273 {
3274 auto task = Aws::MakeShared< std::packaged_task< TagInstanceProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagInstanceProfile(request); } );
3275 auto packagedFunction = [task]() { (*task)(); };
3276 m_executor->Submit(packagedFunction);
3277 return task->get_future();
3278 }
3279
TagInstanceProfileAsync(const TagInstanceProfileRequest & request,const TagInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3280 void IAMClient::TagInstanceProfileAsync(const TagInstanceProfileRequest& request, const TagInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3281 {
3282 m_executor->Submit( [this, request, handler, context](){ this->TagInstanceProfileAsyncHelper( request, handler, context ); } );
3283 }
3284
TagInstanceProfileAsyncHelper(const TagInstanceProfileRequest & request,const TagInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3285 void IAMClient::TagInstanceProfileAsyncHelper(const TagInstanceProfileRequest& request, const TagInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3286 {
3287 handler(this, request, TagInstanceProfile(request), context);
3288 }
3289
TagMFADevice(const TagMFADeviceRequest & request) const3290 TagMFADeviceOutcome IAMClient::TagMFADevice(const TagMFADeviceRequest& request) const
3291 {
3292 Aws::Http::URI uri = m_uri;
3293 return TagMFADeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3294 }
3295
TagMFADeviceCallable(const TagMFADeviceRequest & request) const3296 TagMFADeviceOutcomeCallable IAMClient::TagMFADeviceCallable(const TagMFADeviceRequest& request) const
3297 {
3298 auto task = Aws::MakeShared< std::packaged_task< TagMFADeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagMFADevice(request); } );
3299 auto packagedFunction = [task]() { (*task)(); };
3300 m_executor->Submit(packagedFunction);
3301 return task->get_future();
3302 }
3303
TagMFADeviceAsync(const TagMFADeviceRequest & request,const TagMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3304 void IAMClient::TagMFADeviceAsync(const TagMFADeviceRequest& request, const TagMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3305 {
3306 m_executor->Submit( [this, request, handler, context](){ this->TagMFADeviceAsyncHelper( request, handler, context ); } );
3307 }
3308
TagMFADeviceAsyncHelper(const TagMFADeviceRequest & request,const TagMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3309 void IAMClient::TagMFADeviceAsyncHelper(const TagMFADeviceRequest& request, const TagMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3310 {
3311 handler(this, request, TagMFADevice(request), context);
3312 }
3313
TagOpenIDConnectProvider(const TagOpenIDConnectProviderRequest & request) const3314 TagOpenIDConnectProviderOutcome IAMClient::TagOpenIDConnectProvider(const TagOpenIDConnectProviderRequest& request) const
3315 {
3316 Aws::Http::URI uri = m_uri;
3317 return TagOpenIDConnectProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3318 }
3319
TagOpenIDConnectProviderCallable(const TagOpenIDConnectProviderRequest & request) const3320 TagOpenIDConnectProviderOutcomeCallable IAMClient::TagOpenIDConnectProviderCallable(const TagOpenIDConnectProviderRequest& request) const
3321 {
3322 auto task = Aws::MakeShared< std::packaged_task< TagOpenIDConnectProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagOpenIDConnectProvider(request); } );
3323 auto packagedFunction = [task]() { (*task)(); };
3324 m_executor->Submit(packagedFunction);
3325 return task->get_future();
3326 }
3327
TagOpenIDConnectProviderAsync(const TagOpenIDConnectProviderRequest & request,const TagOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3328 void IAMClient::TagOpenIDConnectProviderAsync(const TagOpenIDConnectProviderRequest& request, const TagOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3329 {
3330 m_executor->Submit( [this, request, handler, context](){ this->TagOpenIDConnectProviderAsyncHelper( request, handler, context ); } );
3331 }
3332
TagOpenIDConnectProviderAsyncHelper(const TagOpenIDConnectProviderRequest & request,const TagOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3333 void IAMClient::TagOpenIDConnectProviderAsyncHelper(const TagOpenIDConnectProviderRequest& request, const TagOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3334 {
3335 handler(this, request, TagOpenIDConnectProvider(request), context);
3336 }
3337
TagPolicy(const TagPolicyRequest & request) const3338 TagPolicyOutcome IAMClient::TagPolicy(const TagPolicyRequest& request) const
3339 {
3340 Aws::Http::URI uri = m_uri;
3341 return TagPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3342 }
3343
TagPolicyCallable(const TagPolicyRequest & request) const3344 TagPolicyOutcomeCallable IAMClient::TagPolicyCallable(const TagPolicyRequest& request) const
3345 {
3346 auto task = Aws::MakeShared< std::packaged_task< TagPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagPolicy(request); } );
3347 auto packagedFunction = [task]() { (*task)(); };
3348 m_executor->Submit(packagedFunction);
3349 return task->get_future();
3350 }
3351
TagPolicyAsync(const TagPolicyRequest & request,const TagPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3352 void IAMClient::TagPolicyAsync(const TagPolicyRequest& request, const TagPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3353 {
3354 m_executor->Submit( [this, request, handler, context](){ this->TagPolicyAsyncHelper( request, handler, context ); } );
3355 }
3356
TagPolicyAsyncHelper(const TagPolicyRequest & request,const TagPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3357 void IAMClient::TagPolicyAsyncHelper(const TagPolicyRequest& request, const TagPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3358 {
3359 handler(this, request, TagPolicy(request), context);
3360 }
3361
TagRole(const TagRoleRequest & request) const3362 TagRoleOutcome IAMClient::TagRole(const TagRoleRequest& request) const
3363 {
3364 Aws::Http::URI uri = m_uri;
3365 return TagRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3366 }
3367
TagRoleCallable(const TagRoleRequest & request) const3368 TagRoleOutcomeCallable IAMClient::TagRoleCallable(const TagRoleRequest& request) const
3369 {
3370 auto task = Aws::MakeShared< std::packaged_task< TagRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagRole(request); } );
3371 auto packagedFunction = [task]() { (*task)(); };
3372 m_executor->Submit(packagedFunction);
3373 return task->get_future();
3374 }
3375
TagRoleAsync(const TagRoleRequest & request,const TagRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3376 void IAMClient::TagRoleAsync(const TagRoleRequest& request, const TagRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3377 {
3378 m_executor->Submit( [this, request, handler, context](){ this->TagRoleAsyncHelper( request, handler, context ); } );
3379 }
3380
TagRoleAsyncHelper(const TagRoleRequest & request,const TagRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3381 void IAMClient::TagRoleAsyncHelper(const TagRoleRequest& request, const TagRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3382 {
3383 handler(this, request, TagRole(request), context);
3384 }
3385
TagSAMLProvider(const TagSAMLProviderRequest & request) const3386 TagSAMLProviderOutcome IAMClient::TagSAMLProvider(const TagSAMLProviderRequest& request) const
3387 {
3388 Aws::Http::URI uri = m_uri;
3389 return TagSAMLProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3390 }
3391
TagSAMLProviderCallable(const TagSAMLProviderRequest & request) const3392 TagSAMLProviderOutcomeCallable IAMClient::TagSAMLProviderCallable(const TagSAMLProviderRequest& request) const
3393 {
3394 auto task = Aws::MakeShared< std::packaged_task< TagSAMLProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagSAMLProvider(request); } );
3395 auto packagedFunction = [task]() { (*task)(); };
3396 m_executor->Submit(packagedFunction);
3397 return task->get_future();
3398 }
3399
TagSAMLProviderAsync(const TagSAMLProviderRequest & request,const TagSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3400 void IAMClient::TagSAMLProviderAsync(const TagSAMLProviderRequest& request, const TagSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3401 {
3402 m_executor->Submit( [this, request, handler, context](){ this->TagSAMLProviderAsyncHelper( request, handler, context ); } );
3403 }
3404
TagSAMLProviderAsyncHelper(const TagSAMLProviderRequest & request,const TagSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3405 void IAMClient::TagSAMLProviderAsyncHelper(const TagSAMLProviderRequest& request, const TagSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3406 {
3407 handler(this, request, TagSAMLProvider(request), context);
3408 }
3409
TagServerCertificate(const TagServerCertificateRequest & request) const3410 TagServerCertificateOutcome IAMClient::TagServerCertificate(const TagServerCertificateRequest& request) const
3411 {
3412 Aws::Http::URI uri = m_uri;
3413 return TagServerCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3414 }
3415
TagServerCertificateCallable(const TagServerCertificateRequest & request) const3416 TagServerCertificateOutcomeCallable IAMClient::TagServerCertificateCallable(const TagServerCertificateRequest& request) const
3417 {
3418 auto task = Aws::MakeShared< std::packaged_task< TagServerCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagServerCertificate(request); } );
3419 auto packagedFunction = [task]() { (*task)(); };
3420 m_executor->Submit(packagedFunction);
3421 return task->get_future();
3422 }
3423
TagServerCertificateAsync(const TagServerCertificateRequest & request,const TagServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3424 void IAMClient::TagServerCertificateAsync(const TagServerCertificateRequest& request, const TagServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3425 {
3426 m_executor->Submit( [this, request, handler, context](){ this->TagServerCertificateAsyncHelper( request, handler, context ); } );
3427 }
3428
TagServerCertificateAsyncHelper(const TagServerCertificateRequest & request,const TagServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3429 void IAMClient::TagServerCertificateAsyncHelper(const TagServerCertificateRequest& request, const TagServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3430 {
3431 handler(this, request, TagServerCertificate(request), context);
3432 }
3433
TagUser(const TagUserRequest & request) const3434 TagUserOutcome IAMClient::TagUser(const TagUserRequest& request) const
3435 {
3436 Aws::Http::URI uri = m_uri;
3437 return TagUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3438 }
3439
TagUserCallable(const TagUserRequest & request) const3440 TagUserOutcomeCallable IAMClient::TagUserCallable(const TagUserRequest& request) const
3441 {
3442 auto task = Aws::MakeShared< std::packaged_task< TagUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagUser(request); } );
3443 auto packagedFunction = [task]() { (*task)(); };
3444 m_executor->Submit(packagedFunction);
3445 return task->get_future();
3446 }
3447
TagUserAsync(const TagUserRequest & request,const TagUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3448 void IAMClient::TagUserAsync(const TagUserRequest& request, const TagUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3449 {
3450 m_executor->Submit( [this, request, handler, context](){ this->TagUserAsyncHelper( request, handler, context ); } );
3451 }
3452
TagUserAsyncHelper(const TagUserRequest & request,const TagUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3453 void IAMClient::TagUserAsyncHelper(const TagUserRequest& request, const TagUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3454 {
3455 handler(this, request, TagUser(request), context);
3456 }
3457
UntagInstanceProfile(const UntagInstanceProfileRequest & request) const3458 UntagInstanceProfileOutcome IAMClient::UntagInstanceProfile(const UntagInstanceProfileRequest& request) const
3459 {
3460 Aws::Http::URI uri = m_uri;
3461 return UntagInstanceProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3462 }
3463
UntagInstanceProfileCallable(const UntagInstanceProfileRequest & request) const3464 UntagInstanceProfileOutcomeCallable IAMClient::UntagInstanceProfileCallable(const UntagInstanceProfileRequest& request) const
3465 {
3466 auto task = Aws::MakeShared< std::packaged_task< UntagInstanceProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagInstanceProfile(request); } );
3467 auto packagedFunction = [task]() { (*task)(); };
3468 m_executor->Submit(packagedFunction);
3469 return task->get_future();
3470 }
3471
UntagInstanceProfileAsync(const UntagInstanceProfileRequest & request,const UntagInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3472 void IAMClient::UntagInstanceProfileAsync(const UntagInstanceProfileRequest& request, const UntagInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3473 {
3474 m_executor->Submit( [this, request, handler, context](){ this->UntagInstanceProfileAsyncHelper( request, handler, context ); } );
3475 }
3476
UntagInstanceProfileAsyncHelper(const UntagInstanceProfileRequest & request,const UntagInstanceProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3477 void IAMClient::UntagInstanceProfileAsyncHelper(const UntagInstanceProfileRequest& request, const UntagInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3478 {
3479 handler(this, request, UntagInstanceProfile(request), context);
3480 }
3481
UntagMFADevice(const UntagMFADeviceRequest & request) const3482 UntagMFADeviceOutcome IAMClient::UntagMFADevice(const UntagMFADeviceRequest& request) const
3483 {
3484 Aws::Http::URI uri = m_uri;
3485 return UntagMFADeviceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3486 }
3487
UntagMFADeviceCallable(const UntagMFADeviceRequest & request) const3488 UntagMFADeviceOutcomeCallable IAMClient::UntagMFADeviceCallable(const UntagMFADeviceRequest& request) const
3489 {
3490 auto task = Aws::MakeShared< std::packaged_task< UntagMFADeviceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagMFADevice(request); } );
3491 auto packagedFunction = [task]() { (*task)(); };
3492 m_executor->Submit(packagedFunction);
3493 return task->get_future();
3494 }
3495
UntagMFADeviceAsync(const UntagMFADeviceRequest & request,const UntagMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3496 void IAMClient::UntagMFADeviceAsync(const UntagMFADeviceRequest& request, const UntagMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3497 {
3498 m_executor->Submit( [this, request, handler, context](){ this->UntagMFADeviceAsyncHelper( request, handler, context ); } );
3499 }
3500
UntagMFADeviceAsyncHelper(const UntagMFADeviceRequest & request,const UntagMFADeviceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3501 void IAMClient::UntagMFADeviceAsyncHelper(const UntagMFADeviceRequest& request, const UntagMFADeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3502 {
3503 handler(this, request, UntagMFADevice(request), context);
3504 }
3505
UntagOpenIDConnectProvider(const UntagOpenIDConnectProviderRequest & request) const3506 UntagOpenIDConnectProviderOutcome IAMClient::UntagOpenIDConnectProvider(const UntagOpenIDConnectProviderRequest& request) const
3507 {
3508 Aws::Http::URI uri = m_uri;
3509 return UntagOpenIDConnectProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3510 }
3511
UntagOpenIDConnectProviderCallable(const UntagOpenIDConnectProviderRequest & request) const3512 UntagOpenIDConnectProviderOutcomeCallable IAMClient::UntagOpenIDConnectProviderCallable(const UntagOpenIDConnectProviderRequest& request) const
3513 {
3514 auto task = Aws::MakeShared< std::packaged_task< UntagOpenIDConnectProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagOpenIDConnectProvider(request); } );
3515 auto packagedFunction = [task]() { (*task)(); };
3516 m_executor->Submit(packagedFunction);
3517 return task->get_future();
3518 }
3519
UntagOpenIDConnectProviderAsync(const UntagOpenIDConnectProviderRequest & request,const UntagOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3520 void IAMClient::UntagOpenIDConnectProviderAsync(const UntagOpenIDConnectProviderRequest& request, const UntagOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3521 {
3522 m_executor->Submit( [this, request, handler, context](){ this->UntagOpenIDConnectProviderAsyncHelper( request, handler, context ); } );
3523 }
3524
UntagOpenIDConnectProviderAsyncHelper(const UntagOpenIDConnectProviderRequest & request,const UntagOpenIDConnectProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3525 void IAMClient::UntagOpenIDConnectProviderAsyncHelper(const UntagOpenIDConnectProviderRequest& request, const UntagOpenIDConnectProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3526 {
3527 handler(this, request, UntagOpenIDConnectProvider(request), context);
3528 }
3529
UntagPolicy(const UntagPolicyRequest & request) const3530 UntagPolicyOutcome IAMClient::UntagPolicy(const UntagPolicyRequest& request) const
3531 {
3532 Aws::Http::URI uri = m_uri;
3533 return UntagPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3534 }
3535
UntagPolicyCallable(const UntagPolicyRequest & request) const3536 UntagPolicyOutcomeCallable IAMClient::UntagPolicyCallable(const UntagPolicyRequest& request) const
3537 {
3538 auto task = Aws::MakeShared< std::packaged_task< UntagPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagPolicy(request); } );
3539 auto packagedFunction = [task]() { (*task)(); };
3540 m_executor->Submit(packagedFunction);
3541 return task->get_future();
3542 }
3543
UntagPolicyAsync(const UntagPolicyRequest & request,const UntagPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3544 void IAMClient::UntagPolicyAsync(const UntagPolicyRequest& request, const UntagPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3545 {
3546 m_executor->Submit( [this, request, handler, context](){ this->UntagPolicyAsyncHelper( request, handler, context ); } );
3547 }
3548
UntagPolicyAsyncHelper(const UntagPolicyRequest & request,const UntagPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3549 void IAMClient::UntagPolicyAsyncHelper(const UntagPolicyRequest& request, const UntagPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3550 {
3551 handler(this, request, UntagPolicy(request), context);
3552 }
3553
UntagRole(const UntagRoleRequest & request) const3554 UntagRoleOutcome IAMClient::UntagRole(const UntagRoleRequest& request) const
3555 {
3556 Aws::Http::URI uri = m_uri;
3557 return UntagRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3558 }
3559
UntagRoleCallable(const UntagRoleRequest & request) const3560 UntagRoleOutcomeCallable IAMClient::UntagRoleCallable(const UntagRoleRequest& request) const
3561 {
3562 auto task = Aws::MakeShared< std::packaged_task< UntagRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagRole(request); } );
3563 auto packagedFunction = [task]() { (*task)(); };
3564 m_executor->Submit(packagedFunction);
3565 return task->get_future();
3566 }
3567
UntagRoleAsync(const UntagRoleRequest & request,const UntagRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3568 void IAMClient::UntagRoleAsync(const UntagRoleRequest& request, const UntagRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3569 {
3570 m_executor->Submit( [this, request, handler, context](){ this->UntagRoleAsyncHelper( request, handler, context ); } );
3571 }
3572
UntagRoleAsyncHelper(const UntagRoleRequest & request,const UntagRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3573 void IAMClient::UntagRoleAsyncHelper(const UntagRoleRequest& request, const UntagRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3574 {
3575 handler(this, request, UntagRole(request), context);
3576 }
3577
UntagSAMLProvider(const UntagSAMLProviderRequest & request) const3578 UntagSAMLProviderOutcome IAMClient::UntagSAMLProvider(const UntagSAMLProviderRequest& request) const
3579 {
3580 Aws::Http::URI uri = m_uri;
3581 return UntagSAMLProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3582 }
3583
UntagSAMLProviderCallable(const UntagSAMLProviderRequest & request) const3584 UntagSAMLProviderOutcomeCallable IAMClient::UntagSAMLProviderCallable(const UntagSAMLProviderRequest& request) const
3585 {
3586 auto task = Aws::MakeShared< std::packaged_task< UntagSAMLProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagSAMLProvider(request); } );
3587 auto packagedFunction = [task]() { (*task)(); };
3588 m_executor->Submit(packagedFunction);
3589 return task->get_future();
3590 }
3591
UntagSAMLProviderAsync(const UntagSAMLProviderRequest & request,const UntagSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3592 void IAMClient::UntagSAMLProviderAsync(const UntagSAMLProviderRequest& request, const UntagSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3593 {
3594 m_executor->Submit( [this, request, handler, context](){ this->UntagSAMLProviderAsyncHelper( request, handler, context ); } );
3595 }
3596
UntagSAMLProviderAsyncHelper(const UntagSAMLProviderRequest & request,const UntagSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3597 void IAMClient::UntagSAMLProviderAsyncHelper(const UntagSAMLProviderRequest& request, const UntagSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3598 {
3599 handler(this, request, UntagSAMLProvider(request), context);
3600 }
3601
UntagServerCertificate(const UntagServerCertificateRequest & request) const3602 UntagServerCertificateOutcome IAMClient::UntagServerCertificate(const UntagServerCertificateRequest& request) const
3603 {
3604 Aws::Http::URI uri = m_uri;
3605 return UntagServerCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3606 }
3607
UntagServerCertificateCallable(const UntagServerCertificateRequest & request) const3608 UntagServerCertificateOutcomeCallable IAMClient::UntagServerCertificateCallable(const UntagServerCertificateRequest& request) const
3609 {
3610 auto task = Aws::MakeShared< std::packaged_task< UntagServerCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagServerCertificate(request); } );
3611 auto packagedFunction = [task]() { (*task)(); };
3612 m_executor->Submit(packagedFunction);
3613 return task->get_future();
3614 }
3615
UntagServerCertificateAsync(const UntagServerCertificateRequest & request,const UntagServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3616 void IAMClient::UntagServerCertificateAsync(const UntagServerCertificateRequest& request, const UntagServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3617 {
3618 m_executor->Submit( [this, request, handler, context](){ this->UntagServerCertificateAsyncHelper( request, handler, context ); } );
3619 }
3620
UntagServerCertificateAsyncHelper(const UntagServerCertificateRequest & request,const UntagServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3621 void IAMClient::UntagServerCertificateAsyncHelper(const UntagServerCertificateRequest& request, const UntagServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3622 {
3623 handler(this, request, UntagServerCertificate(request), context);
3624 }
3625
UntagUser(const UntagUserRequest & request) const3626 UntagUserOutcome IAMClient::UntagUser(const UntagUserRequest& request) const
3627 {
3628 Aws::Http::URI uri = m_uri;
3629 return UntagUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3630 }
3631
UntagUserCallable(const UntagUserRequest & request) const3632 UntagUserOutcomeCallable IAMClient::UntagUserCallable(const UntagUserRequest& request) const
3633 {
3634 auto task = Aws::MakeShared< std::packaged_task< UntagUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagUser(request); } );
3635 auto packagedFunction = [task]() { (*task)(); };
3636 m_executor->Submit(packagedFunction);
3637 return task->get_future();
3638 }
3639
UntagUserAsync(const UntagUserRequest & request,const UntagUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3640 void IAMClient::UntagUserAsync(const UntagUserRequest& request, const UntagUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3641 {
3642 m_executor->Submit( [this, request, handler, context](){ this->UntagUserAsyncHelper( request, handler, context ); } );
3643 }
3644
UntagUserAsyncHelper(const UntagUserRequest & request,const UntagUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3645 void IAMClient::UntagUserAsyncHelper(const UntagUserRequest& request, const UntagUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3646 {
3647 handler(this, request, UntagUser(request), context);
3648 }
3649
UpdateAccessKey(const UpdateAccessKeyRequest & request) const3650 UpdateAccessKeyOutcome IAMClient::UpdateAccessKey(const UpdateAccessKeyRequest& request) const
3651 {
3652 Aws::Http::URI uri = m_uri;
3653 return UpdateAccessKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3654 }
3655
UpdateAccessKeyCallable(const UpdateAccessKeyRequest & request) const3656 UpdateAccessKeyOutcomeCallable IAMClient::UpdateAccessKeyCallable(const UpdateAccessKeyRequest& request) const
3657 {
3658 auto task = Aws::MakeShared< std::packaged_task< UpdateAccessKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAccessKey(request); } );
3659 auto packagedFunction = [task]() { (*task)(); };
3660 m_executor->Submit(packagedFunction);
3661 return task->get_future();
3662 }
3663
UpdateAccessKeyAsync(const UpdateAccessKeyRequest & request,const UpdateAccessKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3664 void IAMClient::UpdateAccessKeyAsync(const UpdateAccessKeyRequest& request, const UpdateAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3665 {
3666 m_executor->Submit( [this, request, handler, context](){ this->UpdateAccessKeyAsyncHelper( request, handler, context ); } );
3667 }
3668
UpdateAccessKeyAsyncHelper(const UpdateAccessKeyRequest & request,const UpdateAccessKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3669 void IAMClient::UpdateAccessKeyAsyncHelper(const UpdateAccessKeyRequest& request, const UpdateAccessKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3670 {
3671 handler(this, request, UpdateAccessKey(request), context);
3672 }
3673
UpdateAccountPasswordPolicy(const UpdateAccountPasswordPolicyRequest & request) const3674 UpdateAccountPasswordPolicyOutcome IAMClient::UpdateAccountPasswordPolicy(const UpdateAccountPasswordPolicyRequest& request) const
3675 {
3676 Aws::Http::URI uri = m_uri;
3677 return UpdateAccountPasswordPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3678 }
3679
UpdateAccountPasswordPolicyCallable(const UpdateAccountPasswordPolicyRequest & request) const3680 UpdateAccountPasswordPolicyOutcomeCallable IAMClient::UpdateAccountPasswordPolicyCallable(const UpdateAccountPasswordPolicyRequest& request) const
3681 {
3682 auto task = Aws::MakeShared< std::packaged_task< UpdateAccountPasswordPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAccountPasswordPolicy(request); } );
3683 auto packagedFunction = [task]() { (*task)(); };
3684 m_executor->Submit(packagedFunction);
3685 return task->get_future();
3686 }
3687
UpdateAccountPasswordPolicyAsync(const UpdateAccountPasswordPolicyRequest & request,const UpdateAccountPasswordPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3688 void IAMClient::UpdateAccountPasswordPolicyAsync(const UpdateAccountPasswordPolicyRequest& request, const UpdateAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3689 {
3690 m_executor->Submit( [this, request, handler, context](){ this->UpdateAccountPasswordPolicyAsyncHelper( request, handler, context ); } );
3691 }
3692
UpdateAccountPasswordPolicyAsyncHelper(const UpdateAccountPasswordPolicyRequest & request,const UpdateAccountPasswordPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3693 void IAMClient::UpdateAccountPasswordPolicyAsyncHelper(const UpdateAccountPasswordPolicyRequest& request, const UpdateAccountPasswordPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3694 {
3695 handler(this, request, UpdateAccountPasswordPolicy(request), context);
3696 }
3697
UpdateAssumeRolePolicy(const UpdateAssumeRolePolicyRequest & request) const3698 UpdateAssumeRolePolicyOutcome IAMClient::UpdateAssumeRolePolicy(const UpdateAssumeRolePolicyRequest& request) const
3699 {
3700 Aws::Http::URI uri = m_uri;
3701 return UpdateAssumeRolePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3702 }
3703
UpdateAssumeRolePolicyCallable(const UpdateAssumeRolePolicyRequest & request) const3704 UpdateAssumeRolePolicyOutcomeCallable IAMClient::UpdateAssumeRolePolicyCallable(const UpdateAssumeRolePolicyRequest& request) const
3705 {
3706 auto task = Aws::MakeShared< std::packaged_task< UpdateAssumeRolePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAssumeRolePolicy(request); } );
3707 auto packagedFunction = [task]() { (*task)(); };
3708 m_executor->Submit(packagedFunction);
3709 return task->get_future();
3710 }
3711
UpdateAssumeRolePolicyAsync(const UpdateAssumeRolePolicyRequest & request,const UpdateAssumeRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3712 void IAMClient::UpdateAssumeRolePolicyAsync(const UpdateAssumeRolePolicyRequest& request, const UpdateAssumeRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3713 {
3714 m_executor->Submit( [this, request, handler, context](){ this->UpdateAssumeRolePolicyAsyncHelper( request, handler, context ); } );
3715 }
3716
UpdateAssumeRolePolicyAsyncHelper(const UpdateAssumeRolePolicyRequest & request,const UpdateAssumeRolePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3717 void IAMClient::UpdateAssumeRolePolicyAsyncHelper(const UpdateAssumeRolePolicyRequest& request, const UpdateAssumeRolePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3718 {
3719 handler(this, request, UpdateAssumeRolePolicy(request), context);
3720 }
3721
UpdateGroup(const UpdateGroupRequest & request) const3722 UpdateGroupOutcome IAMClient::UpdateGroup(const UpdateGroupRequest& request) const
3723 {
3724 Aws::Http::URI uri = m_uri;
3725 return UpdateGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3726 }
3727
UpdateGroupCallable(const UpdateGroupRequest & request) const3728 UpdateGroupOutcomeCallable IAMClient::UpdateGroupCallable(const UpdateGroupRequest& request) const
3729 {
3730 auto task = Aws::MakeShared< std::packaged_task< UpdateGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateGroup(request); } );
3731 auto packagedFunction = [task]() { (*task)(); };
3732 m_executor->Submit(packagedFunction);
3733 return task->get_future();
3734 }
3735
UpdateGroupAsync(const UpdateGroupRequest & request,const UpdateGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3736 void IAMClient::UpdateGroupAsync(const UpdateGroupRequest& request, const UpdateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3737 {
3738 m_executor->Submit( [this, request, handler, context](){ this->UpdateGroupAsyncHelper( request, handler, context ); } );
3739 }
3740
UpdateGroupAsyncHelper(const UpdateGroupRequest & request,const UpdateGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3741 void IAMClient::UpdateGroupAsyncHelper(const UpdateGroupRequest& request, const UpdateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3742 {
3743 handler(this, request, UpdateGroup(request), context);
3744 }
3745
UpdateLoginProfile(const UpdateLoginProfileRequest & request) const3746 UpdateLoginProfileOutcome IAMClient::UpdateLoginProfile(const UpdateLoginProfileRequest& request) const
3747 {
3748 Aws::Http::URI uri = m_uri;
3749 return UpdateLoginProfileOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3750 }
3751
UpdateLoginProfileCallable(const UpdateLoginProfileRequest & request) const3752 UpdateLoginProfileOutcomeCallable IAMClient::UpdateLoginProfileCallable(const UpdateLoginProfileRequest& request) const
3753 {
3754 auto task = Aws::MakeShared< std::packaged_task< UpdateLoginProfileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateLoginProfile(request); } );
3755 auto packagedFunction = [task]() { (*task)(); };
3756 m_executor->Submit(packagedFunction);
3757 return task->get_future();
3758 }
3759
UpdateLoginProfileAsync(const UpdateLoginProfileRequest & request,const UpdateLoginProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3760 void IAMClient::UpdateLoginProfileAsync(const UpdateLoginProfileRequest& request, const UpdateLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3761 {
3762 m_executor->Submit( [this, request, handler, context](){ this->UpdateLoginProfileAsyncHelper( request, handler, context ); } );
3763 }
3764
UpdateLoginProfileAsyncHelper(const UpdateLoginProfileRequest & request,const UpdateLoginProfileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3765 void IAMClient::UpdateLoginProfileAsyncHelper(const UpdateLoginProfileRequest& request, const UpdateLoginProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3766 {
3767 handler(this, request, UpdateLoginProfile(request), context);
3768 }
3769
UpdateOpenIDConnectProviderThumbprint(const UpdateOpenIDConnectProviderThumbprintRequest & request) const3770 UpdateOpenIDConnectProviderThumbprintOutcome IAMClient::UpdateOpenIDConnectProviderThumbprint(const UpdateOpenIDConnectProviderThumbprintRequest& request) const
3771 {
3772 Aws::Http::URI uri = m_uri;
3773 return UpdateOpenIDConnectProviderThumbprintOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3774 }
3775
UpdateOpenIDConnectProviderThumbprintCallable(const UpdateOpenIDConnectProviderThumbprintRequest & request) const3776 UpdateOpenIDConnectProviderThumbprintOutcomeCallable IAMClient::UpdateOpenIDConnectProviderThumbprintCallable(const UpdateOpenIDConnectProviderThumbprintRequest& request) const
3777 {
3778 auto task = Aws::MakeShared< std::packaged_task< UpdateOpenIDConnectProviderThumbprintOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateOpenIDConnectProviderThumbprint(request); } );
3779 auto packagedFunction = [task]() { (*task)(); };
3780 m_executor->Submit(packagedFunction);
3781 return task->get_future();
3782 }
3783
UpdateOpenIDConnectProviderThumbprintAsync(const UpdateOpenIDConnectProviderThumbprintRequest & request,const UpdateOpenIDConnectProviderThumbprintResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3784 void IAMClient::UpdateOpenIDConnectProviderThumbprintAsync(const UpdateOpenIDConnectProviderThumbprintRequest& request, const UpdateOpenIDConnectProviderThumbprintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3785 {
3786 m_executor->Submit( [this, request, handler, context](){ this->UpdateOpenIDConnectProviderThumbprintAsyncHelper( request, handler, context ); } );
3787 }
3788
UpdateOpenIDConnectProviderThumbprintAsyncHelper(const UpdateOpenIDConnectProviderThumbprintRequest & request,const UpdateOpenIDConnectProviderThumbprintResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3789 void IAMClient::UpdateOpenIDConnectProviderThumbprintAsyncHelper(const UpdateOpenIDConnectProviderThumbprintRequest& request, const UpdateOpenIDConnectProviderThumbprintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3790 {
3791 handler(this, request, UpdateOpenIDConnectProviderThumbprint(request), context);
3792 }
3793
UpdateRole(const UpdateRoleRequest & request) const3794 UpdateRoleOutcome IAMClient::UpdateRole(const UpdateRoleRequest& request) const
3795 {
3796 Aws::Http::URI uri = m_uri;
3797 return UpdateRoleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3798 }
3799
UpdateRoleCallable(const UpdateRoleRequest & request) const3800 UpdateRoleOutcomeCallable IAMClient::UpdateRoleCallable(const UpdateRoleRequest& request) const
3801 {
3802 auto task = Aws::MakeShared< std::packaged_task< UpdateRoleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRole(request); } );
3803 auto packagedFunction = [task]() { (*task)(); };
3804 m_executor->Submit(packagedFunction);
3805 return task->get_future();
3806 }
3807
UpdateRoleAsync(const UpdateRoleRequest & request,const UpdateRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3808 void IAMClient::UpdateRoleAsync(const UpdateRoleRequest& request, const UpdateRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3809 {
3810 m_executor->Submit( [this, request, handler, context](){ this->UpdateRoleAsyncHelper( request, handler, context ); } );
3811 }
3812
UpdateRoleAsyncHelper(const UpdateRoleRequest & request,const UpdateRoleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3813 void IAMClient::UpdateRoleAsyncHelper(const UpdateRoleRequest& request, const UpdateRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3814 {
3815 handler(this, request, UpdateRole(request), context);
3816 }
3817
UpdateRoleDescription(const UpdateRoleDescriptionRequest & request) const3818 UpdateRoleDescriptionOutcome IAMClient::UpdateRoleDescription(const UpdateRoleDescriptionRequest& request) const
3819 {
3820 Aws::Http::URI uri = m_uri;
3821 return UpdateRoleDescriptionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3822 }
3823
UpdateRoleDescriptionCallable(const UpdateRoleDescriptionRequest & request) const3824 UpdateRoleDescriptionOutcomeCallable IAMClient::UpdateRoleDescriptionCallable(const UpdateRoleDescriptionRequest& request) const
3825 {
3826 auto task = Aws::MakeShared< std::packaged_task< UpdateRoleDescriptionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRoleDescription(request); } );
3827 auto packagedFunction = [task]() { (*task)(); };
3828 m_executor->Submit(packagedFunction);
3829 return task->get_future();
3830 }
3831
UpdateRoleDescriptionAsync(const UpdateRoleDescriptionRequest & request,const UpdateRoleDescriptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3832 void IAMClient::UpdateRoleDescriptionAsync(const UpdateRoleDescriptionRequest& request, const UpdateRoleDescriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3833 {
3834 m_executor->Submit( [this, request, handler, context](){ this->UpdateRoleDescriptionAsyncHelper( request, handler, context ); } );
3835 }
3836
UpdateRoleDescriptionAsyncHelper(const UpdateRoleDescriptionRequest & request,const UpdateRoleDescriptionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3837 void IAMClient::UpdateRoleDescriptionAsyncHelper(const UpdateRoleDescriptionRequest& request, const UpdateRoleDescriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3838 {
3839 handler(this, request, UpdateRoleDescription(request), context);
3840 }
3841
UpdateSAMLProvider(const UpdateSAMLProviderRequest & request) const3842 UpdateSAMLProviderOutcome IAMClient::UpdateSAMLProvider(const UpdateSAMLProviderRequest& request) const
3843 {
3844 Aws::Http::URI uri = m_uri;
3845 return UpdateSAMLProviderOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3846 }
3847
UpdateSAMLProviderCallable(const UpdateSAMLProviderRequest & request) const3848 UpdateSAMLProviderOutcomeCallable IAMClient::UpdateSAMLProviderCallable(const UpdateSAMLProviderRequest& request) const
3849 {
3850 auto task = Aws::MakeShared< std::packaged_task< UpdateSAMLProviderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateSAMLProvider(request); } );
3851 auto packagedFunction = [task]() { (*task)(); };
3852 m_executor->Submit(packagedFunction);
3853 return task->get_future();
3854 }
3855
UpdateSAMLProviderAsync(const UpdateSAMLProviderRequest & request,const UpdateSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3856 void IAMClient::UpdateSAMLProviderAsync(const UpdateSAMLProviderRequest& request, const UpdateSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3857 {
3858 m_executor->Submit( [this, request, handler, context](){ this->UpdateSAMLProviderAsyncHelper( request, handler, context ); } );
3859 }
3860
UpdateSAMLProviderAsyncHelper(const UpdateSAMLProviderRequest & request,const UpdateSAMLProviderResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3861 void IAMClient::UpdateSAMLProviderAsyncHelper(const UpdateSAMLProviderRequest& request, const UpdateSAMLProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3862 {
3863 handler(this, request, UpdateSAMLProvider(request), context);
3864 }
3865
UpdateSSHPublicKey(const UpdateSSHPublicKeyRequest & request) const3866 UpdateSSHPublicKeyOutcome IAMClient::UpdateSSHPublicKey(const UpdateSSHPublicKeyRequest& request) const
3867 {
3868 Aws::Http::URI uri = m_uri;
3869 return UpdateSSHPublicKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3870 }
3871
UpdateSSHPublicKeyCallable(const UpdateSSHPublicKeyRequest & request) const3872 UpdateSSHPublicKeyOutcomeCallable IAMClient::UpdateSSHPublicKeyCallable(const UpdateSSHPublicKeyRequest& request) const
3873 {
3874 auto task = Aws::MakeShared< std::packaged_task< UpdateSSHPublicKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateSSHPublicKey(request); } );
3875 auto packagedFunction = [task]() { (*task)(); };
3876 m_executor->Submit(packagedFunction);
3877 return task->get_future();
3878 }
3879
UpdateSSHPublicKeyAsync(const UpdateSSHPublicKeyRequest & request,const UpdateSSHPublicKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3880 void IAMClient::UpdateSSHPublicKeyAsync(const UpdateSSHPublicKeyRequest& request, const UpdateSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3881 {
3882 m_executor->Submit( [this, request, handler, context](){ this->UpdateSSHPublicKeyAsyncHelper( request, handler, context ); } );
3883 }
3884
UpdateSSHPublicKeyAsyncHelper(const UpdateSSHPublicKeyRequest & request,const UpdateSSHPublicKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3885 void IAMClient::UpdateSSHPublicKeyAsyncHelper(const UpdateSSHPublicKeyRequest& request, const UpdateSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3886 {
3887 handler(this, request, UpdateSSHPublicKey(request), context);
3888 }
3889
UpdateServerCertificate(const UpdateServerCertificateRequest & request) const3890 UpdateServerCertificateOutcome IAMClient::UpdateServerCertificate(const UpdateServerCertificateRequest& request) const
3891 {
3892 Aws::Http::URI uri = m_uri;
3893 return UpdateServerCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3894 }
3895
UpdateServerCertificateCallable(const UpdateServerCertificateRequest & request) const3896 UpdateServerCertificateOutcomeCallable IAMClient::UpdateServerCertificateCallable(const UpdateServerCertificateRequest& request) const
3897 {
3898 auto task = Aws::MakeShared< std::packaged_task< UpdateServerCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateServerCertificate(request); } );
3899 auto packagedFunction = [task]() { (*task)(); };
3900 m_executor->Submit(packagedFunction);
3901 return task->get_future();
3902 }
3903
UpdateServerCertificateAsync(const UpdateServerCertificateRequest & request,const UpdateServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3904 void IAMClient::UpdateServerCertificateAsync(const UpdateServerCertificateRequest& request, const UpdateServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3905 {
3906 m_executor->Submit( [this, request, handler, context](){ this->UpdateServerCertificateAsyncHelper( request, handler, context ); } );
3907 }
3908
UpdateServerCertificateAsyncHelper(const UpdateServerCertificateRequest & request,const UpdateServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3909 void IAMClient::UpdateServerCertificateAsyncHelper(const UpdateServerCertificateRequest& request, const UpdateServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3910 {
3911 handler(this, request, UpdateServerCertificate(request), context);
3912 }
3913
UpdateServiceSpecificCredential(const UpdateServiceSpecificCredentialRequest & request) const3914 UpdateServiceSpecificCredentialOutcome IAMClient::UpdateServiceSpecificCredential(const UpdateServiceSpecificCredentialRequest& request) const
3915 {
3916 Aws::Http::URI uri = m_uri;
3917 return UpdateServiceSpecificCredentialOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3918 }
3919
UpdateServiceSpecificCredentialCallable(const UpdateServiceSpecificCredentialRequest & request) const3920 UpdateServiceSpecificCredentialOutcomeCallable IAMClient::UpdateServiceSpecificCredentialCallable(const UpdateServiceSpecificCredentialRequest& request) const
3921 {
3922 auto task = Aws::MakeShared< std::packaged_task< UpdateServiceSpecificCredentialOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateServiceSpecificCredential(request); } );
3923 auto packagedFunction = [task]() { (*task)(); };
3924 m_executor->Submit(packagedFunction);
3925 return task->get_future();
3926 }
3927
UpdateServiceSpecificCredentialAsync(const UpdateServiceSpecificCredentialRequest & request,const UpdateServiceSpecificCredentialResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3928 void IAMClient::UpdateServiceSpecificCredentialAsync(const UpdateServiceSpecificCredentialRequest& request, const UpdateServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3929 {
3930 m_executor->Submit( [this, request, handler, context](){ this->UpdateServiceSpecificCredentialAsyncHelper( request, handler, context ); } );
3931 }
3932
UpdateServiceSpecificCredentialAsyncHelper(const UpdateServiceSpecificCredentialRequest & request,const UpdateServiceSpecificCredentialResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3933 void IAMClient::UpdateServiceSpecificCredentialAsyncHelper(const UpdateServiceSpecificCredentialRequest& request, const UpdateServiceSpecificCredentialResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3934 {
3935 handler(this, request, UpdateServiceSpecificCredential(request), context);
3936 }
3937
UpdateSigningCertificate(const UpdateSigningCertificateRequest & request) const3938 UpdateSigningCertificateOutcome IAMClient::UpdateSigningCertificate(const UpdateSigningCertificateRequest& request) const
3939 {
3940 Aws::Http::URI uri = m_uri;
3941 return UpdateSigningCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3942 }
3943
UpdateSigningCertificateCallable(const UpdateSigningCertificateRequest & request) const3944 UpdateSigningCertificateOutcomeCallable IAMClient::UpdateSigningCertificateCallable(const UpdateSigningCertificateRequest& request) const
3945 {
3946 auto task = Aws::MakeShared< std::packaged_task< UpdateSigningCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateSigningCertificate(request); } );
3947 auto packagedFunction = [task]() { (*task)(); };
3948 m_executor->Submit(packagedFunction);
3949 return task->get_future();
3950 }
3951
UpdateSigningCertificateAsync(const UpdateSigningCertificateRequest & request,const UpdateSigningCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3952 void IAMClient::UpdateSigningCertificateAsync(const UpdateSigningCertificateRequest& request, const UpdateSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3953 {
3954 m_executor->Submit( [this, request, handler, context](){ this->UpdateSigningCertificateAsyncHelper( request, handler, context ); } );
3955 }
3956
UpdateSigningCertificateAsyncHelper(const UpdateSigningCertificateRequest & request,const UpdateSigningCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3957 void IAMClient::UpdateSigningCertificateAsyncHelper(const UpdateSigningCertificateRequest& request, const UpdateSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3958 {
3959 handler(this, request, UpdateSigningCertificate(request), context);
3960 }
3961
UpdateUser(const UpdateUserRequest & request) const3962 UpdateUserOutcome IAMClient::UpdateUser(const UpdateUserRequest& request) const
3963 {
3964 Aws::Http::URI uri = m_uri;
3965 return UpdateUserOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3966 }
3967
UpdateUserCallable(const UpdateUserRequest & request) const3968 UpdateUserOutcomeCallable IAMClient::UpdateUserCallable(const UpdateUserRequest& request) const
3969 {
3970 auto task = Aws::MakeShared< std::packaged_task< UpdateUserOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateUser(request); } );
3971 auto packagedFunction = [task]() { (*task)(); };
3972 m_executor->Submit(packagedFunction);
3973 return task->get_future();
3974 }
3975
UpdateUserAsync(const UpdateUserRequest & request,const UpdateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3976 void IAMClient::UpdateUserAsync(const UpdateUserRequest& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3977 {
3978 m_executor->Submit( [this, request, handler, context](){ this->UpdateUserAsyncHelper( request, handler, context ); } );
3979 }
3980
UpdateUserAsyncHelper(const UpdateUserRequest & request,const UpdateUserResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const3981 void IAMClient::UpdateUserAsyncHelper(const UpdateUserRequest& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
3982 {
3983 handler(this, request, UpdateUser(request), context);
3984 }
3985
UploadSSHPublicKey(const UploadSSHPublicKeyRequest & request) const3986 UploadSSHPublicKeyOutcome IAMClient::UploadSSHPublicKey(const UploadSSHPublicKeyRequest& request) const
3987 {
3988 Aws::Http::URI uri = m_uri;
3989 return UploadSSHPublicKeyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
3990 }
3991
UploadSSHPublicKeyCallable(const UploadSSHPublicKeyRequest & request) const3992 UploadSSHPublicKeyOutcomeCallable IAMClient::UploadSSHPublicKeyCallable(const UploadSSHPublicKeyRequest& request) const
3993 {
3994 auto task = Aws::MakeShared< std::packaged_task< UploadSSHPublicKeyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UploadSSHPublicKey(request); } );
3995 auto packagedFunction = [task]() { (*task)(); };
3996 m_executor->Submit(packagedFunction);
3997 return task->get_future();
3998 }
3999
UploadSSHPublicKeyAsync(const UploadSSHPublicKeyRequest & request,const UploadSSHPublicKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4000 void IAMClient::UploadSSHPublicKeyAsync(const UploadSSHPublicKeyRequest& request, const UploadSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4001 {
4002 m_executor->Submit( [this, request, handler, context](){ this->UploadSSHPublicKeyAsyncHelper( request, handler, context ); } );
4003 }
4004
UploadSSHPublicKeyAsyncHelper(const UploadSSHPublicKeyRequest & request,const UploadSSHPublicKeyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4005 void IAMClient::UploadSSHPublicKeyAsyncHelper(const UploadSSHPublicKeyRequest& request, const UploadSSHPublicKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4006 {
4007 handler(this, request, UploadSSHPublicKey(request), context);
4008 }
4009
UploadServerCertificate(const UploadServerCertificateRequest & request) const4010 UploadServerCertificateOutcome IAMClient::UploadServerCertificate(const UploadServerCertificateRequest& request) const
4011 {
4012 Aws::Http::URI uri = m_uri;
4013 return UploadServerCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
4014 }
4015
UploadServerCertificateCallable(const UploadServerCertificateRequest & request) const4016 UploadServerCertificateOutcomeCallable IAMClient::UploadServerCertificateCallable(const UploadServerCertificateRequest& request) const
4017 {
4018 auto task = Aws::MakeShared< std::packaged_task< UploadServerCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UploadServerCertificate(request); } );
4019 auto packagedFunction = [task]() { (*task)(); };
4020 m_executor->Submit(packagedFunction);
4021 return task->get_future();
4022 }
4023
UploadServerCertificateAsync(const UploadServerCertificateRequest & request,const UploadServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4024 void IAMClient::UploadServerCertificateAsync(const UploadServerCertificateRequest& request, const UploadServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4025 {
4026 m_executor->Submit( [this, request, handler, context](){ this->UploadServerCertificateAsyncHelper( request, handler, context ); } );
4027 }
4028
UploadServerCertificateAsyncHelper(const UploadServerCertificateRequest & request,const UploadServerCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4029 void IAMClient::UploadServerCertificateAsyncHelper(const UploadServerCertificateRequest& request, const UploadServerCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4030 {
4031 handler(this, request, UploadServerCertificate(request), context);
4032 }
4033
UploadSigningCertificate(const UploadSigningCertificateRequest & request) const4034 UploadSigningCertificateOutcome IAMClient::UploadSigningCertificate(const UploadSigningCertificateRequest& request) const
4035 {
4036 Aws::Http::URI uri = m_uri;
4037 return UploadSigningCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
4038 }
4039
UploadSigningCertificateCallable(const UploadSigningCertificateRequest & request) const4040 UploadSigningCertificateOutcomeCallable IAMClient::UploadSigningCertificateCallable(const UploadSigningCertificateRequest& request) const
4041 {
4042 auto task = Aws::MakeShared< std::packaged_task< UploadSigningCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UploadSigningCertificate(request); } );
4043 auto packagedFunction = [task]() { (*task)(); };
4044 m_executor->Submit(packagedFunction);
4045 return task->get_future();
4046 }
4047
UploadSigningCertificateAsync(const UploadSigningCertificateRequest & request,const UploadSigningCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4048 void IAMClient::UploadSigningCertificateAsync(const UploadSigningCertificateRequest& request, const UploadSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4049 {
4050 m_executor->Submit( [this, request, handler, context](){ this->UploadSigningCertificateAsyncHelper( request, handler, context ); } );
4051 }
4052
UploadSigningCertificateAsyncHelper(const UploadSigningCertificateRequest & request,const UploadSigningCertificateResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const4053 void IAMClient::UploadSigningCertificateAsyncHelper(const UploadSigningCertificateRequest& request, const UploadSigningCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
4054 {
4055 handler(this, request, UploadSigningCertificate(request), context);
4056 }
4057
4058