blib/lib/Paws/CognitoIdp.pm untested

filter: Statementstmt 0.0% 0 / 498 Branchbran 0.0% 0 / 36 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 117 Podpod 0.0% 0 / 116 totaltotal 0.0% 0 / 767 CC 19 SCAR 13.9
CC
19
Cov
0%
AdminListAllGroupsForUser
12.0
AdminListAllUserAuthEvents
12.0
ListAllGroups
12.0
CRAP 4.0
1 package Paws::CognitoIdp;
2 use Moose;
3 sub service { 'cognito-idp' }
4 sub signing_name { 'cognito-idp' }
5 sub version { '2016-04-18' }
6 sub target_prefix { 'AWSCognitoIdentityProviderService' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub AddCustomAttributes {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AddCustomAttributes', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub AdminAddUserToGroup {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminAddUserToGroup', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub AdminConfirmSignUp {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminConfirmSignUp', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub AdminCreateUser {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminCreateUser', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub AdminDeleteUser {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminDeleteUser', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub AdminDeleteUserAttributes {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminDeleteUserAttributes', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub AdminDisableProviderForUser {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminDisableProviderForUser', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub AdminDisableUser {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminDisableUser', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub AdminEnableUser {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminEnableUser', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub AdminForgetDevice {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminForgetDevice', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub AdminGetDevice {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminGetDevice', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub AdminGetUser {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminGetUser', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub AdminInitiateAuth {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminInitiateAuth', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub AdminLinkProviderForUser {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminLinkProviderForUser', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub AdminListDevices {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminListDevices', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub AdminListGroupsForUser {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminListGroupsForUser', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub AdminListUserAuthEvents {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminListUserAuthEvents', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub AdminRemoveUserFromGroup {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminRemoveUserFromGroup', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub AdminResetUserPassword {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminResetUserPassword', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub AdminRespondToAuthChallenge {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminRespondToAuthChallenge', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub AdminSetUserMFAPreference {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminSetUserMFAPreference', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub AdminSetUserPassword {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminSetUserPassword', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub AdminSetUserSettings {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminSetUserSettings', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub AdminUpdateAuthEventFeedback {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminUpdateAuthEventFeedback', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub AdminUpdateDeviceStatus {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminUpdateDeviceStatus', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub AdminUpdateUserAttributes {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminUpdateUserAttributes', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub AdminUserGlobalSignOut {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AdminUserGlobalSignOut', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub AssociateSoftwareToken {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::AssociateSoftwareToken', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub ChangePassword {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ChangePassword', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub ConfirmDevice {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ConfirmDevice', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub ConfirmForgotPassword {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ConfirmForgotPassword', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub ConfirmSignUp {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ConfirmSignUp', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub CreateGroup {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::CreateGroup', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub CreateIdentityProvider {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::CreateIdentityProvider', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub CreateResourceServer {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::CreateResourceServer', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub CreateUserImportJob {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::CreateUserImportJob', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub CreateUserPool {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::CreateUserPool', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub CreateUserPoolClient {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::CreateUserPoolClient', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub CreateUserPoolDomain {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::CreateUserPoolDomain', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub DeleteGroup {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DeleteGroup', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218 sub DeleteIdentityProvider {
219 my $self = shift;
220 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DeleteIdentityProvider', @_);
221 return $self->caller->do_call($self, $call_object);
222 }
223 sub DeleteResourceServer {
224 my $self = shift;
225 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DeleteResourceServer', @_);
226 return $self->caller->do_call($self, $call_object);
227 }
228 sub DeleteUser {
229 my $self = shift;
230 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DeleteUser', @_);
231 return $self->caller->do_call($self, $call_object);
232 }
233 sub DeleteUserAttributes {
234 my $self = shift;
235 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DeleteUserAttributes', @_);
236 return $self->caller->do_call($self, $call_object);
237 }
238 sub DeleteUserPool {
239 my $self = shift;
240 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DeleteUserPool', @_);
241 return $self->caller->do_call($self, $call_object);
242 }
243 sub DeleteUserPoolClient {
244 my $self = shift;
245 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DeleteUserPoolClient', @_);
246 return $self->caller->do_call($self, $call_object);
247 }
248 sub DeleteUserPoolDomain {
249 my $self = shift;
250 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DeleteUserPoolDomain', @_);
251 return $self->caller->do_call($self, $call_object);
252 }
253 sub DescribeIdentityProvider {
254 my $self = shift;
255 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DescribeIdentityProvider', @_);
256 return $self->caller->do_call($self, $call_object);
257 }
258 sub DescribeResourceServer {
259 my $self = shift;
260 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DescribeResourceServer', @_);
261 return $self->caller->do_call($self, $call_object);
262 }
263 sub DescribeRiskConfiguration {
264 my $self = shift;
265 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DescribeRiskConfiguration', @_);
266 return $self->caller->do_call($self, $call_object);
267 }
268 sub DescribeUserImportJob {
269 my $self = shift;
270 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DescribeUserImportJob', @_);
271 return $self->caller->do_call($self, $call_object);
272 }
273 sub DescribeUserPool {
274 my $self = shift;
275 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DescribeUserPool', @_);
276 return $self->caller->do_call($self, $call_object);
277 }
278 sub DescribeUserPoolClient {
279 my $self = shift;
280 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DescribeUserPoolClient', @_);
281 return $self->caller->do_call($self, $call_object);
282 }
283 sub DescribeUserPoolDomain {
284 my $self = shift;
285 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::DescribeUserPoolDomain', @_);
286 return $self->caller->do_call($self, $call_object);
287 }
288 sub ForgetDevice {
289 my $self = shift;
290 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ForgetDevice', @_);
291 return $self->caller->do_call($self, $call_object);
292 }
293 sub ForgotPassword {
294 my $self = shift;
295 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ForgotPassword', @_);
296 return $self->caller->do_call($self, $call_object);
297 }
298 sub GetCSVHeader {
299 my $self = shift;
300 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetCSVHeader', @_);
301 return $self->caller->do_call($self, $call_object);
302 }
303 sub GetDevice {
304 my $self = shift;
305 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetDevice', @_);
306 return $self->caller->do_call($self, $call_object);
307 }
308 sub GetGroup {
309 my $self = shift;
310 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetGroup', @_);
311 return $self->caller->do_call($self, $call_object);
312 }
313 sub GetIdentityProviderByIdentifier {
314 my $self = shift;
315 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetIdentityProviderByIdentifier', @_);
316 return $self->caller->do_call($self, $call_object);
317 }
318 sub GetSigningCertificate {
319 my $self = shift;
320 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetSigningCertificate', @_);
321 return $self->caller->do_call($self, $call_object);
322 }
323 sub GetUICustomization {
324 my $self = shift;
325 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetUICustomization', @_);
326 return $self->caller->do_call($self, $call_object);
327 }
328 sub GetUser {
329 my $self = shift;
330 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetUser', @_);
331 return $self->caller->do_call($self, $call_object);
332 }
333 sub GetUserAttributeVerificationCode {
334 my $self = shift;
335 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetUserAttributeVerificationCode', @_);
336 return $self->caller->do_call($self, $call_object);
337 }
338 sub GetUserPoolMfaConfig {
339 my $self = shift;
340 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GetUserPoolMfaConfig', @_);
341 return $self->caller->do_call($self, $call_object);
342 }
343 sub GlobalSignOut {
344 my $self = shift;
345 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::GlobalSignOut', @_);
346 return $self->caller->do_call($self, $call_object);
347 }
348 sub InitiateAuth {
349 my $self = shift;
350 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::InitiateAuth', @_);
351 return $self->caller->do_call($self, $call_object);
352 }
353 sub ListDevices {
354 my $self = shift;
355 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListDevices', @_);
356 return $self->caller->do_call($self, $call_object);
357 }
358 sub ListGroups {
359 my $self = shift;
360 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListGroups', @_);
361 return $self->caller->do_call($self, $call_object);
362 }
363 sub ListIdentityProviders {
364 my $self = shift;
365 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListIdentityProviders', @_);
366 return $self->caller->do_call($self, $call_object);
367 }
368 sub ListResourceServers {
369 my $self = shift;
370 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListResourceServers', @_);
371 return $self->caller->do_call($self, $call_object);
372 }
373 sub ListTagsForResource {
374 my $self = shift;
375 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListTagsForResource', @_);
376 return $self->caller->do_call($self, $call_object);
377 }
378 sub ListUserImportJobs {
379 my $self = shift;
380 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListUserImportJobs', @_);
381 return $self->caller->do_call($self, $call_object);
382 }
383 sub ListUserPoolClients {
384 my $self = shift;
385 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListUserPoolClients', @_);
386 return $self->caller->do_call($self, $call_object);
387 }
388 sub ListUserPools {
389 my $self = shift;
390 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListUserPools', @_);
391 return $self->caller->do_call($self, $call_object);
392 }
393 sub ListUsers {
394 my $self = shift;
395 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListUsers', @_);
396 return $self->caller->do_call($self, $call_object);
397 }
398 sub ListUsersInGroup {
399 my $self = shift;
400 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ListUsersInGroup', @_);
401 return $self->caller->do_call($self, $call_object);
402 }
403 sub ResendConfirmationCode {
404 my $self = shift;
405 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::ResendConfirmationCode', @_);
406 return $self->caller->do_call($self, $call_object);
407 }
408 sub RespondToAuthChallenge {
409 my $self = shift;
410 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::RespondToAuthChallenge', @_);
411 return $self->caller->do_call($self, $call_object);
412 }
413 sub RevokeToken {
414 my $self = shift;
415 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::RevokeToken', @_);
416 return $self->caller->do_call($self, $call_object);
417 }
418 sub SetRiskConfiguration {
419 my $self = shift;
420 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::SetRiskConfiguration', @_);
421 return $self->caller->do_call($self, $call_object);
422 }
423 sub SetUICustomization {
424 my $self = shift;
425 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::SetUICustomization', @_);
426 return $self->caller->do_call($self, $call_object);
427 }
428 sub SetUserMFAPreference {
429 my $self = shift;
430 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::SetUserMFAPreference', @_);
431 return $self->caller->do_call($self, $call_object);
432 }
433 sub SetUserPoolMfaConfig {
434 my $self = shift;
435 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::SetUserPoolMfaConfig', @_);
436 return $self->caller->do_call($self, $call_object);
437 }
438 sub SetUserSettings {
439 my $self = shift;
440 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::SetUserSettings', @_);
441 return $self->caller->do_call($self, $call_object);
442 }
443 sub SignUp {
444 my $self = shift;
445 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::SignUp', @_);
446 return $self->caller->do_call($self, $call_object);
447 }
448 sub StartUserImportJob {
449 my $self = shift;
450 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::StartUserImportJob', @_);
451 return $self->caller->do_call($self, $call_object);
452 }
453 sub StopUserImportJob {
454 my $self = shift;
455 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::StopUserImportJob', @_);
456 return $self->caller->do_call($self, $call_object);
457 }
458 sub TagResource {
459 my $self = shift;
460 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::TagResource', @_);
461 return $self->caller->do_call($self, $call_object);
462 }
463 sub UntagResource {
464 my $self = shift;
465 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UntagResource', @_);
466 return $self->caller->do_call($self, $call_object);
467 }
468 sub UpdateAuthEventFeedback {
469 my $self = shift;
470 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateAuthEventFeedback', @_);
471 return $self->caller->do_call($self, $call_object);
472 }
473 sub UpdateDeviceStatus {
474 my $self = shift;
475 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateDeviceStatus', @_);
476 return $self->caller->do_call($self, $call_object);
477 }
478 sub UpdateGroup {
479 my $self = shift;
480 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateGroup', @_);
481 return $self->caller->do_call($self, $call_object);
482 }
483 sub UpdateIdentityProvider {
484 my $self = shift;
485 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateIdentityProvider', @_);
486 return $self->caller->do_call($self, $call_object);
487 }
488 sub UpdateResourceServer {
489 my $self = shift;
490 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateResourceServer', @_);
491 return $self->caller->do_call($self, $call_object);
492 }
493 sub UpdateUserAttributes {
494 my $self = shift;
495 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateUserAttributes', @_);
496 return $self->caller->do_call($self, $call_object);
497 }
498 sub UpdateUserPool {
499 my $self = shift;
500 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateUserPool', @_);
501 return $self->caller->do_call($self, $call_object);
502 }
503 sub UpdateUserPoolClient {
504 my $self = shift;
505 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateUserPoolClient', @_);
506 return $self->caller->do_call($self, $call_object);
507 }
508 sub UpdateUserPoolDomain {
509 my $self = shift;
510 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::UpdateUserPoolDomain', @_);
511 return $self->caller->do_call($self, $call_object);
512 }
513 sub VerifySoftwareToken {
514 my $self = shift;
515 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::VerifySoftwareToken', @_);
516 return $self->caller->do_call($self, $call_object);
517 }
518 sub VerifyUserAttribute {
519 my $self = shift;
520 my $call_object = $self->new_with_coercions('Paws::CognitoIdp::VerifyUserAttribute', @_);
521 return $self->caller->do_call($self, $call_object);
522 }
523
524 sub AdminListAllGroupsForUser {
525 my $self = shift;
526  
527 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
528 my $result = $self->AdminListGroupsForUser(@_);
529 my $next_result = $result;
530  
531 if (not defined $callback) {
532 while ($next_result->NextToken) {
533 $next_result = $self->AdminListGroupsForUser(@_, NextToken => $next_result->NextToken);
534 push @{ $result->Groups }, @{ $next_result->Groups };
535 }
536 return $result;
537 } else {
538 while ($result->NextToken) {
539 $callback->($_ => 'Groups') foreach (@{ $result->Groups });
540 $result = $self->AdminListGroupsForUser(@_, NextToken => $result->NextToken);
541 }
542 $callback->($_ => 'Groups') foreach (@{ $result->Groups });
543 }
544  
545 return undef
546 }
547 sub AdminListAllUserAuthEvents {
548 my $self = shift;
549  
550 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
551 my $result = $self->AdminListUserAuthEvents(@_);
552 my $next_result = $result;
553  
554 if (not defined $callback) {
555 while ($next_result->NextToken) {
556 $next_result = $self->AdminListUserAuthEvents(@_, NextToken => $next_result->NextToken);
557 push @{ $result->AuthEvents }, @{ $next_result->AuthEvents };
558 }
559 return $result;
560 } else {
561 while ($result->NextToken) {
562 $callback->($_ => 'AuthEvents') foreach (@{ $result->AuthEvents });
563 $result = $self->AdminListUserAuthEvents(@_, NextToken => $result->NextToken);
564 }
565 $callback->($_ => 'AuthEvents') foreach (@{ $result->AuthEvents });
566 }
567  
568 return undef
569 }
570 sub ListAllGroups {
571 my $self = shift;
572  
573 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
574 my $result = $self->ListGroups(@_);
575 my $next_result = $result;
576  
577 if (not defined $callback) {
578 while ($next_result->NextToken) {
579 $next_result = $self->ListGroups(@_, NextToken => $next_result->NextToken);
580 push @{ $result->Groups }, @{ $next_result->Groups };
581 }
582 return $result;
583 } else {
584 while ($result->NextToken) {
585 $callback->($_ => 'Groups') foreach (@{ $result->Groups });
586 $result = $self->ListGroups(@_, NextToken => $result->NextToken);
587 }
588 $callback->($_ => 'Groups') foreach (@{ $result->Groups });
589 }
590  
591 return undef
592 }
593 sub ListAllIdentityProviders {
594 my $self = shift;
595  
596 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
597 my $result = $self->ListIdentityProviders(@_);
598 my $next_result = $result;
599  
600 if (not defined $callback) {
601 while ($next_result->NextToken) {
602 $next_result = $self->ListIdentityProviders(@_, NextToken => $next_result->NextToken);
603 push @{ $result->Providers }, @{ $next_result->Providers };
604 }
605 return $result;
606 } else {
607 while ($result->NextToken) {
608 $callback->($_ => 'Providers') foreach (@{ $result->Providers });
609 $result = $self->ListIdentityProviders(@_, NextToken => $result->NextToken);
610 }
611 $callback->($_ => 'Providers') foreach (@{ $result->Providers });
612 }
613  
614 return undef
615 }
616 sub ListAllResourceServers {
617 my $self = shift;
618  
619 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
620 my $result = $self->ListResourceServers(@_);
621 my $next_result = $result;
622  
623 if (not defined $callback) {
624 while ($next_result->NextToken) {
625 $next_result = $self->ListResourceServers(@_, NextToken => $next_result->NextToken);
626 push @{ $result->ResourceServers }, @{ $next_result->ResourceServers };
627 }
628 return $result;
629 } else {
630 while ($result->NextToken) {
631 $callback->($_ => 'ResourceServers') foreach (@{ $result->ResourceServers });
632 $result = $self->ListResourceServers(@_, NextToken => $result->NextToken);
633 }
634 $callback->($_ => 'ResourceServers') foreach (@{ $result->ResourceServers });
635 }
636  
637 return undef
638 }
639 sub ListAllUserPoolClients {
640 my $self = shift;
641  
642 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
643 my $result = $self->ListUserPoolClients(@_);
644 my $next_result = $result;
645  
646 if (not defined $callback) {
647 while ($next_result->NextToken) {
648 $next_result = $self->ListUserPoolClients(@_, NextToken => $next_result->NextToken);
649 push @{ $result->UserPoolClients }, @{ $next_result->UserPoolClients };
650 }
651 return $result;
652 } else {
653 while ($result->NextToken) {
654 $callback->($_ => 'UserPoolClients') foreach (@{ $result->UserPoolClients });
655 $result = $self->ListUserPoolClients(@_, NextToken => $result->NextToken);
656 }
657 $callback->($_ => 'UserPoolClients') foreach (@{ $result->UserPoolClients });
658 }
659  
660 return undef
661 }
662 sub ListAllUserPools {
663 my $self = shift;
664  
665 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
666 my $result = $self->ListUserPools(@_);
667 my $next_result = $result;
668  
669 if (not defined $callback) {
670 while ($next_result->NextToken) {
671 $next_result = $self->ListUserPools(@_, NextToken => $next_result->NextToken);
672 push @{ $result->UserPools }, @{ $next_result->UserPools };
673 }
674 return $result;
675 } else {
676 while ($result->NextToken) {
677 $callback->($_ => 'UserPools') foreach (@{ $result->UserPools });
678 $result = $self->ListUserPools(@_, NextToken => $result->NextToken);
679 }
680 $callback->($_ => 'UserPools') foreach (@{ $result->UserPools });
681 }
682  
683 return undef
684 }
685 sub ListAllUsers {
686 my $self = shift;
687  
688 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
689 my $result = $self->ListUsers(@_);
690 my $next_result = $result;
691  
692 if (not defined $callback) {
693 while ($next_result->PaginationToken) {
694 $next_result = $self->ListUsers(@_, PaginationToken => $next_result->PaginationToken);
695 push @{ $result->Users }, @{ $next_result->Users };
696 }
697 return $result;
698 } else {
699 while ($result->PaginationToken) {
700 $callback->($_ => 'Users') foreach (@{ $result->Users });
701 $result = $self->ListUsers(@_, PaginationToken => $result->PaginationToken);
702 }
703 $callback->($_ => 'Users') foreach (@{ $result->Users });
704 }
705  
706 return undef
707 }
708 sub ListAllUsersInGroup {
709 my $self = shift;
710  
711 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
712 my $result = $self->ListUsersInGroup(@_);
713 my $next_result = $result;
714  
715 if (not defined $callback) {
716 while ($next_result->NextToken) {
717 $next_result = $self->ListUsersInGroup(@_, NextToken => $next_result->NextToken);
718 push @{ $result->Users }, @{ $next_result->Users };
719 }
720 return $result;
721 } else {
722 while ($result->NextToken) {
723 $callback->($_ => 'Users') foreach (@{ $result->Users });
724 $result = $self->ListUsersInGroup(@_, NextToken => $result->NextToken);
725 }
726 $callback->($_ => 'Users') foreach (@{ $result->Users });
727 }
728  
729 return undef
730 }
731  
732  
733 sub operations { qw/AddCustomAttributes AdminAddUserToGroup AdminConfirmSignUp AdminCreateUser AdminDeleteUser AdminDeleteUserAttributes AdminDisableProviderForUser AdminDisableUser AdminEnableUser AdminForgetDevice AdminGetDevice AdminGetUser AdminInitiateAuth AdminLinkProviderForUser AdminListDevices AdminListGroupsForUser AdminListUserAuthEvents AdminRemoveUserFromGroup AdminResetUserPassword AdminRespondToAuthChallenge AdminSetUserMFAPreference AdminSetUserPassword AdminSetUserSettings AdminUpdateAuthEventFeedback AdminUpdateDeviceStatus AdminUpdateUserAttributes AdminUserGlobalSignOut AssociateSoftwareToken ChangePassword ConfirmDevice ConfirmForgotPassword ConfirmSignUp CreateGroup CreateIdentityProvider CreateResourceServer CreateUserImportJob CreateUserPool CreateUserPoolClient CreateUserPoolDomain DeleteGroup DeleteIdentityProvider DeleteResourceServer DeleteUser DeleteUserAttributes DeleteUserPool DeleteUserPoolClient DeleteUserPoolDomain DescribeIdentityProvider DescribeResourceServer DescribeRiskConfiguration DescribeUserImportJob DescribeUserPool DescribeUserPoolClient DescribeUserPoolDomain ForgetDevice ForgotPassword GetCSVHeader GetDevice GetGroup GetIdentityProviderByIdentifier GetSigningCertificate GetUICustomization GetUser GetUserAttributeVerificationCode GetUserPoolMfaConfig GlobalSignOut InitiateAuth ListDevices ListGroups ListIdentityProviders ListResourceServers ListTagsForResource ListUserImportJobs ListUserPoolClients ListUserPools ListUsers ListUsersInGroup ResendConfirmationCode RespondToAuthChallenge RevokeToken SetRiskConfiguration SetUICustomization SetUserMFAPreference SetUserPoolMfaConfig SetUserSettings SignUp StartUserImportJob StopUserImportJob TagResource UntagResource UpdateAuthEventFeedback UpdateDeviceStatus UpdateGroup UpdateIdentityProvider UpdateResourceServer UpdateUserAttributes UpdateUserPool UpdateUserPoolClient UpdateUserPoolDomain VerifySoftwareToken VerifyUserAttribute / }
734  
735 1;
736  
737 ### main pod documentation begin ###
738  
739 =head1 NAME
740  
741 Paws::CognitoIdp - Perl Interface to AWS Amazon Cognito Identity Provider
742  
743 =head1 SYNOPSIS
744  
745 use Paws;
746  
747 my $obj = Paws->service('CognitoIdp');
748 my $res = $obj->Method(
749 Arg1 => $val1,
750 Arg2 => [ 'V1', 'V2' ],
751 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
752 # of the arguments type
753 Arg3 => { Att1 => 'Val1' },
754 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
755 # the constructor of the arguments type
756 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
757 );
758  
759 =head1 DESCRIPTION
760  
761 Using the Amazon Cognito User Pools API, you can create a user pool to
762 manage directories and users. You can authenticate a user to obtain
763 tokens related to user identity and access policies.
764  
765 This API reference provides information about user pools in Amazon
766 Cognito User Pools.
767  
768 For more information, see the Amazon Cognito Documentation
769 (https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html).
770  
771 For the AWS API documentation, see L<https://docs.aws.amazon.com/cognito/>
772  
773  
774 =head1 METHODS
775  
776 =head2 AddCustomAttributes
777  
778 =over
779  
780 =item CustomAttributes => ArrayRef[L<Paws::CognitoIdp::SchemaAttributeType>]
781  
782 =item UserPoolId => Str
783  
784  
785 =back
786  
787 Each argument is described in detail in: L<Paws::CognitoIdp::AddCustomAttributes>
788  
789 Returns: a L<Paws::CognitoIdp::AddCustomAttributesResponse> instance
790  
791 Adds additional user attributes to the user pool schema.
792  
793  
794 =head2 AdminAddUserToGroup
795  
796 =over
797  
798 =item GroupName => Str
799  
800 =item Username => Str
801  
802 =item UserPoolId => Str
803  
804  
805 =back
806  
807 Each argument is described in detail in: L<Paws::CognitoIdp::AdminAddUserToGroup>
808  
809 Returns: nothing
810  
811 Adds the specified user to the specified group.
812  
813 Calling this action requires developer credentials.
814  
815  
816 =head2 AdminConfirmSignUp
817  
818 =over
819  
820 =item Username => Str
821  
822 =item UserPoolId => Str
823  
824 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
825  
826  
827 =back
828  
829 Each argument is described in detail in: L<Paws::CognitoIdp::AdminConfirmSignUp>
830  
831 Returns: a L<Paws::CognitoIdp::AdminConfirmSignUpResponse> instance
832  
833 Confirms user registration as an admin without using a confirmation
834 code. Works on any user.
835  
836 Calling this action requires developer credentials.
837  
838  
839 =head2 AdminCreateUser
840  
841 =over
842  
843 =item Username => Str
844  
845 =item UserPoolId => Str
846  
847 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
848  
849 =item [DesiredDeliveryMediums => ArrayRef[Str|Undef]]
850  
851 =item [ForceAliasCreation => Bool]
852  
853 =item [MessageAction => Str]
854  
855 =item [TemporaryPassword => Str]
856  
857 =item [UserAttributes => ArrayRef[L<Paws::CognitoIdp::AttributeType>]]
858  
859 =item [ValidationData => ArrayRef[L<Paws::CognitoIdp::AttributeType>]]
860  
861  
862 =back
863  
864 Each argument is described in detail in: L<Paws::CognitoIdp::AdminCreateUser>
865  
866 Returns: a L<Paws::CognitoIdp::AdminCreateUserResponse> instance
867  
868 Creates a new user in the specified user pool.
869  
870 If C<MessageAction> is not set, the default is to send a welcome
871 message via email or phone (SMS).
872  
873 This action might generate an SMS text message. Starting June 1, 2021,
874 U.S. telecom carriers require that you register an origination phone
875 number before you can send SMS messages to U.S. phone numbers. If you
876 use SMS text messages in Amazon Cognito, you must register a phone
877 number with Amazon Pinpoint
878 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
879 the registered number automatically. Otherwise, Cognito users that must
880 receive SMS messages might be unable to sign up, activate their
881 accounts, or sign in.
882  
883 If you have never used SMS text messages with Amazon Cognito or any
884 other AWS service, Amazon SNS might place your account in SMS sandbox.
885 In I< sandbox mode
886 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
887 youE<rsquo>ll have limitations, such as sending messages to only
888 verified phone numbers. After testing in the sandbox environment, you
889 can move out of the SMS sandbox and into production. For more
890 information, see SMS message settings for Cognito User Pools
891 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
892 in the I<Amazon Cognito Developer Guide>.
893  
894 This message is based on a template that you configured in your call to
895 create or update a user pool. This template includes your custom
896 sign-up instructions and placeholders for user name and temporary
897 password.
898  
899 Alternatively, you can call C<AdminCreateUser> with
900 E<ldquo>SUPPRESSE<rdquo> for the C<MessageAction> parameter, and Amazon
901 Cognito will not send any email.
902  
903 In either case, the user will be in the C<FORCE_CHANGE_PASSWORD> state
904 until they sign in and change their password.
905  
906 C<AdminCreateUser> requires developer credentials.
907  
908  
909 =head2 AdminDeleteUser
910  
911 =over
912  
913 =item Username => Str
914  
915 =item UserPoolId => Str
916  
917  
918 =back
919  
920 Each argument is described in detail in: L<Paws::CognitoIdp::AdminDeleteUser>
921  
922 Returns: nothing
923  
924 Deletes a user as an administrator. Works on any user.
925  
926 Calling this action requires developer credentials.
927  
928  
929 =head2 AdminDeleteUserAttributes
930  
931 =over
932  
933 =item UserAttributeNames => ArrayRef[Str|Undef]
934  
935 =item Username => Str
936  
937 =item UserPoolId => Str
938  
939  
940 =back
941  
942 Each argument is described in detail in: L<Paws::CognitoIdp::AdminDeleteUserAttributes>
943  
944 Returns: a L<Paws::CognitoIdp::AdminDeleteUserAttributesResponse> instance
945  
946 Deletes the user attributes in a user pool as an administrator. Works
947 on any user.
948  
949 Calling this action requires developer credentials.
950  
951  
952 =head2 AdminDisableProviderForUser
953  
954 =over
955  
956 =item User => L<Paws::CognitoIdp::ProviderUserIdentifierType>
957  
958 =item UserPoolId => Str
959  
960  
961 =back
962  
963 Each argument is described in detail in: L<Paws::CognitoIdp::AdminDisableProviderForUser>
964  
965 Returns: a L<Paws::CognitoIdp::AdminDisableProviderForUserResponse> instance
966  
967 Disables the user from signing in with the specified external (SAML or
968 social) identity provider. If the user to disable is a Cognito User
969 Pools native username + password user, they are not permitted to use
970 their password to sign-in. If the user to disable is a linked external
971 IdP user, any link between that user and an existing user is removed.
972 The next time the external user (no longer attached to the previously
973 linked C<DestinationUser>) signs in, they must create a new user
974 account. See AdminLinkProviderForUser
975 (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminLinkProviderForUser.html).
976  
977 This action is enabled only for admin access and requires developer
978 credentials.
979  
980 The C<ProviderName> must match the value specified when creating an IdP
981 for the pool.
982  
983 To disable a native username + password user, the C<ProviderName> value
984 must be C<Cognito> and the C<ProviderAttributeName> must be
985 C<Cognito_Subject>, with the C<ProviderAttributeValue> being the name
986 that is used in the user pool for the user.
987  
988 The C<ProviderAttributeName> must always be C<Cognito_Subject> for
989 social identity providers. The C<ProviderAttributeValue> must always be
990 the exact subject that was used when the user was originally linked as
991 a source user.
992  
993 For de-linking a SAML identity, there are two scenarios. If the linked
994 identity has not yet been used to sign-in, the C<ProviderAttributeName>
995 and C<ProviderAttributeValue> must be the same values that were used
996 for the C<SourceUser> when the identities were originally linked using
997 C< AdminLinkProviderForUser> call. (If the linking was done with
998 C<ProviderAttributeName> set to C<Cognito_Subject>, the same applies
999 here). However, if the user has already signed in, the
1000 C<ProviderAttributeName> must be C<Cognito_Subject> and
1001 C<ProviderAttributeValue> must be the subject of the SAML assertion.
1002  
1003  
1004 =head2 AdminDisableUser
1005  
1006 =over
1007  
1008 =item Username => Str
1009  
1010 =item UserPoolId => Str
1011  
1012  
1013 =back
1014  
1015 Each argument is described in detail in: L<Paws::CognitoIdp::AdminDisableUser>
1016  
1017 Returns: a L<Paws::CognitoIdp::AdminDisableUserResponse> instance
1018  
1019 Disables the specified user.
1020  
1021 Calling this action requires developer credentials.
1022  
1023  
1024 =head2 AdminEnableUser
1025  
1026 =over
1027  
1028 =item Username => Str
1029  
1030 =item UserPoolId => Str
1031  
1032  
1033 =back
1034  
1035 Each argument is described in detail in: L<Paws::CognitoIdp::AdminEnableUser>
1036  
1037 Returns: a L<Paws::CognitoIdp::AdminEnableUserResponse> instance
1038  
1039 Enables the specified user as an administrator. Works on any user.
1040  
1041 Calling this action requires developer credentials.
1042  
1043  
1044 =head2 AdminForgetDevice
1045  
1046 =over
1047  
1048 =item DeviceKey => Str
1049  
1050 =item Username => Str
1051  
1052 =item UserPoolId => Str
1053  
1054  
1055 =back
1056  
1057 Each argument is described in detail in: L<Paws::CognitoIdp::AdminForgetDevice>
1058  
1059 Returns: nothing
1060  
1061 Forgets the device, as an administrator.
1062  
1063 Calling this action requires developer credentials.
1064  
1065  
1066 =head2 AdminGetDevice
1067  
1068 =over
1069  
1070 =item DeviceKey => Str
1071  
1072 =item Username => Str
1073  
1074 =item UserPoolId => Str
1075  
1076  
1077 =back
1078  
1079 Each argument is described in detail in: L<Paws::CognitoIdp::AdminGetDevice>
1080  
1081 Returns: a L<Paws::CognitoIdp::AdminGetDeviceResponse> instance
1082  
1083 Gets the device, as an administrator.
1084  
1085 Calling this action requires developer credentials.
1086  
1087  
1088 =head2 AdminGetUser
1089  
1090 =over
1091  
1092 =item Username => Str
1093  
1094 =item UserPoolId => Str
1095  
1096  
1097 =back
1098  
1099 Each argument is described in detail in: L<Paws::CognitoIdp::AdminGetUser>
1100  
1101 Returns: a L<Paws::CognitoIdp::AdminGetUserResponse> instance
1102  
1103 Gets the specified user by user name in a user pool as an
1104 administrator. Works on any user.
1105  
1106 Calling this action requires developer credentials.
1107  
1108  
1109 =head2 AdminInitiateAuth
1110  
1111 =over
1112  
1113 =item AuthFlow => Str
1114  
1115 =item ClientId => Str
1116  
1117 =item UserPoolId => Str
1118  
1119 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
1120  
1121 =item [AuthParameters => L<Paws::CognitoIdp::AuthParametersType>]
1122  
1123 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
1124  
1125 =item [ContextData => L<Paws::CognitoIdp::ContextDataType>]
1126  
1127  
1128 =back
1129  
1130 Each argument is described in detail in: L<Paws::CognitoIdp::AdminInitiateAuth>
1131  
1132 Returns: a L<Paws::CognitoIdp::AdminInitiateAuthResponse> instance
1133  
1134 Initiates the authentication flow, as an administrator.
1135  
1136 This action might generate an SMS text message. Starting June 1, 2021,
1137 U.S. telecom carriers require that you register an origination phone
1138 number before you can send SMS messages to U.S. phone numbers. If you
1139 use SMS text messages in Amazon Cognito, you must register a phone
1140 number with Amazon Pinpoint
1141 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
1142 the registered number automatically. Otherwise, Cognito users that must
1143 receive SMS messages might be unable to sign up, activate their
1144 accounts, or sign in.
1145  
1146 If you have never used SMS text messages with Amazon Cognito or any
1147 other AWS service, Amazon SNS might place your account in SMS sandbox.
1148 In I< sandbox mode
1149 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
1150 youE<rsquo>ll have limitations, such as sending messages to only
1151 verified phone numbers. After testing in the sandbox environment, you
1152 can move out of the SMS sandbox and into production. For more
1153 information, see SMS message settings for Cognito User Pools
1154 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
1155 in the I<Amazon Cognito Developer Guide>.
1156  
1157 Calling this action requires developer credentials.
1158  
1159  
1160 =head2 AdminLinkProviderForUser
1161  
1162 =over
1163  
1164 =item DestinationUser => L<Paws::CognitoIdp::ProviderUserIdentifierType>
1165  
1166 =item SourceUser => L<Paws::CognitoIdp::ProviderUserIdentifierType>
1167  
1168 =item UserPoolId => Str
1169  
1170  
1171 =back
1172  
1173 Each argument is described in detail in: L<Paws::CognitoIdp::AdminLinkProviderForUser>
1174  
1175 Returns: a L<Paws::CognitoIdp::AdminLinkProviderForUserResponse> instance
1176  
1177 Links an existing user account in a user pool (C<DestinationUser>) to
1178 an identity from an external identity provider (C<SourceUser>) based on
1179 a specified attribute name and value from the external identity
1180 provider. This allows you to create a link from the existing user
1181 account to an external federated user identity that has not yet been
1182 used to sign in, so that the federated user identity can be used to
1183 sign in as the existing user account.
1184  
1185 For example, if there is an existing user with a username and password,
1186 this API links that user to a federated user identity, so that when the
1187 federated user identity is used, the user signs in as the existing user
1188 account.
1189  
1190 The maximum number of federated identities linked to a user is 5.
1191  
1192 Because this API allows a user with an external federated identity to
1193 sign in as an existing user in the user pool, it is critical that it
1194 only be used with external identity providers and provider attributes
1195 that have been trusted by the application owner.
1196  
1197 This action is enabled only for admin access and requires developer
1198 credentials.
1199  
1200  
1201 =head2 AdminListDevices
1202  
1203 =over
1204  
1205 =item Username => Str
1206  
1207 =item UserPoolId => Str
1208  
1209 =item [Limit => Int]
1210  
1211 =item [PaginationToken => Str]
1212  
1213  
1214 =back
1215  
1216 Each argument is described in detail in: L<Paws::CognitoIdp::AdminListDevices>
1217  
1218 Returns: a L<Paws::CognitoIdp::AdminListDevicesResponse> instance
1219  
1220 Lists devices, as an administrator.
1221  
1222 Calling this action requires developer credentials.
1223  
1224  
1225 =head2 AdminListGroupsForUser
1226  
1227 =over
1228  
1229 =item Username => Str
1230  
1231 =item UserPoolId => Str
1232  
1233 =item [Limit => Int]
1234  
1235 =item [NextToken => Str]
1236  
1237  
1238 =back
1239  
1240 Each argument is described in detail in: L<Paws::CognitoIdp::AdminListGroupsForUser>
1241  
1242 Returns: a L<Paws::CognitoIdp::AdminListGroupsForUserResponse> instance
1243  
1244 Lists the groups that the user belongs to.
1245  
1246 Calling this action requires developer credentials.
1247  
1248  
1249 =head2 AdminListUserAuthEvents
1250  
1251 =over
1252  
1253 =item Username => Str
1254  
1255 =item UserPoolId => Str
1256  
1257 =item [MaxResults => Int]
1258  
1259 =item [NextToken => Str]
1260  
1261  
1262 =back
1263  
1264 Each argument is described in detail in: L<Paws::CognitoIdp::AdminListUserAuthEvents>
1265  
1266 Returns: a L<Paws::CognitoIdp::AdminListUserAuthEventsResponse> instance
1267  
1268 Lists a history of user activity and any risks detected as part of
1269 Amazon Cognito advanced security.
1270  
1271  
1272 =head2 AdminRemoveUserFromGroup
1273  
1274 =over
1275  
1276 =item GroupName => Str
1277  
1278 =item Username => Str
1279  
1280 =item UserPoolId => Str
1281  
1282  
1283 =back
1284  
1285 Each argument is described in detail in: L<Paws::CognitoIdp::AdminRemoveUserFromGroup>
1286  
1287 Returns: nothing
1288  
1289 Removes the specified user from the specified group.
1290  
1291 Calling this action requires developer credentials.
1292  
1293  
1294 =head2 AdminResetUserPassword
1295  
1296 =over
1297  
1298 =item Username => Str
1299  
1300 =item UserPoolId => Str
1301  
1302 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
1303  
1304  
1305 =back
1306  
1307 Each argument is described in detail in: L<Paws::CognitoIdp::AdminResetUserPassword>
1308  
1309 Returns: a L<Paws::CognitoIdp::AdminResetUserPasswordResponse> instance
1310  
1311 Resets the specified user's password in a user pool as an
1312 administrator. Works on any user.
1313  
1314 When a developer calls this API, the current password is invalidated,
1315 so it must be changed. If a user tries to sign in after the API is
1316 called, the app will get a PasswordResetRequiredException exception
1317 back and should direct the user down the flow to reset the password,
1318 which is the same as the forgot password flow. In addition, if the user
1319 pool has phone verification selected and a verified phone number exists
1320 for the user, or if email verification is selected and a verified email
1321 exists for the user, calling this API will also result in sending a
1322 message to the end user with the code to change their password.
1323  
1324 This action might generate an SMS text message. Starting June 1, 2021,
1325 U.S. telecom carriers require that you register an origination phone
1326 number before you can send SMS messages to U.S. phone numbers. If you
1327 use SMS text messages in Amazon Cognito, you must register a phone
1328 number with Amazon Pinpoint
1329 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
1330 the registered number automatically. Otherwise, Cognito users that must
1331 receive SMS messages might be unable to sign up, activate their
1332 accounts, or sign in.
1333  
1334 If you have never used SMS text messages with Amazon Cognito or any
1335 other AWS service, Amazon SNS might place your account in SMS sandbox.
1336 In I< sandbox mode
1337 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
1338 youE<rsquo>ll have limitations, such as sending messages to only
1339 verified phone numbers. After testing in the sandbox environment, you
1340 can move out of the SMS sandbox and into production. For more
1341 information, see SMS message settings for Cognito User Pools
1342 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
1343 in the I<Amazon Cognito Developer Guide>.
1344  
1345 Calling this action requires developer credentials.
1346  
1347  
1348 =head2 AdminRespondToAuthChallenge
1349  
1350 =over
1351  
1352 =item ChallengeName => Str
1353  
1354 =item ClientId => Str
1355  
1356 =item UserPoolId => Str
1357  
1358 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
1359  
1360 =item [ChallengeResponses => L<Paws::CognitoIdp::ChallengeResponsesType>]
1361  
1362 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
1363  
1364 =item [ContextData => L<Paws::CognitoIdp::ContextDataType>]
1365  
1366 =item [Session => Str]
1367  
1368  
1369 =back
1370  
1371 Each argument is described in detail in: L<Paws::CognitoIdp::AdminRespondToAuthChallenge>
1372  
1373 Returns: a L<Paws::CognitoIdp::AdminRespondToAuthChallengeResponse> instance
1374  
1375 Responds to an authentication challenge, as an administrator.
1376  
1377 This action might generate an SMS text message. Starting June 1, 2021,
1378 U.S. telecom carriers require that you register an origination phone
1379 number before you can send SMS messages to U.S. phone numbers. If you
1380 use SMS text messages in Amazon Cognito, you must register a phone
1381 number with Amazon Pinpoint
1382 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
1383 the registered number automatically. Otherwise, Cognito users that must
1384 receive SMS messages might be unable to sign up, activate their
1385 accounts, or sign in.
1386  
1387 If you have never used SMS text messages with Amazon Cognito or any
1388 other AWS service, Amazon SNS might place your account in SMS sandbox.
1389 In I< sandbox mode
1390 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
1391 youE<rsquo>ll have limitations, such as sending messages to only
1392 verified phone numbers. After testing in the sandbox environment, you
1393 can move out of the SMS sandbox and into production. For more
1394 information, see SMS message settings for Cognito User Pools
1395 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
1396 in the I<Amazon Cognito Developer Guide>.
1397  
1398 Calling this action requires developer credentials.
1399  
1400  
1401 =head2 AdminSetUserMFAPreference
1402  
1403 =over
1404  
1405 =item Username => Str
1406  
1407 =item UserPoolId => Str
1408  
1409 =item [SMSMfaSettings => L<Paws::CognitoIdp::SMSMfaSettingsType>]
1410  
1411 =item [SoftwareTokenMfaSettings => L<Paws::CognitoIdp::SoftwareTokenMfaSettingsType>]
1412  
1413  
1414 =back
1415  
1416 Each argument is described in detail in: L<Paws::CognitoIdp::AdminSetUserMFAPreference>
1417  
1418 Returns: a L<Paws::CognitoIdp::AdminSetUserMFAPreferenceResponse> instance
1419  
1420 Sets the user's multi-factor authentication (MFA) preference, including
1421 which MFA options are enabled and if any are preferred. Only one factor
1422 can be set as preferred. The preferred MFA factor will be used to
1423 authenticate a user if multiple factors are enabled. If multiple
1424 options are enabled and no preference is set, a challenge to choose an
1425 MFA option will be returned during sign in.
1426  
1427  
1428 =head2 AdminSetUserPassword
1429  
1430 =over
1431  
1432 =item Password => Str
1433  
1434 =item Username => Str
1435  
1436 =item UserPoolId => Str
1437  
1438 =item [Permanent => Bool]
1439  
1440  
1441 =back
1442  
1443 Each argument is described in detail in: L<Paws::CognitoIdp::AdminSetUserPassword>
1444  
1445 Returns: a L<Paws::CognitoIdp::AdminSetUserPasswordResponse> instance
1446  
1447 Sets the specified user's password in a user pool as an administrator.
1448 Works on any user.
1449  
1450 The password can be temporary or permanent. If it is temporary, the
1451 user status will be placed into the C<FORCE_CHANGE_PASSWORD> state.
1452 When the user next tries to sign in, the InitiateAuth/AdminInitiateAuth
1453 response will contain the C<NEW_PASSWORD_REQUIRED> challenge. If the
1454 user does not sign in before it expires, the user will not be able to
1455 sign in and their password will need to be reset by an administrator.
1456  
1457 Once the user has set a new password, or the password is permanent, the
1458 user status will be set to C<Confirmed>.
1459  
1460  
1461 =head2 AdminSetUserSettings
1462  
1463 =over
1464  
1465 =item MFAOptions => ArrayRef[L<Paws::CognitoIdp::MFAOptionType>]
1466  
1467 =item Username => Str
1468  
1469 =item UserPoolId => Str
1470  
1471  
1472 =back
1473  
1474 Each argument is described in detail in: L<Paws::CognitoIdp::AdminSetUserSettings>
1475  
1476 Returns: a L<Paws::CognitoIdp::AdminSetUserSettingsResponse> instance
1477  
1478 I<This action is no longer supported.> You can use it to configure only
1479 SMS MFA. You can't use it to configure TOTP software token MFA. To
1480 configure either type of MFA, use AdminSetUserMFAPreference
1481 (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminSetUserMFAPreference.html)
1482 instead.
1483  
1484  
1485 =head2 AdminUpdateAuthEventFeedback
1486  
1487 =over
1488  
1489 =item EventId => Str
1490  
1491 =item FeedbackValue => Str
1492  
1493 =item Username => Str
1494  
1495 =item UserPoolId => Str
1496  
1497  
1498 =back
1499  
1500 Each argument is described in detail in: L<Paws::CognitoIdp::AdminUpdateAuthEventFeedback>
1501  
1502 Returns: a L<Paws::CognitoIdp::AdminUpdateAuthEventFeedbackResponse> instance
1503  
1504 Provides feedback for an authentication event as to whether it was from
1505 a valid user. This feedback is used for improving the risk evaluation
1506 decision for the user pool as part of Amazon Cognito advanced security.
1507  
1508  
1509 =head2 AdminUpdateDeviceStatus
1510  
1511 =over
1512  
1513 =item DeviceKey => Str
1514  
1515 =item Username => Str
1516  
1517 =item UserPoolId => Str
1518  
1519 =item [DeviceRememberedStatus => Str]
1520  
1521  
1522 =back
1523  
1524 Each argument is described in detail in: L<Paws::CognitoIdp::AdminUpdateDeviceStatus>
1525  
1526 Returns: a L<Paws::CognitoIdp::AdminUpdateDeviceStatusResponse> instance
1527  
1528 Updates the device status as an administrator.
1529  
1530 Calling this action requires developer credentials.
1531  
1532  
1533 =head2 AdminUpdateUserAttributes
1534  
1535 =over
1536  
1537 =item UserAttributes => ArrayRef[L<Paws::CognitoIdp::AttributeType>]
1538  
1539 =item Username => Str
1540  
1541 =item UserPoolId => Str
1542  
1543 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
1544  
1545  
1546 =back
1547  
1548 Each argument is described in detail in: L<Paws::CognitoIdp::AdminUpdateUserAttributes>
1549  
1550 Returns: a L<Paws::CognitoIdp::AdminUpdateUserAttributesResponse> instance
1551  
1552 Updates the specified user's attributes, including developer
1553 attributes, as an administrator. Works on any user.
1554  
1555 For custom attributes, you must prepend the C<custom:> prefix to the
1556 attribute name.
1557  
1558 In addition to updating user attributes, this API can also be used to
1559 mark phone and email as verified.
1560  
1561 This action might generate an SMS text message. Starting June 1, 2021,
1562 U.S. telecom carriers require that you register an origination phone
1563 number before you can send SMS messages to U.S. phone numbers. If you
1564 use SMS text messages in Amazon Cognito, you must register a phone
1565 number with Amazon Pinpoint
1566 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
1567 the registered number automatically. Otherwise, Cognito users that must
1568 receive SMS messages might be unable to sign up, activate their
1569 accounts, or sign in.
1570  
1571 If you have never used SMS text messages with Amazon Cognito or any
1572 other AWS service, Amazon SNS might place your account in SMS sandbox.
1573 In I< sandbox mode
1574 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
1575 youE<rsquo>ll have limitations, such as sending messages to only
1576 verified phone numbers. After testing in the sandbox environment, you
1577 can move out of the SMS sandbox and into production. For more
1578 information, see SMS message settings for Cognito User Pools
1579 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
1580 in the I<Amazon Cognito Developer Guide>.
1581  
1582 Calling this action requires developer credentials.
1583  
1584  
1585 =head2 AdminUserGlobalSignOut
1586  
1587 =over
1588  
1589 =item Username => Str
1590  
1591 =item UserPoolId => Str
1592  
1593  
1594 =back
1595  
1596 Each argument is described in detail in: L<Paws::CognitoIdp::AdminUserGlobalSignOut>
1597  
1598 Returns: a L<Paws::CognitoIdp::AdminUserGlobalSignOutResponse> instance
1599  
1600 Signs out users from all devices, as an administrator. It also
1601 invalidates all refresh tokens issued to a user. The user's current
1602 access and Id tokens remain valid until their expiry. Access and Id
1603 tokens expire one hour after they are issued.
1604  
1605 Calling this action requires developer credentials.
1606  
1607  
1608 =head2 AssociateSoftwareToken
1609  
1610 =over
1611  
1612 =item [AccessToken => Str]
1613  
1614 =item [Session => Str]
1615  
1616  
1617 =back
1618  
1619 Each argument is described in detail in: L<Paws::CognitoIdp::AssociateSoftwareToken>
1620  
1621 Returns: a L<Paws::CognitoIdp::AssociateSoftwareTokenResponse> instance
1622  
1623 Returns a unique generated shared secret key code for the user account.
1624 The request takes an access token or a session string, but not both.
1625  
1626 Calling AssociateSoftwareToken immediately disassociates the existing
1627 software token from the user account. If the user doesn't subsequently
1628 verify the software token, their account is essentially set up to
1629 authenticate without MFA. If MFA config is set to Optional at the user
1630 pool level, the user can then login without MFA. However, if MFA is set
1631 to Required for the user pool, the user will be asked to setup a new
1632 software token MFA during sign in.
1633  
1634  
1635 =head2 ChangePassword
1636  
1637 =over
1638  
1639 =item AccessToken => Str
1640  
1641 =item PreviousPassword => Str
1642  
1643 =item ProposedPassword => Str
1644  
1645  
1646 =back
1647  
1648 Each argument is described in detail in: L<Paws::CognitoIdp::ChangePassword>
1649  
1650 Returns: a L<Paws::CognitoIdp::ChangePasswordResponse> instance
1651  
1652 Changes the password for a specified user in a user pool.
1653  
1654  
1655 =head2 ConfirmDevice
1656  
1657 =over
1658  
1659 =item AccessToken => Str
1660  
1661 =item DeviceKey => Str
1662  
1663 =item [DeviceName => Str]
1664  
1665 =item [DeviceSecretVerifierConfig => L<Paws::CognitoIdp::DeviceSecretVerifierConfigType>]
1666  
1667  
1668 =back
1669  
1670 Each argument is described in detail in: L<Paws::CognitoIdp::ConfirmDevice>
1671  
1672 Returns: a L<Paws::CognitoIdp::ConfirmDeviceResponse> instance
1673  
1674 Confirms tracking of the device. This API call is the call that begins
1675 device tracking.
1676  
1677  
1678 =head2 ConfirmForgotPassword
1679  
1680 =over
1681  
1682 =item ClientId => Str
1683  
1684 =item ConfirmationCode => Str
1685  
1686 =item Password => Str
1687  
1688 =item Username => Str
1689  
1690 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
1691  
1692 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
1693  
1694 =item [SecretHash => Str]
1695  
1696 =item [UserContextData => L<Paws::CognitoIdp::UserContextDataType>]
1697  
1698  
1699 =back
1700  
1701 Each argument is described in detail in: L<Paws::CognitoIdp::ConfirmForgotPassword>
1702  
1703 Returns: a L<Paws::CognitoIdp::ConfirmForgotPasswordResponse> instance
1704  
1705 Allows a user to enter a confirmation code to reset a forgotten
1706 password.
1707  
1708  
1709 =head2 ConfirmSignUp
1710  
1711 =over
1712  
1713 =item ClientId => Str
1714  
1715 =item ConfirmationCode => Str
1716  
1717 =item Username => Str
1718  
1719 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
1720  
1721 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
1722  
1723 =item [ForceAliasCreation => Bool]
1724  
1725 =item [SecretHash => Str]
1726  
1727 =item [UserContextData => L<Paws::CognitoIdp::UserContextDataType>]
1728  
1729  
1730 =back
1731  
1732 Each argument is described in detail in: L<Paws::CognitoIdp::ConfirmSignUp>
1733  
1734 Returns: a L<Paws::CognitoIdp::ConfirmSignUpResponse> instance
1735  
1736 Confirms registration of a user and handles the existing alias from a
1737 previous user.
1738  
1739  
1740 =head2 CreateGroup
1741  
1742 =over
1743  
1744 =item GroupName => Str
1745  
1746 =item UserPoolId => Str
1747  
1748 =item [Description => Str]
1749  
1750 =item [Precedence => Int]
1751  
1752 =item [RoleArn => Str]
1753  
1754  
1755 =back
1756  
1757 Each argument is described in detail in: L<Paws::CognitoIdp::CreateGroup>
1758  
1759 Returns: a L<Paws::CognitoIdp::CreateGroupResponse> instance
1760  
1761 Creates a new group in the specified user pool.
1762  
1763 Calling this action requires developer credentials.
1764  
1765  
1766 =head2 CreateIdentityProvider
1767  
1768 =over
1769  
1770 =item ProviderDetails => L<Paws::CognitoIdp::ProviderDetailsType>
1771  
1772 =item ProviderName => Str
1773  
1774 =item ProviderType => Str
1775  
1776 =item UserPoolId => Str
1777  
1778 =item [AttributeMapping => L<Paws::CognitoIdp::AttributeMappingType>]
1779  
1780 =item [IdpIdentifiers => ArrayRef[Str|Undef]]
1781  
1782  
1783 =back
1784  
1785 Each argument is described in detail in: L<Paws::CognitoIdp::CreateIdentityProvider>
1786  
1787 Returns: a L<Paws::CognitoIdp::CreateIdentityProviderResponse> instance
1788  
1789 Creates an identity provider for a user pool.
1790  
1791  
1792 =head2 CreateResourceServer
1793  
1794 =over
1795  
1796 =item Identifier => Str
1797  
1798 =item Name => Str
1799  
1800 =item UserPoolId => Str
1801  
1802 =item [Scopes => ArrayRef[L<Paws::CognitoIdp::ResourceServerScopeType>]]
1803  
1804  
1805 =back
1806  
1807 Each argument is described in detail in: L<Paws::CognitoIdp::CreateResourceServer>
1808  
1809 Returns: a L<Paws::CognitoIdp::CreateResourceServerResponse> instance
1810  
1811 Creates a new OAuth2.0 resource server and defines custom scopes in it.
1812  
1813  
1814 =head2 CreateUserImportJob
1815  
1816 =over
1817  
1818 =item CloudWatchLogsRoleArn => Str
1819  
1820 =item JobName => Str
1821  
1822 =item UserPoolId => Str
1823  
1824  
1825 =back
1826  
1827 Each argument is described in detail in: L<Paws::CognitoIdp::CreateUserImportJob>
1828  
1829 Returns: a L<Paws::CognitoIdp::CreateUserImportJobResponse> instance
1830  
1831 Creates the user import job.
1832  
1833  
1834 =head2 CreateUserPool
1835  
1836 =over
1837  
1838 =item PoolName => Str
1839  
1840 =item [AccountRecoverySetting => L<Paws::CognitoIdp::AccountRecoverySettingType>]
1841  
1842 =item [AdminCreateUserConfig => L<Paws::CognitoIdp::AdminCreateUserConfigType>]
1843  
1844 =item [AliasAttributes => ArrayRef[Str|Undef]]
1845  
1846 =item [AutoVerifiedAttributes => ArrayRef[Str|Undef]]
1847  
1848 =item [DeviceConfiguration => L<Paws::CognitoIdp::DeviceConfigurationType>]
1849  
1850 =item [EmailConfiguration => L<Paws::CognitoIdp::EmailConfigurationType>]
1851  
1852 =item [EmailVerificationMessage => Str]
1853  
1854 =item [EmailVerificationSubject => Str]
1855  
1856 =item [LambdaConfig => L<Paws::CognitoIdp::LambdaConfigType>]
1857  
1858 =item [MfaConfiguration => Str]
1859  
1860 =item [Policies => L<Paws::CognitoIdp::UserPoolPolicyType>]
1861  
1862 =item [Schema => ArrayRef[L<Paws::CognitoIdp::SchemaAttributeType>]]
1863  
1864 =item [SmsAuthenticationMessage => Str]
1865  
1866 =item [SmsConfiguration => L<Paws::CognitoIdp::SmsConfigurationType>]
1867  
1868 =item [SmsVerificationMessage => Str]
1869  
1870 =item [UsernameAttributes => ArrayRef[Str|Undef]]
1871  
1872 =item [UsernameConfiguration => L<Paws::CognitoIdp::UsernameConfigurationType>]
1873  
1874 =item [UserPoolAddOns => L<Paws::CognitoIdp::UserPoolAddOnsType>]
1875  
1876 =item [UserPoolTags => L<Paws::CognitoIdp::UserPoolTagsType>]
1877  
1878 =item [VerificationMessageTemplate => L<Paws::CognitoIdp::VerificationMessageTemplateType>]
1879  
1880  
1881 =back
1882  
1883 Each argument is described in detail in: L<Paws::CognitoIdp::CreateUserPool>
1884  
1885 Returns: a L<Paws::CognitoIdp::CreateUserPoolResponse> instance
1886  
1887 Creates a new Amazon Cognito user pool and sets the password policy for
1888 the pool.
1889  
1890 This action might generate an SMS text message. Starting June 1, 2021,
1891 U.S. telecom carriers require that you register an origination phone
1892 number before you can send SMS messages to U.S. phone numbers. If you
1893 use SMS text messages in Amazon Cognito, you must register a phone
1894 number with Amazon Pinpoint
1895 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
1896 the registered number automatically. Otherwise, Cognito users that must
1897 receive SMS messages might be unable to sign up, activate their
1898 accounts, or sign in.
1899  
1900 If you have never used SMS text messages with Amazon Cognito or any
1901 other AWS service, Amazon SNS might place your account in SMS sandbox.
1902 In I< sandbox mode
1903 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
1904 youE<rsquo>ll have limitations, such as sending messages to only
1905 verified phone numbers. After testing in the sandbox environment, you
1906 can move out of the SMS sandbox and into production. For more
1907 information, see SMS message settings for Cognito User Pools
1908 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
1909 in the I<Amazon Cognito Developer Guide>.
1910  
1911  
1912 =head2 CreateUserPoolClient
1913  
1914 =over
1915  
1916 =item ClientName => Str
1917  
1918 =item UserPoolId => Str
1919  
1920 =item [AccessTokenValidity => Int]
1921  
1922 =item [AllowedOAuthFlows => ArrayRef[Str|Undef]]
1923  
1924 =item [AllowedOAuthFlowsUserPoolClient => Bool]
1925  
1926 =item [AllowedOAuthScopes => ArrayRef[Str|Undef]]
1927  
1928 =item [AnalyticsConfiguration => L<Paws::CognitoIdp::AnalyticsConfigurationType>]
1929  
1930 =item [CallbackURLs => ArrayRef[Str|Undef]]
1931  
1932 =item [DefaultRedirectURI => Str]
1933  
1934 =item [EnableTokenRevocation => Bool]
1935  
1936 =item [ExplicitAuthFlows => ArrayRef[Str|Undef]]
1937  
1938 =item [GenerateSecret => Bool]
1939  
1940 =item [IdTokenValidity => Int]
1941  
1942 =item [LogoutURLs => ArrayRef[Str|Undef]]
1943  
1944 =item [PreventUserExistenceErrors => Str]
1945  
1946 =item [ReadAttributes => ArrayRef[Str|Undef]]
1947  
1948 =item [RefreshTokenValidity => Int]
1949  
1950 =item [SupportedIdentityProviders => ArrayRef[Str|Undef]]
1951  
1952 =item [TokenValidityUnits => L<Paws::CognitoIdp::TokenValidityUnitsType>]
1953  
1954 =item [WriteAttributes => ArrayRef[Str|Undef]]
1955  
1956  
1957 =back
1958  
1959 Each argument is described in detail in: L<Paws::CognitoIdp::CreateUserPoolClient>
1960  
1961 Returns: a L<Paws::CognitoIdp::CreateUserPoolClientResponse> instance
1962  
1963 Creates the user pool client.
1964  
1965 When you create a new user pool client, token revocation is
1966 automatically enabled. For more information about revoking tokens, see
1967 RevokeToken
1968 (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RevokeToken.html).
1969  
1970  
1971 =head2 CreateUserPoolDomain
1972  
1973 =over
1974  
1975 =item Domain => Str
1976  
1977 =item UserPoolId => Str
1978  
1979 =item [CustomDomainConfig => L<Paws::CognitoIdp::CustomDomainConfigType>]
1980  
1981  
1982 =back
1983  
1984 Each argument is described in detail in: L<Paws::CognitoIdp::CreateUserPoolDomain>
1985  
1986 Returns: a L<Paws::CognitoIdp::CreateUserPoolDomainResponse> instance
1987  
1988 Creates a new domain for a user pool.
1989  
1990  
1991 =head2 DeleteGroup
1992  
1993 =over
1994  
1995 =item GroupName => Str
1996  
1997 =item UserPoolId => Str
1998  
1999  
2000 =back
2001  
2002 Each argument is described in detail in: L<Paws::CognitoIdp::DeleteGroup>
2003  
2004 Returns: nothing
2005  
2006 Deletes a group.
2007  
2008 Calling this action requires developer credentials.
2009  
2010  
2011 =head2 DeleteIdentityProvider
2012  
2013 =over
2014  
2015 =item ProviderName => Str
2016  
2017 =item UserPoolId => Str
2018  
2019  
2020 =back
2021  
2022 Each argument is described in detail in: L<Paws::CognitoIdp::DeleteIdentityProvider>
2023  
2024 Returns: nothing
2025  
2026 Deletes an identity provider for a user pool.
2027  
2028  
2029 =head2 DeleteResourceServer
2030  
2031 =over
2032  
2033 =item Identifier => Str
2034  
2035 =item UserPoolId => Str
2036  
2037  
2038 =back
2039  
2040 Each argument is described in detail in: L<Paws::CognitoIdp::DeleteResourceServer>
2041  
2042 Returns: nothing
2043  
2044 Deletes a resource server.
2045  
2046  
2047 =head2 DeleteUser
2048  
2049 =over
2050  
2051 =item AccessToken => Str
2052  
2053  
2054 =back
2055  
2056 Each argument is described in detail in: L<Paws::CognitoIdp::DeleteUser>
2057  
2058 Returns: nothing
2059  
2060 Allows a user to delete himself or herself.
2061  
2062  
2063 =head2 DeleteUserAttributes
2064  
2065 =over
2066  
2067 =item AccessToken => Str
2068  
2069 =item UserAttributeNames => ArrayRef[Str|Undef]
2070  
2071  
2072 =back
2073  
2074 Each argument is described in detail in: L<Paws::CognitoIdp::DeleteUserAttributes>
2075  
2076 Returns: a L<Paws::CognitoIdp::DeleteUserAttributesResponse> instance
2077  
2078 Deletes the attributes for a user.
2079  
2080  
2081 =head2 DeleteUserPool
2082  
2083 =over
2084  
2085 =item UserPoolId => Str
2086  
2087  
2088 =back
2089  
2090 Each argument is described in detail in: L<Paws::CognitoIdp::DeleteUserPool>
2091  
2092 Returns: nothing
2093  
2094 Deletes the specified Amazon Cognito user pool.
2095  
2096  
2097 =head2 DeleteUserPoolClient
2098  
2099 =over
2100  
2101 =item ClientId => Str
2102  
2103 =item UserPoolId => Str
2104  
2105  
2106 =back
2107  
2108 Each argument is described in detail in: L<Paws::CognitoIdp::DeleteUserPoolClient>
2109  
2110 Returns: nothing
2111  
2112 Allows the developer to delete the user pool client.
2113  
2114  
2115 =head2 DeleteUserPoolDomain
2116  
2117 =over
2118  
2119 =item Domain => Str
2120  
2121 =item UserPoolId => Str
2122  
2123  
2124 =back
2125  
2126 Each argument is described in detail in: L<Paws::CognitoIdp::DeleteUserPoolDomain>
2127  
2128 Returns: a L<Paws::CognitoIdp::DeleteUserPoolDomainResponse> instance
2129  
2130 Deletes a domain for a user pool.
2131  
2132  
2133 =head2 DescribeIdentityProvider
2134  
2135 =over
2136  
2137 =item ProviderName => Str
2138  
2139 =item UserPoolId => Str
2140  
2141  
2142 =back
2143  
2144 Each argument is described in detail in: L<Paws::CognitoIdp::DescribeIdentityProvider>
2145  
2146 Returns: a L<Paws::CognitoIdp::DescribeIdentityProviderResponse> instance
2147  
2148 Gets information about a specific identity provider.
2149  
2150  
2151 =head2 DescribeResourceServer
2152  
2153 =over
2154  
2155 =item Identifier => Str
2156  
2157 =item UserPoolId => Str
2158  
2159  
2160 =back
2161  
2162 Each argument is described in detail in: L<Paws::CognitoIdp::DescribeResourceServer>
2163  
2164 Returns: a L<Paws::CognitoIdp::DescribeResourceServerResponse> instance
2165  
2166 Describes a resource server.
2167  
2168  
2169 =head2 DescribeRiskConfiguration
2170  
2171 =over
2172  
2173 =item UserPoolId => Str
2174  
2175 =item [ClientId => Str]
2176  
2177  
2178 =back
2179  
2180 Each argument is described in detail in: L<Paws::CognitoIdp::DescribeRiskConfiguration>
2181  
2182 Returns: a L<Paws::CognitoIdp::DescribeRiskConfigurationResponse> instance
2183  
2184 Describes the risk configuration.
2185  
2186  
2187 =head2 DescribeUserImportJob
2188  
2189 =over
2190  
2191 =item JobId => Str
2192  
2193 =item UserPoolId => Str
2194  
2195  
2196 =back
2197  
2198 Each argument is described in detail in: L<Paws::CognitoIdp::DescribeUserImportJob>
2199  
2200 Returns: a L<Paws::CognitoIdp::DescribeUserImportJobResponse> instance
2201  
2202 Describes the user import job.
2203  
2204  
2205 =head2 DescribeUserPool
2206  
2207 =over
2208  
2209 =item UserPoolId => Str
2210  
2211  
2212 =back
2213  
2214 Each argument is described in detail in: L<Paws::CognitoIdp::DescribeUserPool>
2215  
2216 Returns: a L<Paws::CognitoIdp::DescribeUserPoolResponse> instance
2217  
2218 Returns the configuration information and metadata of the specified
2219 user pool.
2220  
2221  
2222 =head2 DescribeUserPoolClient
2223  
2224 =over
2225  
2226 =item ClientId => Str
2227  
2228 =item UserPoolId => Str
2229  
2230  
2231 =back
2232  
2233 Each argument is described in detail in: L<Paws::CognitoIdp::DescribeUserPoolClient>
2234  
2235 Returns: a L<Paws::CognitoIdp::DescribeUserPoolClientResponse> instance
2236  
2237 Client method for returning the configuration information and metadata
2238 of the specified user pool app client.
2239  
2240  
2241 =head2 DescribeUserPoolDomain
2242  
2243 =over
2244  
2245 =item Domain => Str
2246  
2247  
2248 =back
2249  
2250 Each argument is described in detail in: L<Paws::CognitoIdp::DescribeUserPoolDomain>
2251  
2252 Returns: a L<Paws::CognitoIdp::DescribeUserPoolDomainResponse> instance
2253  
2254 Gets information about a domain.
2255  
2256  
2257 =head2 ForgetDevice
2258  
2259 =over
2260  
2261 =item DeviceKey => Str
2262  
2263 =item [AccessToken => Str]
2264  
2265  
2266 =back
2267  
2268 Each argument is described in detail in: L<Paws::CognitoIdp::ForgetDevice>
2269  
2270 Returns: nothing
2271  
2272 Forgets the specified device.
2273  
2274  
2275 =head2 ForgotPassword
2276  
2277 =over
2278  
2279 =item ClientId => Str
2280  
2281 =item Username => Str
2282  
2283 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
2284  
2285 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
2286  
2287 =item [SecretHash => Str]
2288  
2289 =item [UserContextData => L<Paws::CognitoIdp::UserContextDataType>]
2290  
2291  
2292 =back
2293  
2294 Each argument is described in detail in: L<Paws::CognitoIdp::ForgotPassword>
2295  
2296 Returns: a L<Paws::CognitoIdp::ForgotPasswordResponse> instance
2297  
2298 Calling this API causes a message to be sent to the end user with a
2299 confirmation code that is required to change the user's password. For
2300 the C<Username> parameter, you can use the username or user alias. The
2301 method used to send the confirmation code is sent according to the
2302 specified AccountRecoverySetting. For more information, see Recovering
2303 User Accounts
2304 (https://docs.aws.amazon.com/cognito/latest/developerguide/how-to-recover-a-user-account.html)
2305 in the I<Amazon Cognito Developer Guide>. If neither a verified phone
2306 number nor a verified email exists, an C<InvalidParameterException> is
2307 thrown. To use the confirmation code for resetting the password, call
2308 ConfirmForgotPassword
2309 (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_ConfirmForgotPassword.html).
2310  
2311 This action might generate an SMS text message. Starting June 1, 2021,
2312 U.S. telecom carriers require that you register an origination phone
2313 number before you can send SMS messages to U.S. phone numbers. If you
2314 use SMS text messages in Amazon Cognito, you must register a phone
2315 number with Amazon Pinpoint
2316 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
2317 the registered number automatically. Otherwise, Cognito users that must
2318 receive SMS messages might be unable to sign up, activate their
2319 accounts, or sign in.
2320  
2321 If you have never used SMS text messages with Amazon Cognito or any
2322 other AWS service, Amazon SNS might place your account in SMS sandbox.
2323 In I< sandbox mode
2324 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
2325 youE<rsquo>ll have limitations, such as sending messages to only
2326 verified phone numbers. After testing in the sandbox environment, you
2327 can move out of the SMS sandbox and into production. For more
2328 information, see SMS message settings for Cognito User Pools
2329 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
2330 in the I<Amazon Cognito Developer Guide>.
2331  
2332  
2333 =head2 GetCSVHeader
2334  
2335 =over
2336  
2337 =item UserPoolId => Str
2338  
2339  
2340 =back
2341  
2342 Each argument is described in detail in: L<Paws::CognitoIdp::GetCSVHeader>
2343  
2344 Returns: a L<Paws::CognitoIdp::GetCSVHeaderResponse> instance
2345  
2346 Gets the header information for the .csv file to be used as input for
2347 the user import job.
2348  
2349  
2350 =head2 GetDevice
2351  
2352 =over
2353  
2354 =item DeviceKey => Str
2355  
2356 =item [AccessToken => Str]
2357  
2358  
2359 =back
2360  
2361 Each argument is described in detail in: L<Paws::CognitoIdp::GetDevice>
2362  
2363 Returns: a L<Paws::CognitoIdp::GetDeviceResponse> instance
2364  
2365 Gets the device.
2366  
2367  
2368 =head2 GetGroup
2369  
2370 =over
2371  
2372 =item GroupName => Str
2373  
2374 =item UserPoolId => Str
2375  
2376  
2377 =back
2378  
2379 Each argument is described in detail in: L<Paws::CognitoIdp::GetGroup>
2380  
2381 Returns: a L<Paws::CognitoIdp::GetGroupResponse> instance
2382  
2383 Gets a group.
2384  
2385 Calling this action requires developer credentials.
2386  
2387  
2388 =head2 GetIdentityProviderByIdentifier
2389  
2390 =over
2391  
2392 =item IdpIdentifier => Str
2393  
2394 =item UserPoolId => Str
2395  
2396  
2397 =back
2398  
2399 Each argument is described in detail in: L<Paws::CognitoIdp::GetIdentityProviderByIdentifier>
2400  
2401 Returns: a L<Paws::CognitoIdp::GetIdentityProviderByIdentifierResponse> instance
2402  
2403 Gets the specified identity provider.
2404  
2405  
2406 =head2 GetSigningCertificate
2407  
2408 =over
2409  
2410 =item UserPoolId => Str
2411  
2412  
2413 =back
2414  
2415 Each argument is described in detail in: L<Paws::CognitoIdp::GetSigningCertificate>
2416  
2417 Returns: a L<Paws::CognitoIdp::GetSigningCertificateResponse> instance
2418  
2419 This method takes a user pool ID, and returns the signing certificate.
2420  
2421  
2422 =head2 GetUICustomization
2423  
2424 =over
2425  
2426 =item UserPoolId => Str
2427  
2428 =item [ClientId => Str]
2429  
2430  
2431 =back
2432  
2433 Each argument is described in detail in: L<Paws::CognitoIdp::GetUICustomization>
2434  
2435 Returns: a L<Paws::CognitoIdp::GetUICustomizationResponse> instance
2436  
2437 Gets the UI Customization information for a particular app client's app
2438 UI, if there is something set. If nothing is set for the particular
2439 client, but there is an existing pool level customization (app
2440 C<clientId> will be C<ALL>), then that is returned. If nothing is
2441 present, then an empty shape is returned.
2442  
2443  
2444 =head2 GetUser
2445  
2446 =over
2447  
2448 =item AccessToken => Str
2449  
2450  
2451 =back
2452  
2453 Each argument is described in detail in: L<Paws::CognitoIdp::GetUser>
2454  
2455 Returns: a L<Paws::CognitoIdp::GetUserResponse> instance
2456  
2457 Gets the user attributes and metadata for a user.
2458  
2459  
2460 =head2 GetUserAttributeVerificationCode
2461  
2462 =over
2463  
2464 =item AccessToken => Str
2465  
2466 =item AttributeName => Str
2467  
2468 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
2469  
2470  
2471 =back
2472  
2473 Each argument is described in detail in: L<Paws::CognitoIdp::GetUserAttributeVerificationCode>
2474  
2475 Returns: a L<Paws::CognitoIdp::GetUserAttributeVerificationCodeResponse> instance
2476  
2477 Gets the user attribute verification code for the specified attribute
2478 name.
2479  
2480 This action might generate an SMS text message. Starting June 1, 2021,
2481 U.S. telecom carriers require that you register an origination phone
2482 number before you can send SMS messages to U.S. phone numbers. If you
2483 use SMS text messages in Amazon Cognito, you must register a phone
2484 number with Amazon Pinpoint
2485 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
2486 the registered number automatically. Otherwise, Cognito users that must
2487 receive SMS messages might be unable to sign up, activate their
2488 accounts, or sign in.
2489  
2490 If you have never used SMS text messages with Amazon Cognito or any
2491 other AWS service, Amazon SNS might place your account in SMS sandbox.
2492 In I< sandbox mode
2493 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
2494 youE<rsquo>ll have limitations, such as sending messages to only
2495 verified phone numbers. After testing in the sandbox environment, you
2496 can move out of the SMS sandbox and into production. For more
2497 information, see SMS message settings for Cognito User Pools
2498 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
2499 in the I<Amazon Cognito Developer Guide>.
2500  
2501  
2502 =head2 GetUserPoolMfaConfig
2503  
2504 =over
2505  
2506 =item UserPoolId => Str
2507  
2508  
2509 =back
2510  
2511 Each argument is described in detail in: L<Paws::CognitoIdp::GetUserPoolMfaConfig>
2512  
2513 Returns: a L<Paws::CognitoIdp::GetUserPoolMfaConfigResponse> instance
2514  
2515 Gets the user pool multi-factor authentication (MFA) configuration.
2516  
2517  
2518 =head2 GlobalSignOut
2519  
2520 =over
2521  
2522 =item AccessToken => Str
2523  
2524  
2525 =back
2526  
2527 Each argument is described in detail in: L<Paws::CognitoIdp::GlobalSignOut>
2528  
2529 Returns: a L<Paws::CognitoIdp::GlobalSignOutResponse> instance
2530  
2531 Signs out users from all devices. It also invalidates all refresh
2532 tokens issued to a user. The user's current access and Id tokens remain
2533 valid until their expiry. Access and Id tokens expire one hour after
2534 they are issued.
2535  
2536  
2537 =head2 InitiateAuth
2538  
2539 =over
2540  
2541 =item AuthFlow => Str
2542  
2543 =item ClientId => Str
2544  
2545 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
2546  
2547 =item [AuthParameters => L<Paws::CognitoIdp::AuthParametersType>]
2548  
2549 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
2550  
2551 =item [UserContextData => L<Paws::CognitoIdp::UserContextDataType>]
2552  
2553  
2554 =back
2555  
2556 Each argument is described in detail in: L<Paws::CognitoIdp::InitiateAuth>
2557  
2558 Returns: a L<Paws::CognitoIdp::InitiateAuthResponse> instance
2559  
2560 Initiates the authentication flow.
2561  
2562 This action might generate an SMS text message. Starting June 1, 2021,
2563 U.S. telecom carriers require that you register an origination phone
2564 number before you can send SMS messages to U.S. phone numbers. If you
2565 use SMS text messages in Amazon Cognito, you must register a phone
2566 number with Amazon Pinpoint
2567 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
2568 the registered number automatically. Otherwise, Cognito users that must
2569 receive SMS messages might be unable to sign up, activate their
2570 accounts, or sign in.
2571  
2572 If you have never used SMS text messages with Amazon Cognito or any
2573 other AWS service, Amazon SNS might place your account in SMS sandbox.
2574 In I< sandbox mode
2575 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
2576 youE<rsquo>ll have limitations, such as sending messages to only
2577 verified phone numbers. After testing in the sandbox environment, you
2578 can move out of the SMS sandbox and into production. For more
2579 information, see SMS message settings for Cognito User Pools
2580 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
2581 in the I<Amazon Cognito Developer Guide>.
2582  
2583  
2584 =head2 ListDevices
2585  
2586 =over
2587  
2588 =item AccessToken => Str
2589  
2590 =item [Limit => Int]
2591  
2592 =item [PaginationToken => Str]
2593  
2594  
2595 =back
2596  
2597 Each argument is described in detail in: L<Paws::CognitoIdp::ListDevices>
2598  
2599 Returns: a L<Paws::CognitoIdp::ListDevicesResponse> instance
2600  
2601 Lists the devices.
2602  
2603  
2604 =head2 ListGroups
2605  
2606 =over
2607  
2608 =item UserPoolId => Str
2609  
2610 =item [Limit => Int]
2611  
2612 =item [NextToken => Str]
2613  
2614  
2615 =back
2616  
2617 Each argument is described in detail in: L<Paws::CognitoIdp::ListGroups>
2618  
2619 Returns: a L<Paws::CognitoIdp::ListGroupsResponse> instance
2620  
2621 Lists the groups associated with a user pool.
2622  
2623 Calling this action requires developer credentials.
2624  
2625  
2626 =head2 ListIdentityProviders
2627  
2628 =over
2629  
2630 =item UserPoolId => Str
2631  
2632 =item [MaxResults => Int]
2633  
2634 =item [NextToken => Str]
2635  
2636  
2637 =back
2638  
2639 Each argument is described in detail in: L<Paws::CognitoIdp::ListIdentityProviders>
2640  
2641 Returns: a L<Paws::CognitoIdp::ListIdentityProvidersResponse> instance
2642  
2643 Lists information about all identity providers for a user pool.
2644  
2645  
2646 =head2 ListResourceServers
2647  
2648 =over
2649  
2650 =item UserPoolId => Str
2651  
2652 =item [MaxResults => Int]
2653  
2654 =item [NextToken => Str]
2655  
2656  
2657 =back
2658  
2659 Each argument is described in detail in: L<Paws::CognitoIdp::ListResourceServers>
2660  
2661 Returns: a L<Paws::CognitoIdp::ListResourceServersResponse> instance
2662  
2663 Lists the resource servers for a user pool.
2664  
2665  
2666 =head2 ListTagsForResource
2667  
2668 =over
2669  
2670 =item ResourceArn => Str
2671  
2672  
2673 =back
2674  
2675 Each argument is described in detail in: L<Paws::CognitoIdp::ListTagsForResource>
2676  
2677 Returns: a L<Paws::CognitoIdp::ListTagsForResourceResponse> instance
2678  
2679 Lists the tags that are assigned to an Amazon Cognito user pool.
2680  
2681 A tag is a label that you can apply to user pools to categorize and
2682 manage them in different ways, such as by purpose, owner, environment,
2683 or other criteria.
2684  
2685 You can use this action up to 10 times per second, per account.
2686  
2687  
2688 =head2 ListUserImportJobs
2689  
2690 =over
2691  
2692 =item MaxResults => Int
2693  
2694 =item UserPoolId => Str
2695  
2696 =item [PaginationToken => Str]
2697  
2698  
2699 =back
2700  
2701 Each argument is described in detail in: L<Paws::CognitoIdp::ListUserImportJobs>
2702  
2703 Returns: a L<Paws::CognitoIdp::ListUserImportJobsResponse> instance
2704  
2705 Lists the user import jobs.
2706  
2707  
2708 =head2 ListUserPoolClients
2709  
2710 =over
2711  
2712 =item UserPoolId => Str
2713  
2714 =item [MaxResults => Int]
2715  
2716 =item [NextToken => Str]
2717  
2718  
2719 =back
2720  
2721 Each argument is described in detail in: L<Paws::CognitoIdp::ListUserPoolClients>
2722  
2723 Returns: a L<Paws::CognitoIdp::ListUserPoolClientsResponse> instance
2724  
2725 Lists the clients that have been created for the specified user pool.
2726  
2727  
2728 =head2 ListUserPools
2729  
2730 =over
2731  
2732 =item MaxResults => Int
2733  
2734 =item [NextToken => Str]
2735  
2736  
2737 =back
2738  
2739 Each argument is described in detail in: L<Paws::CognitoIdp::ListUserPools>
2740  
2741 Returns: a L<Paws::CognitoIdp::ListUserPoolsResponse> instance
2742  
2743 Lists the user pools associated with an AWS account.
2744  
2745  
2746 =head2 ListUsers
2747  
2748 =over
2749  
2750 =item UserPoolId => Str
2751  
2752 =item [AttributesToGet => ArrayRef[Str|Undef]]
2753  
2754 =item [Filter => Str]
2755  
2756 =item [Limit => Int]
2757  
2758 =item [PaginationToken => Str]
2759  
2760  
2761 =back
2762  
2763 Each argument is described in detail in: L<Paws::CognitoIdp::ListUsers>
2764  
2765 Returns: a L<Paws::CognitoIdp::ListUsersResponse> instance
2766  
2767 Lists the users in the Amazon Cognito user pool.
2768  
2769  
2770 =head2 ListUsersInGroup
2771  
2772 =over
2773  
2774 =item GroupName => Str
2775  
2776 =item UserPoolId => Str
2777  
2778 =item [Limit => Int]
2779  
2780 =item [NextToken => Str]
2781  
2782  
2783 =back
2784  
2785 Each argument is described in detail in: L<Paws::CognitoIdp::ListUsersInGroup>
2786  
2787 Returns: a L<Paws::CognitoIdp::ListUsersInGroupResponse> instance
2788  
2789 Lists the users in the specified group.
2790  
2791 Calling this action requires developer credentials.
2792  
2793  
2794 =head2 ResendConfirmationCode
2795  
2796 =over
2797  
2798 =item ClientId => Str
2799  
2800 =item Username => Str
2801  
2802 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
2803  
2804 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
2805  
2806 =item [SecretHash => Str]
2807  
2808 =item [UserContextData => L<Paws::CognitoIdp::UserContextDataType>]
2809  
2810  
2811 =back
2812  
2813 Each argument is described in detail in: L<Paws::CognitoIdp::ResendConfirmationCode>
2814  
2815 Returns: a L<Paws::CognitoIdp::ResendConfirmationCodeResponse> instance
2816  
2817 Resends the confirmation (for confirmation of registration) to a
2818 specific user in the user pool.
2819  
2820 This action might generate an SMS text message. Starting June 1, 2021,
2821 U.S. telecom carriers require that you register an origination phone
2822 number before you can send SMS messages to U.S. phone numbers. If you
2823 use SMS text messages in Amazon Cognito, you must register a phone
2824 number with Amazon Pinpoint
2825 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
2826 the registered number automatically. Otherwise, Cognito users that must
2827 receive SMS messages might be unable to sign up, activate their
2828 accounts, or sign in.
2829  
2830 If you have never used SMS text messages with Amazon Cognito or any
2831 other AWS service, Amazon SNS might place your account in SMS sandbox.
2832 In I< sandbox mode
2833 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
2834 youE<rsquo>ll have limitations, such as sending messages to only
2835 verified phone numbers. After testing in the sandbox environment, you
2836 can move out of the SMS sandbox and into production. For more
2837 information, see SMS message settings for Cognito User Pools
2838 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
2839 in the I<Amazon Cognito Developer Guide>.
2840  
2841  
2842 =head2 RespondToAuthChallenge
2843  
2844 =over
2845  
2846 =item ChallengeName => Str
2847  
2848 =item ClientId => Str
2849  
2850 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
2851  
2852 =item [ChallengeResponses => L<Paws::CognitoIdp::ChallengeResponsesType>]
2853  
2854 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
2855  
2856 =item [Session => Str]
2857  
2858 =item [UserContextData => L<Paws::CognitoIdp::UserContextDataType>]
2859  
2860  
2861 =back
2862  
2863 Each argument is described in detail in: L<Paws::CognitoIdp::RespondToAuthChallenge>
2864  
2865 Returns: a L<Paws::CognitoIdp::RespondToAuthChallengeResponse> instance
2866  
2867 Responds to the authentication challenge.
2868  
2869 This action might generate an SMS text message. Starting June 1, 2021,
2870 U.S. telecom carriers require that you register an origination phone
2871 number before you can send SMS messages to U.S. phone numbers. If you
2872 use SMS text messages in Amazon Cognito, you must register a phone
2873 number with Amazon Pinpoint
2874 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
2875 the registered number automatically. Otherwise, Cognito users that must
2876 receive SMS messages might be unable to sign up, activate their
2877 accounts, or sign in.
2878  
2879 If you have never used SMS text messages with Amazon Cognito or any
2880 other AWS service, Amazon SNS might place your account in SMS sandbox.
2881 In I< sandbox mode
2882 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
2883 youE<rsquo>ll have limitations, such as sending messages to only
2884 verified phone numbers. After testing in the sandbox environment, you
2885 can move out of the SMS sandbox and into production. For more
2886 information, see SMS message settings for Cognito User Pools
2887 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
2888 in the I<Amazon Cognito Developer Guide>.
2889  
2890  
2891 =head2 RevokeToken
2892  
2893 =over
2894  
2895 =item ClientId => Str
2896  
2897 =item Token => Str
2898  
2899 =item [ClientSecret => Str]
2900  
2901  
2902 =back
2903  
2904 Each argument is described in detail in: L<Paws::CognitoIdp::RevokeToken>
2905  
2906 Returns: a L<Paws::CognitoIdp::RevokeTokenResponse> instance
2907  
2908 Revokes all of the access tokens generated by the specified refresh
2909 token. After the token is revoked, you can not use the revoked token to
2910 access Cognito authenticated APIs.
2911  
2912  
2913 =head2 SetRiskConfiguration
2914  
2915 =over
2916  
2917 =item UserPoolId => Str
2918  
2919 =item [AccountTakeoverRiskConfiguration => L<Paws::CognitoIdp::AccountTakeoverRiskConfigurationType>]
2920  
2921 =item [ClientId => Str]
2922  
2923 =item [CompromisedCredentialsRiskConfiguration => L<Paws::CognitoIdp::CompromisedCredentialsRiskConfigurationType>]
2924  
2925 =item [RiskExceptionConfiguration => L<Paws::CognitoIdp::RiskExceptionConfigurationType>]
2926  
2927  
2928 =back
2929  
2930 Each argument is described in detail in: L<Paws::CognitoIdp::SetRiskConfiguration>
2931  
2932 Returns: a L<Paws::CognitoIdp::SetRiskConfigurationResponse> instance
2933  
2934 Configures actions on detected risks. To delete the risk configuration
2935 for C<UserPoolId> or C<ClientId>, pass null values for all four
2936 configuration types.
2937  
2938 To enable Amazon Cognito advanced security features, update the user
2939 pool to include the C<UserPoolAddOns> keyC<AdvancedSecurityMode>.
2940  
2941  
2942 =head2 SetUICustomization
2943  
2944 =over
2945  
2946 =item UserPoolId => Str
2947  
2948 =item [ClientId => Str]
2949  
2950 =item [CSS => Str]
2951  
2952 =item [ImageFile => Str]
2953  
2954  
2955 =back
2956  
2957 Each argument is described in detail in: L<Paws::CognitoIdp::SetUICustomization>
2958  
2959 Returns: a L<Paws::CognitoIdp::SetUICustomizationResponse> instance
2960  
2961 Sets the UI customization information for a user pool's built-in app
2962 UI.
2963  
2964 You can specify app UI customization settings for a single client (with
2965 a specific C<clientId>) or for all clients (by setting the C<clientId>
2966 to C<ALL>). If you specify C<ALL>, the default configuration will be
2967 used for every client that has no UI customization set previously. If
2968 you specify UI customization settings for a particular client, it will
2969 no longer fall back to the C<ALL> configuration.
2970  
2971 To use this API, your user pool must have a domain associated with it.
2972 Otherwise, there is no place to host the app's pages, and the service
2973 will throw an error.
2974  
2975  
2976 =head2 SetUserMFAPreference
2977  
2978 =over
2979  
2980 =item AccessToken => Str
2981  
2982 =item [SMSMfaSettings => L<Paws::CognitoIdp::SMSMfaSettingsType>]
2983  
2984 =item [SoftwareTokenMfaSettings => L<Paws::CognitoIdp::SoftwareTokenMfaSettingsType>]
2985  
2986  
2987 =back
2988  
2989 Each argument is described in detail in: L<Paws::CognitoIdp::SetUserMFAPreference>
2990  
2991 Returns: a L<Paws::CognitoIdp::SetUserMFAPreferenceResponse> instance
2992  
2993 Set the user's multi-factor authentication (MFA) method preference,
2994 including which MFA factors are enabled and if any are preferred. Only
2995 one factor can be set as preferred. The preferred MFA factor will be
2996 used to authenticate a user if multiple factors are enabled. If
2997 multiple options are enabled and no preference is set, a challenge to
2998 choose an MFA option will be returned during sign in. If an MFA type is
2999 enabled for a user, the user will be prompted for MFA during all sign
3000 in attempts, unless device tracking is turned on and the device has
3001 been trusted. If you would like MFA to be applied selectively based on
3002 the assessed risk level of sign in attempts, disable MFA for users and
3003 turn on Adaptive Authentication for the user pool.
3004  
3005  
3006 =head2 SetUserPoolMfaConfig
3007  
3008 =over
3009  
3010 =item UserPoolId => Str
3011  
3012 =item [MfaConfiguration => Str]
3013  
3014 =item [SmsMfaConfiguration => L<Paws::CognitoIdp::SmsMfaConfigType>]
3015  
3016 =item [SoftwareTokenMfaConfiguration => L<Paws::CognitoIdp::SoftwareTokenMfaConfigType>]
3017  
3018  
3019 =back
3020  
3021 Each argument is described in detail in: L<Paws::CognitoIdp::SetUserPoolMfaConfig>
3022  
3023 Returns: a L<Paws::CognitoIdp::SetUserPoolMfaConfigResponse> instance
3024  
3025 Set the user pool multi-factor authentication (MFA) configuration.
3026  
3027 This action might generate an SMS text message. Starting June 1, 2021,
3028 U.S. telecom carriers require that you register an origination phone
3029 number before you can send SMS messages to U.S. phone numbers. If you
3030 use SMS text messages in Amazon Cognito, you must register a phone
3031 number with Amazon Pinpoint
3032 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
3033 the registered number automatically. Otherwise, Cognito users that must
3034 receive SMS messages might be unable to sign up, activate their
3035 accounts, or sign in.
3036  
3037 If you have never used SMS text messages with Amazon Cognito or any
3038 other AWS service, Amazon SNS might place your account in SMS sandbox.
3039 In I< sandbox mode
3040 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
3041 youE<rsquo>ll have limitations, such as sending messages to only
3042 verified phone numbers. After testing in the sandbox environment, you
3043 can move out of the SMS sandbox and into production. For more
3044 information, see SMS message settings for Cognito User Pools
3045 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
3046 in the I<Amazon Cognito Developer Guide>.
3047  
3048  
3049 =head2 SetUserSettings
3050  
3051 =over
3052  
3053 =item AccessToken => Str
3054  
3055 =item MFAOptions => ArrayRef[L<Paws::CognitoIdp::MFAOptionType>]
3056  
3057  
3058 =back
3059  
3060 Each argument is described in detail in: L<Paws::CognitoIdp::SetUserSettings>
3061  
3062 Returns: a L<Paws::CognitoIdp::SetUserSettingsResponse> instance
3063  
3064 I<This action is no longer supported.> You can use it to configure only
3065 SMS MFA. You can't use it to configure TOTP software token MFA. To
3066 configure either type of MFA, use SetUserMFAPreference
3067 (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_SetUserMFAPreference.html)
3068 instead.
3069  
3070  
3071 =head2 SignUp
3072  
3073 =over
3074  
3075 =item ClientId => Str
3076  
3077 =item Password => Str
3078  
3079 =item Username => Str
3080  
3081 =item [AnalyticsMetadata => L<Paws::CognitoIdp::AnalyticsMetadataType>]
3082  
3083 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
3084  
3085 =item [SecretHash => Str]
3086  
3087 =item [UserAttributes => ArrayRef[L<Paws::CognitoIdp::AttributeType>]]
3088  
3089 =item [UserContextData => L<Paws::CognitoIdp::UserContextDataType>]
3090  
3091 =item [ValidationData => ArrayRef[L<Paws::CognitoIdp::AttributeType>]]
3092  
3093  
3094 =back
3095  
3096 Each argument is described in detail in: L<Paws::CognitoIdp::SignUp>
3097  
3098 Returns: a L<Paws::CognitoIdp::SignUpResponse> instance
3099  
3100 Registers the user in the specified user pool and creates a user name,
3101 password, and user attributes.
3102  
3103 This action might generate an SMS text message. Starting June 1, 2021,
3104 U.S. telecom carriers require that you register an origination phone
3105 number before you can send SMS messages to U.S. phone numbers. If you
3106 use SMS text messages in Amazon Cognito, you must register a phone
3107 number with Amazon Pinpoint
3108 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
3109 the registered number automatically. Otherwise, Cognito users that must
3110 receive SMS messages might be unable to sign up, activate their
3111 accounts, or sign in.
3112  
3113 If you have never used SMS text messages with Amazon Cognito or any
3114 other AWS service, Amazon SNS might place your account in SMS sandbox.
3115 In I< sandbox mode
3116 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
3117 youE<rsquo>ll have limitations, such as sending messages to only
3118 verified phone numbers. After testing in the sandbox environment, you
3119 can move out of the SMS sandbox and into production. For more
3120 information, see SMS message settings for Cognito User Pools
3121 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
3122 in the I<Amazon Cognito Developer Guide>.
3123  
3124  
3125 =head2 StartUserImportJob
3126  
3127 =over
3128  
3129 =item JobId => Str
3130  
3131 =item UserPoolId => Str
3132  
3133  
3134 =back
3135  
3136 Each argument is described in detail in: L<Paws::CognitoIdp::StartUserImportJob>
3137  
3138 Returns: a L<Paws::CognitoIdp::StartUserImportJobResponse> instance
3139  
3140 Starts the user import.
3141  
3142  
3143 =head2 StopUserImportJob
3144  
3145 =over
3146  
3147 =item JobId => Str
3148  
3149 =item UserPoolId => Str
3150  
3151  
3152 =back
3153  
3154 Each argument is described in detail in: L<Paws::CognitoIdp::StopUserImportJob>
3155  
3156 Returns: a L<Paws::CognitoIdp::StopUserImportJobResponse> instance
3157  
3158 Stops the user import job.
3159  
3160  
3161 =head2 TagResource
3162  
3163 =over
3164  
3165 =item ResourceArn => Str
3166  
3167 =item Tags => L<Paws::CognitoIdp::UserPoolTagsType>
3168  
3169  
3170 =back
3171  
3172 Each argument is described in detail in: L<Paws::CognitoIdp::TagResource>
3173  
3174 Returns: a L<Paws::CognitoIdp::TagResourceResponse> instance
3175  
3176 Assigns a set of tags to an Amazon Cognito user pool. A tag is a label
3177 that you can use to categorize and manage user pools in different ways,
3178 such as by purpose, owner, environment, or other criteria.
3179  
3180 Each tag consists of a key and value, both of which you define. A key
3181 is a general category for more specific values. For example, if you
3182 have two versions of a user pool, one for testing and another for
3183 production, you might assign an C<Environment> tag key to both user
3184 pools. The value of this key might be C<Test> for one user pool and
3185 C<Production> for the other.
3186  
3187 Tags are useful for cost tracking and access control. You can activate
3188 your tags so that they appear on the Billing and Cost Management
3189 console, where you can track the costs associated with your user pools.
3190 In an IAM policy, you can constrain permissions for user pools based on
3191 specific tags or tag values.
3192  
3193 You can use this action up to 5 times per second, per account. A user
3194 pool can have as many as 50 tags.
3195  
3196  
3197 =head2 UntagResource
3198  
3199 =over
3200  
3201 =item ResourceArn => Str
3202  
3203 =item TagKeys => ArrayRef[Str|Undef]
3204  
3205  
3206 =back
3207  
3208 Each argument is described in detail in: L<Paws::CognitoIdp::UntagResource>
3209  
3210 Returns: a L<Paws::CognitoIdp::UntagResourceResponse> instance
3211  
3212 Removes the specified tags from an Amazon Cognito user pool. You can
3213 use this action up to 5 times per second, per account
3214  
3215  
3216 =head2 UpdateAuthEventFeedback
3217  
3218 =over
3219  
3220 =item EventId => Str
3221  
3222 =item FeedbackToken => Str
3223  
3224 =item FeedbackValue => Str
3225  
3226 =item Username => Str
3227  
3228 =item UserPoolId => Str
3229  
3230  
3231 =back
3232  
3233 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateAuthEventFeedback>
3234  
3235 Returns: a L<Paws::CognitoIdp::UpdateAuthEventFeedbackResponse> instance
3236  
3237 Provides the feedback for an authentication event whether it was from a
3238 valid user or not. This feedback is used for improving the risk
3239 evaluation decision for the user pool as part of Amazon Cognito
3240 advanced security.
3241  
3242  
3243 =head2 UpdateDeviceStatus
3244  
3245 =over
3246  
3247 =item AccessToken => Str
3248  
3249 =item DeviceKey => Str
3250  
3251 =item [DeviceRememberedStatus => Str]
3252  
3253  
3254 =back
3255  
3256 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateDeviceStatus>
3257  
3258 Returns: a L<Paws::CognitoIdp::UpdateDeviceStatusResponse> instance
3259  
3260 Updates the device status.
3261  
3262  
3263 =head2 UpdateGroup
3264  
3265 =over
3266  
3267 =item GroupName => Str
3268  
3269 =item UserPoolId => Str
3270  
3271 =item [Description => Str]
3272  
3273 =item [Precedence => Int]
3274  
3275 =item [RoleArn => Str]
3276  
3277  
3278 =back
3279  
3280 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateGroup>
3281  
3282 Returns: a L<Paws::CognitoIdp::UpdateGroupResponse> instance
3283  
3284 Updates the specified group with the specified attributes.
3285  
3286 Calling this action requires developer credentials.
3287  
3288 If you don't provide a value for an attribute, it will be set to the
3289 default value.
3290  
3291  
3292 =head2 UpdateIdentityProvider
3293  
3294 =over
3295  
3296 =item ProviderName => Str
3297  
3298 =item UserPoolId => Str
3299  
3300 =item [AttributeMapping => L<Paws::CognitoIdp::AttributeMappingType>]
3301  
3302 =item [IdpIdentifiers => ArrayRef[Str|Undef]]
3303  
3304 =item [ProviderDetails => L<Paws::CognitoIdp::ProviderDetailsType>]
3305  
3306  
3307 =back
3308  
3309 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateIdentityProvider>
3310  
3311 Returns: a L<Paws::CognitoIdp::UpdateIdentityProviderResponse> instance
3312  
3313 Updates identity provider information for a user pool.
3314  
3315  
3316 =head2 UpdateResourceServer
3317  
3318 =over
3319  
3320 =item Identifier => Str
3321  
3322 =item Name => Str
3323  
3324 =item UserPoolId => Str
3325  
3326 =item [Scopes => ArrayRef[L<Paws::CognitoIdp::ResourceServerScopeType>]]
3327  
3328  
3329 =back
3330  
3331 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateResourceServer>
3332  
3333 Returns: a L<Paws::CognitoIdp::UpdateResourceServerResponse> instance
3334  
3335 Updates the name and scopes of resource server. All other fields are
3336 read-only.
3337  
3338 If you don't provide a value for an attribute, it will be set to the
3339 default value.
3340  
3341  
3342 =head2 UpdateUserAttributes
3343  
3344 =over
3345  
3346 =item AccessToken => Str
3347  
3348 =item UserAttributes => ArrayRef[L<Paws::CognitoIdp::AttributeType>]
3349  
3350 =item [ClientMetadata => L<Paws::CognitoIdp::ClientMetadataType>]
3351  
3352  
3353 =back
3354  
3355 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateUserAttributes>
3356  
3357 Returns: a L<Paws::CognitoIdp::UpdateUserAttributesResponse> instance
3358  
3359 Allows a user to update a specific attribute (one at a time).
3360  
3361 This action might generate an SMS text message. Starting June 1, 2021,
3362 U.S. telecom carriers require that you register an origination phone
3363 number before you can send SMS messages to U.S. phone numbers. If you
3364 use SMS text messages in Amazon Cognito, you must register a phone
3365 number with Amazon Pinpoint
3366 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
3367 the registered number automatically. Otherwise, Cognito users that must
3368 receive SMS messages might be unable to sign up, activate their
3369 accounts, or sign in.
3370  
3371 If you have never used SMS text messages with Amazon Cognito or any
3372 other AWS service, Amazon SNS might place your account in SMS sandbox.
3373 In I< sandbox mode
3374 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
3375 youE<rsquo>ll have limitations, such as sending messages to only
3376 verified phone numbers. After testing in the sandbox environment, you
3377 can move out of the SMS sandbox and into production. For more
3378 information, see SMS message settings for Cognito User Pools
3379 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
3380 in the I<Amazon Cognito Developer Guide>.
3381  
3382  
3383 =head2 UpdateUserPool
3384  
3385 =over
3386  
3387 =item UserPoolId => Str
3388  
3389 =item [AccountRecoverySetting => L<Paws::CognitoIdp::AccountRecoverySettingType>]
3390  
3391 =item [AdminCreateUserConfig => L<Paws::CognitoIdp::AdminCreateUserConfigType>]
3392  
3393 =item [AutoVerifiedAttributes => ArrayRef[Str|Undef]]
3394  
3395 =item [DeviceConfiguration => L<Paws::CognitoIdp::DeviceConfigurationType>]
3396  
3397 =item [EmailConfiguration => L<Paws::CognitoIdp::EmailConfigurationType>]
3398  
3399 =item [EmailVerificationMessage => Str]
3400  
3401 =item [EmailVerificationSubject => Str]
3402  
3403 =item [LambdaConfig => L<Paws::CognitoIdp::LambdaConfigType>]
3404  
3405 =item [MfaConfiguration => Str]
3406  
3407 =item [Policies => L<Paws::CognitoIdp::UserPoolPolicyType>]
3408  
3409 =item [SmsAuthenticationMessage => Str]
3410  
3411 =item [SmsConfiguration => L<Paws::CognitoIdp::SmsConfigurationType>]
3412  
3413 =item [SmsVerificationMessage => Str]
3414  
3415 =item [UserPoolAddOns => L<Paws::CognitoIdp::UserPoolAddOnsType>]
3416  
3417 =item [UserPoolTags => L<Paws::CognitoIdp::UserPoolTagsType>]
3418  
3419 =item [VerificationMessageTemplate => L<Paws::CognitoIdp::VerificationMessageTemplateType>]
3420  
3421  
3422 =back
3423  
3424 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateUserPool>
3425  
3426 Returns: a L<Paws::CognitoIdp::UpdateUserPoolResponse> instance
3427  
3428 Updates the specified user pool with the specified attributes. You can
3429 get a list of the current user pool settings using DescribeUserPool
3430 (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_DescribeUserPool.html).
3431 If you don't provide a value for an attribute, it will be set to the
3432 default value.
3433  
3434 This action might generate an SMS text message. Starting June 1, 2021,
3435 U.S. telecom carriers require that you register an origination phone
3436 number before you can send SMS messages to U.S. phone numbers. If you
3437 use SMS text messages in Amazon Cognito, you must register a phone
3438 number with Amazon Pinpoint
3439 (https://console.aws.amazon.com/pinpoint/home/). Cognito will use the
3440 the registered number automatically. Otherwise, Cognito users that must
3441 receive SMS messages might be unable to sign up, activate their
3442 accounts, or sign in.
3443  
3444 If you have never used SMS text messages with Amazon Cognito or any
3445 other AWS service, Amazon SNS might place your account in SMS sandbox.
3446 In I< sandbox mode
3447 (https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html) >,
3448 youE<rsquo>ll have limitations, such as sending messages to only
3449 verified phone numbers. After testing in the sandbox environment, you
3450 can move out of the SMS sandbox and into production. For more
3451 information, see SMS message settings for Cognito User Pools
3452 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html)
3453 in the I<Amazon Cognito Developer Guide>.
3454  
3455  
3456 =head2 UpdateUserPoolClient
3457  
3458 =over
3459  
3460 =item ClientId => Str
3461  
3462 =item UserPoolId => Str
3463  
3464 =item [AccessTokenValidity => Int]
3465  
3466 =item [AllowedOAuthFlows => ArrayRef[Str|Undef]]
3467  
3468 =item [AllowedOAuthFlowsUserPoolClient => Bool]
3469  
3470 =item [AllowedOAuthScopes => ArrayRef[Str|Undef]]
3471  
3472 =item [AnalyticsConfiguration => L<Paws::CognitoIdp::AnalyticsConfigurationType>]
3473  
3474 =item [CallbackURLs => ArrayRef[Str|Undef]]
3475  
3476 =item [ClientName => Str]
3477  
3478 =item [DefaultRedirectURI => Str]
3479  
3480 =item [EnableTokenRevocation => Bool]
3481  
3482 =item [ExplicitAuthFlows => ArrayRef[Str|Undef]]
3483  
3484 =item [IdTokenValidity => Int]
3485  
3486 =item [LogoutURLs => ArrayRef[Str|Undef]]
3487  
3488 =item [PreventUserExistenceErrors => Str]
3489  
3490 =item [ReadAttributes => ArrayRef[Str|Undef]]
3491  
3492 =item [RefreshTokenValidity => Int]
3493  
3494 =item [SupportedIdentityProviders => ArrayRef[Str|Undef]]
3495  
3496 =item [TokenValidityUnits => L<Paws::CognitoIdp::TokenValidityUnitsType>]
3497  
3498 =item [WriteAttributes => ArrayRef[Str|Undef]]
3499  
3500  
3501 =back
3502  
3503 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateUserPoolClient>
3504  
3505 Returns: a L<Paws::CognitoIdp::UpdateUserPoolClientResponse> instance
3506  
3507 Updates the specified user pool app client with the specified
3508 attributes. You can get a list of the current user pool app client
3509 settings using DescribeUserPoolClient
3510 (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_DescribeUserPoolClient.html).
3511  
3512 If you don't provide a value for an attribute, it will be set to the
3513 default value.
3514  
3515 You can also use this operation to enable token revocation for user
3516 pool clients. For more information about revoking tokens, see
3517 RevokeToken
3518 (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RevokeToken.html).
3519  
3520  
3521 =head2 UpdateUserPoolDomain
3522  
3523 =over
3524  
3525 =item CustomDomainConfig => L<Paws::CognitoIdp::CustomDomainConfigType>
3526  
3527 =item Domain => Str
3528  
3529 =item UserPoolId => Str
3530  
3531  
3532 =back
3533  
3534 Each argument is described in detail in: L<Paws::CognitoIdp::UpdateUserPoolDomain>
3535  
3536 Returns: a L<Paws::CognitoIdp::UpdateUserPoolDomainResponse> instance
3537  
3538 Updates the Secure Sockets Layer (SSL) certificate for the custom
3539 domain for your user pool.
3540  
3541 You can use this operation to provide the Amazon Resource Name (ARN) of
3542 a new certificate to Amazon Cognito. You cannot use it to change the
3543 domain for a user pool.
3544  
3545 A custom domain is used to host the Amazon Cognito hosted UI, which
3546 provides sign-up and sign-in pages for your application. When you set
3547 up a custom domain, you provide a certificate that you manage with AWS
3548 Certificate Manager (ACM). When necessary, you can use this operation
3549 to change the certificate that you applied to your custom domain.
3550  
3551 Usually, this is unnecessary following routine certificate renewal with
3552 ACM. When you renew your existing certificate in ACM, the ARN for your
3553 certificate remains the same, and your custom domain uses the new
3554 certificate automatically.
3555  
3556 However, if you replace your existing certificate with a new one, ACM
3557 gives the new certificate a new ARN. To apply the new certificate to
3558 your custom domain, you must provide this ARN to Amazon Cognito.
3559  
3560 When you add your new certificate in ACM, you must choose US East (N.
3561 Virginia) as the AWS Region.
3562  
3563 After you submit your request, Amazon Cognito requires up to 1 hour to
3564 distribute your new certificate to your custom domain.
3565  
3566 For more information about adding a custom domain to your user pool,
3567 see Using Your Own Domain for the Hosted UI
3568 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-add-custom-domain.html).
3569  
3570  
3571 =head2 VerifySoftwareToken
3572  
3573 =over
3574  
3575 =item UserCode => Str
3576  
3577 =item [AccessToken => Str]
3578  
3579 =item [FriendlyDeviceName => Str]
3580  
3581 =item [Session => Str]
3582  
3583  
3584 =back
3585  
3586 Each argument is described in detail in: L<Paws::CognitoIdp::VerifySoftwareToken>
3587  
3588 Returns: a L<Paws::CognitoIdp::VerifySoftwareTokenResponse> instance
3589  
3590 Use this API to register a user's entered TOTP code and mark the user's
3591 software token MFA status as "verified" if successful. The request
3592 takes an access token or a session string, but not both.
3593  
3594  
3595 =head2 VerifyUserAttribute
3596  
3597 =over
3598  
3599 =item AccessToken => Str
3600  
3601 =item AttributeName => Str
3602  
3603 =item Code => Str
3604  
3605  
3606 =back
3607  
3608 Each argument is described in detail in: L<Paws::CognitoIdp::VerifyUserAttribute>
3609  
3610 Returns: a L<Paws::CognitoIdp::VerifyUserAttributeResponse> instance
3611  
3612 Verifies the specified user attributes in the user pool.
3613  
3614  
3615  
3616  
3617 =head1 PAGINATORS
3618  
3619 Paginator methods are helpers that repetively call methods that return partial results
3620  
3621 =head2 AdminListAllGroupsForUser(sub { },Username => Str, UserPoolId => Str, [Limit => Int, NextToken => Str])
3622  
3623 =head2 AdminListAllGroupsForUser(Username => Str, UserPoolId => Str, [Limit => Int, NextToken => Str])
3624  
3625  
3626 If passed a sub as first parameter, it will call the sub for each element found in :
3627  
3628 - Groups, passing the object as the first parameter, and the string 'Groups' as the second parameter
3629  
3630 If not, it will return a a L<Paws::CognitoIdp::AdminListGroupsForUserResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3631  
3632  
3633 =head2 AdminListAllUserAuthEvents(sub { },Username => Str, UserPoolId => Str, [MaxResults => Int, NextToken => Str])
3634  
3635 =head2 AdminListAllUserAuthEvents(Username => Str, UserPoolId => Str, [MaxResults => Int, NextToken => Str])
3636  
3637  
3638 If passed a sub as first parameter, it will call the sub for each element found in :
3639  
3640 - AuthEvents, passing the object as the first parameter, and the string 'AuthEvents' as the second parameter
3641  
3642 If not, it will return a a L<Paws::CognitoIdp::AdminListUserAuthEventsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3643  
3644  
3645 =head2 ListAllGroups(sub { },UserPoolId => Str, [Limit => Int, NextToken => Str])
3646  
3647 =head2 ListAllGroups(UserPoolId => Str, [Limit => Int, NextToken => Str])
3648  
3649  
3650 If passed a sub as first parameter, it will call the sub for each element found in :
3651  
3652 - Groups, passing the object as the first parameter, and the string 'Groups' as the second parameter
3653  
3654 If not, it will return a a L<Paws::CognitoIdp::ListGroupsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3655  
3656  
3657 =head2 ListAllIdentityProviders(sub { },UserPoolId => Str, [MaxResults => Int, NextToken => Str])
3658  
3659 =head2 ListAllIdentityProviders(UserPoolId => Str, [MaxResults => Int, NextToken => Str])
3660  
3661  
3662 If passed a sub as first parameter, it will call the sub for each element found in :
3663  
3664 - Providers, passing the object as the first parameter, and the string 'Providers' as the second parameter
3665  
3666 If not, it will return a a L<Paws::CognitoIdp::ListIdentityProvidersResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3667  
3668  
3669 =head2 ListAllResourceServers(sub { },UserPoolId => Str, [MaxResults => Int, NextToken => Str])
3670  
3671 =head2 ListAllResourceServers(UserPoolId => Str, [MaxResults => Int, NextToken => Str])
3672  
3673  
3674 If passed a sub as first parameter, it will call the sub for each element found in :
3675  
3676 - ResourceServers, passing the object as the first parameter, and the string 'ResourceServers' as the second parameter
3677  
3678 If not, it will return a a L<Paws::CognitoIdp::ListResourceServersResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3679  
3680  
3681 =head2 ListAllUserPoolClients(sub { },UserPoolId => Str, [MaxResults => Int, NextToken => Str])
3682  
3683 =head2 ListAllUserPoolClients(UserPoolId => Str, [MaxResults => Int, NextToken => Str])
3684  
3685  
3686 If passed a sub as first parameter, it will call the sub for each element found in :
3687  
3688 - UserPoolClients, passing the object as the first parameter, and the string 'UserPoolClients' as the second parameter
3689  
3690 If not, it will return a a L<Paws::CognitoIdp::ListUserPoolClientsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3691  
3692  
3693 =head2 ListAllUserPools(sub { },MaxResults => Int, [NextToken => Str])
3694  
3695 =head2 ListAllUserPools(MaxResults => Int, [NextToken => Str])
3696  
3697  
3698 If passed a sub as first parameter, it will call the sub for each element found in :
3699  
3700 - UserPools, passing the object as the first parameter, and the string 'UserPools' as the second parameter
3701  
3702 If not, it will return a a L<Paws::CognitoIdp::ListUserPoolsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3703  
3704  
3705 =head2 ListAllUsers(sub { },UserPoolId => Str, [AttributesToGet => ArrayRef[Str|Undef], Filter => Str, Limit => Int, PaginationToken => Str])
3706  
3707 =head2 ListAllUsers(UserPoolId => Str, [AttributesToGet => ArrayRef[Str|Undef], Filter => Str, Limit => Int, PaginationToken => Str])
3708  
3709  
3710 If passed a sub as first parameter, it will call the sub for each element found in :
3711  
3712 - Users, passing the object as the first parameter, and the string 'Users' as the second parameter
3713  
3714 If not, it will return a a L<Paws::CognitoIdp::ListUsersResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3715  
3716  
3717 =head2 ListAllUsersInGroup(sub { },GroupName => Str, UserPoolId => Str, [Limit => Int, NextToken => Str])
3718  
3719 =head2 ListAllUsersInGroup(GroupName => Str, UserPoolId => Str, [Limit => Int, NextToken => Str])
3720  
3721  
3722 If passed a sub as first parameter, it will call the sub for each element found in :
3723  
3724 - Users, passing the object as the first parameter, and the string 'Users' as the second parameter
3725  
3726 If not, it will return a a L<Paws::CognitoIdp::ListUsersInGroupResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
3727  
3728  
3729  
3730  
3731  
3732 =head1 SEE ALSO
3733  
3734 This service class forms part of L<Paws>
3735  
3736 =head1 BUGS and CONTRIBUTIONS
3737  
3738 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
3739  
3740 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
3741  
3742 =cut
3743