blib/lib/Paws/CognitoIdentity.pm

filter: Statementstmt 17.4% 18 / 103 Branchbran 0.0% 0 / 8 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 27.2% 9 / 33 Podpod 80.0% 24 / 30 totaltotal 29.3% 51 / 174 CC 7 SCAR 24.4
CC
7
Cov
16%
ListAllIdentityPools
56.0
CreateIdentityPool
2.0
DeleteIdentities
2.0
CRAP 11.5
« blib/lib/Paws/MQ.pm ↑ Summary blib/lib/Paws/Net/S3V4Signature.pm »
1 package Paws::CognitoIdentity;
2 1 ▶ use Moose;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 1 ▶ sub service { 'cognito-identity' }
Subroutine service: called CC=1 SCAR=0.0
Pod undocumented
4 1 ▶ sub signing_name { 'cognito-identity' }
Subroutine signing_name: called CC=1 SCAR=0.0
Pod undocumented
5 1 ▶ sub version { '2014-06-30' }
Subroutine version: called CC=1 SCAR=0.0
Pod undocumented
6 1 ▶ sub target_prefix { 'AWSCognitoIdentityService' }
Subroutine target_prefix: called CC=1 SCAR=0.0
Pod undocumented
7 1 ▶ sub json_version { "1.1" }
Subroutine json_version: called CC=1 SCAR=0.0
Pod undocumented
8 1 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 1 ▶ has retry => (is => 'ro', isa => 'HashRef', default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
10 1 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 1 });
12 1 ▶ has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
Subroutine __ANON__: called CC=1 SCAR=0.0
13 1 ] });
14  
15 1 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 0 ▶ sub CreateIdentityPool {
Subroutine CreateIdentityPool: not called CC=1 SCAR=6.9
Pod documented
19 0 my $self = shift;
20 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::CreateIdentityPool', @_);
21 0 return $self->caller->do_call($self, $call_object);
22 }
23 0 ▶ sub DeleteIdentities {
Subroutine DeleteIdentities: not called CC=1 SCAR=6.9
Pod documented
24 0 my $self = shift;
25 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::DeleteIdentities', @_);
26 0 return $self->caller->do_call($self, $call_object);
27 }
28 0 ▶ sub DeleteIdentityPool {
Subroutine DeleteIdentityPool: not called CC=1 SCAR=6.9
Pod documented
29 0 my $self = shift;
30 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::DeleteIdentityPool', @_);
31 0 return $self->caller->do_call($self, $call_object);
32 }
33 0 ▶ sub DescribeIdentity {
Subroutine DescribeIdentity: not called CC=1 SCAR=6.9
Pod documented
34 0 my $self = shift;
35 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::DescribeIdentity', @_);
36 0 return $self->caller->do_call($self, $call_object);
37 }
38 0 ▶ sub DescribeIdentityPool {
Subroutine DescribeIdentityPool: not called CC=1 SCAR=6.9
Pod documented
39 0 my $self = shift;
40 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::DescribeIdentityPool', @_);
41 0 return $self->caller->do_call($self, $call_object);
42 }
43 0 ▶ sub GetCredentialsForIdentity {
Subroutine GetCredentialsForIdentity: not called CC=1 SCAR=6.9
Pod documented
44 0 my $self = shift;
45 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::GetCredentialsForIdentity', @_);
46 0 return $self->caller->do_call($self, $call_object);
47 }
48 0 ▶ sub GetId {
Subroutine GetId: not called CC=1 SCAR=6.9
Pod documented
49 0 my $self = shift;
50 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::GetId', @_);
51 0 return $self->caller->do_call($self, $call_object);
52 }
53 0 ▶ sub GetIdentityPoolRoles {
Subroutine GetIdentityPoolRoles: not called CC=1 SCAR=6.9
Pod documented
54 0 my $self = shift;
55 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::GetIdentityPoolRoles', @_);
56 0 return $self->caller->do_call($self, $call_object);
57 }
58 0 ▶ sub GetOpenIdToken {
Subroutine GetOpenIdToken: not called CC=1 SCAR=6.9
Pod documented
59 0 my $self = shift;
60 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::GetOpenIdToken', @_);
61 0 return $self->caller->do_call($self, $call_object);
62 }
63 1 ▶ sub GetOpenIdTokenForDeveloperIdentity {
Subroutine GetOpenIdTokenForDeveloperIdentity: called CC=1 SCAR=0.0
Pod documented
64 1 my $self = shift;
65 1 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::GetOpenIdTokenForDeveloperIdentity', @_);
66 1 return $self->caller->do_call($self, $call_object);
67 }
68 0 ▶ sub GetPrincipalTagAttributeMap {
Subroutine GetPrincipalTagAttributeMap: not called CC=1 SCAR=6.9
Pod documented
69 0 my $self = shift;
70 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::GetPrincipalTagAttributeMap', @_);
71 0 return $self->caller->do_call($self, $call_object);
72 }
73 0 ▶ sub ListIdentities {
Subroutine ListIdentities: not called CC=1 SCAR=6.9
Pod documented
74 0 my $self = shift;
75 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::ListIdentities', @_);
76 0 return $self->caller->do_call($self, $call_object);
77 }
78 0 ▶ sub ListIdentityPools {
Subroutine ListIdentityPools: not called CC=1 SCAR=6.9
Pod documented
79 0 my $self = shift;
80 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::ListIdentityPools', @_);
81 0 return $self->caller->do_call($self, $call_object);
82 }
83 0 ▶ sub ListTagsForResource {
Subroutine ListTagsForResource: not called CC=1 SCAR=6.9
Pod documented
84 0 my $self = shift;
85 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::ListTagsForResource', @_);
86 0 return $self->caller->do_call($self, $call_object);
87 }
88 0 ▶ sub LookupDeveloperIdentity {
Subroutine LookupDeveloperIdentity: not called CC=1 SCAR=6.9
Pod documented
89 0 my $self = shift;
90 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::LookupDeveloperIdentity', @_);
91 0 return $self->caller->do_call($self, $call_object);
92 }
93 0 ▶ sub MergeDeveloperIdentities {
Subroutine MergeDeveloperIdentities: not called CC=1 SCAR=6.9
Pod documented
94 0 my $self = shift;
95 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::MergeDeveloperIdentities', @_);
96 0 return $self->caller->do_call($self, $call_object);
97 }
98 0 ▶ sub SetIdentityPoolRoles {
Subroutine SetIdentityPoolRoles: not called CC=1 SCAR=6.9
Pod documented
99 0 my $self = shift;
100 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::SetIdentityPoolRoles', @_);
101 0 return $self->caller->do_call($self, $call_object);
102 }
103 0 ▶ sub SetPrincipalTagAttributeMap {
Subroutine SetPrincipalTagAttributeMap: not called CC=1 SCAR=6.9
Pod documented
104 0 my $self = shift;
105 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::SetPrincipalTagAttributeMap', @_);
106 0 return $self->caller->do_call($self, $call_object);
107 }
108 0 ▶ sub TagResource {
Subroutine TagResource: not called CC=1 SCAR=6.9
Pod documented
109 0 my $self = shift;
110 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::TagResource', @_);
111 0 return $self->caller->do_call($self, $call_object);
112 }
113 0 ▶ sub UnlinkDeveloperIdentity {
Subroutine UnlinkDeveloperIdentity: not called CC=1 SCAR=6.9
Pod documented
114 0 my $self = shift;
115 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::UnlinkDeveloperIdentity', @_);
116 0 return $self->caller->do_call($self, $call_object);
117 }
118 0 ▶ sub UnlinkIdentity {
Subroutine UnlinkIdentity: not called CC=1 SCAR=6.9
Pod documented
119 0 my $self = shift;
120 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::UnlinkIdentity', @_);
121 0 return $self->caller->do_call($self, $call_object);
122 }
123 0 ▶ sub UntagResource {
Subroutine UntagResource: not called CC=1 SCAR=6.9
Pod documented
124 0 my $self = shift;
125 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::UntagResource', @_);
126 0 return $self->caller->do_call($self, $call_object);
127 }
128 0 ▶ sub UpdateIdentityPool {
Subroutine UpdateIdentityPool: not called CC=1 SCAR=6.9
Pod documented
129 0 my $self = shift;
130 0 my $call_object = $self->new_with_coercions('Paws::CognitoIdentity::UpdateIdentityPool', @_);
131 0 return $self->caller->do_call($self, $call_object);
132 }
133
134 0 ▶ sub ListAllIdentityPools {
Subroutine ListAllIdentityPools: not called CC=7 SCAR=40.3
Pod documented
135 0 my $self = shift;
136  
137 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
138 0 my $result = $self->ListIdentityPools(@_);
139 0 my $next_result = $result;
140  
141 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
142 0 ▶ while ($next_result->NextToken) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->NextToken) 0 0 0
143 0 $next_result = $self->ListIdentityPools(@_, NextToken => $next_result->NextToken);
144 0 push @{ $result->IdentityPools }, @{ $next_result->IdentityPools };
145 }
146 0 return $result;
147 } else {
148 0 ▶ while ($result->NextToken) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->NextToken) 0 0 0
149 0 $callback->($_ => 'IdentityPools') foreach (@{ $result->IdentityPools });
150 0 $result = $self->ListIdentityPools(@_, NextToken => $result->NextToken);
151 }
152 0 $callback->($_ => 'IdentityPools') foreach (@{ $result->IdentityPools });
153 }
154  
155 return undef
156 0 }
157  
158  
159 0 ▶ sub operations { qw/CreateIdentityPool DeleteIdentities DeleteIdentityPool DescribeIdentity DescribeIdentityPool GetCredentialsForIdentity GetId GetIdentityPoolRoles GetOpenIdToken GetOpenIdTokenForDeveloperIdentity GetPrincipalTagAttributeMap ListIdentities ListIdentityPools ListTagsForResource LookupDeveloperIdentity MergeDeveloperIdentities SetIdentityPoolRoles SetPrincipalTagAttributeMap TagResource UnlinkDeveloperIdentity UnlinkIdentity UntagResource UpdateIdentityPool / }
Subroutine operations: not called CC=1 SCAR=6.9
Pod undocumented
160  
161 1 1;
162  
163 ### main pod documentation begin ###
164  
165 =head1 NAME
166  
167 Paws::CognitoIdentity - Perl Interface to AWS Amazon Cognito Identity
168  
169 =head1 SYNOPSIS
170  
171 use Paws;
172  
173 my $obj = Paws->service('CognitoIdentity');
174 my $res = $obj->Method(
175 Arg1 => $val1,
176 Arg2 => [ 'V1', 'V2' ],
177 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
178 # of the arguments type
179 Arg3 => { Att1 => 'Val1' },
180 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
181 # the constructor of the arguments type
182 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
183 );
184  
185 =head1 DESCRIPTION
186  
187 Amazon Cognito Federated Identities
188  
189 Amazon Cognito Federated Identities is a web service that delivers
190 scoped temporary credentials to mobile devices and other untrusted
191 environments. It uniquely identifies a device and supplies the user
192 with a consistent identity over the lifetime of an application.
193  
194 Using Amazon Cognito Federated Identities, you can enable
195 authentication with one or more third-party identity providers
196 (Facebook, Google, or Login with Amazon) or an Amazon Cognito user
197 pool, and you can also choose to support unauthenticated access from
198 your app. Cognito delivers a unique identifier for each user and acts
199 as an OpenID token provider trusted by AWS Security Token Service (STS)
200 to access temporary, limited-privilege AWS credentials.
201  
202 For a description of the authentication flow from the Amazon Cognito
203 Developer Guide see Authentication Flow
204 (https://docs.aws.amazon.com/cognito/latest/developerguide/authentication-flow.html).
205  
206 For more information see Amazon Cognito Federated Identities
207 (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html).
208  
209 For the AWS API documentation, see L<https://docs.aws.amazon.com/cognito/>
210  
211  
212 =head1 METHODS
213  
214 =head2 CreateIdentityPool
215  
216 =over
217  
218 =item AllowUnauthenticatedIdentities => Bool
219  
220 =item IdentityPoolName => Str
221  
222 =item [AllowClassicFlow => Bool]
223  
224 =item [CognitoIdentityProviders => ArrayRef[L<Paws::CognitoIdentity::CognitoIdentityProvider>]]
225  
226 =item [DeveloperProviderName => Str]
227  
228 =item [IdentityPoolTags => L<Paws::CognitoIdentity::IdentityPoolTagsType>]
229  
230 =item [OpenIdConnectProviderARNs => ArrayRef[Str|Undef]]
231  
232 =item [SamlProviderARNs => ArrayRef[Str|Undef]]
233  
234 =item [SupportedLoginProviders => L<Paws::CognitoIdentity::IdentityProviders>]
235  
236  
237 =back
238  
239 Each argument is described in detail in: L<Paws::CognitoIdentity::CreateIdentityPool>
240  
241 Returns: a L<Paws::CognitoIdentity::IdentityPool> instance
242  
243 Creates a new identity pool. The identity pool is a store of user
244 identity information that is specific to your AWS account. The keys for
245 C<SupportedLoginProviders> are as follows:
246  
247 =over
248  
249 =item *
250  
251 Facebook: C<graph.facebook.com>
252  
253 =item *
254  
255 Google: C<accounts.google.com>
256  
257 =item *
258  
259 Amazon: C<www.amazon.com>
260  
261 =item *
262  
263 Twitter: C<api.twitter.com>
264  
265 =item *
266  
267 Digits: C<www.digits.com>
268  
269 =back
270  
271 You must use AWS Developer credentials to call this API.
272  
273  
274 =head2 DeleteIdentities
275  
276 =over
277  
278 =item IdentityIdsToDelete => ArrayRef[Str|Undef]
279  
280  
281 =back
282  
283 Each argument is described in detail in: L<Paws::CognitoIdentity::DeleteIdentities>
284  
285 Returns: a L<Paws::CognitoIdentity::DeleteIdentitiesResponse> instance
286  
287 Deletes identities from an identity pool. You can specify a list of
288 1-60 identities that you want to delete.
289  
290 You must use AWS Developer credentials to call this API.
291  
292  
293 =head2 DeleteIdentityPool
294  
295 =over
296  
297 =item IdentityPoolId => Str
298  
299  
300 =back
301  
302 Each argument is described in detail in: L<Paws::CognitoIdentity::DeleteIdentityPool>
303  
304 Returns: nothing
305  
306 Deletes an identity pool. Once a pool is deleted, users will not be
307 able to authenticate with the pool.
308  
309 You must use AWS Developer credentials to call this API.
310  
311  
312 =head2 DescribeIdentity
313  
314 =over
315  
316 =item IdentityId => Str
317  
318  
319 =back
320  
321 Each argument is described in detail in: L<Paws::CognitoIdentity::DescribeIdentity>
322  
323 Returns: a L<Paws::CognitoIdentity::IdentityDescription> instance
324  
325 Returns metadata related to the given identity, including when the
326 identity was created and any associated linked logins.
327  
328 You must use AWS Developer credentials to call this API.
329  
330  
331 =head2 DescribeIdentityPool
332  
333 =over
334  
335 =item IdentityPoolId => Str
336  
337  
338 =back
339  
340 Each argument is described in detail in: L<Paws::CognitoIdentity::DescribeIdentityPool>
341  
342 Returns: a L<Paws::CognitoIdentity::IdentityPool> instance
343  
344 Gets details about a particular identity pool, including the pool name,
345 ID description, creation date, and current number of users.
346  
347 You must use AWS Developer credentials to call this API.
348  
349  
350 =head2 GetCredentialsForIdentity
351  
352 =over
353  
354 =item IdentityId => Str
355  
356 =item [CustomRoleArn => Str]
357  
358 =item [Logins => L<Paws::CognitoIdentity::LoginsMap>]
359  
360  
361 =back
362  
363 Each argument is described in detail in: L<Paws::CognitoIdentity::GetCredentialsForIdentity>
364  
365 Returns: a L<Paws::CognitoIdentity::GetCredentialsForIdentityResponse> instance
366  
367 Returns credentials for the provided identity ID. Any provided logins
368 will be validated against supported login providers. If the token is
369 for cognito-identity.amazonaws.com, it will be passed through to AWS
370 Security Token Service with the appropriate role for the token.
371  
372 This is a public API. You do not need any credentials to call this API.
373  
374  
375 =head2 GetId
376  
377 =over
378  
379 =item IdentityPoolId => Str
380  
381 =item [AccountId => Str]
382  
383 =item [Logins => L<Paws::CognitoIdentity::LoginsMap>]
384  
385  
386 =back
387  
388 Each argument is described in detail in: L<Paws::CognitoIdentity::GetId>
389  
390 Returns: a L<Paws::CognitoIdentity::GetIdResponse> instance
391  
392 Generates (or retrieves) a Cognito ID. Supplying multiple logins will
393 create an implicit linked account.
394  
395 This is a public API. You do not need any credentials to call this API.
396  
397  
398 =head2 GetIdentityPoolRoles
399  
400 =over
401  
402 =item IdentityPoolId => Str
403  
404  
405 =back
406  
407 Each argument is described in detail in: L<Paws::CognitoIdentity::GetIdentityPoolRoles>
408  
409 Returns: a L<Paws::CognitoIdentity::GetIdentityPoolRolesResponse> instance
410  
411 Gets the roles for an identity pool.
412  
413 You must use AWS Developer credentials to call this API.
414  
415  
416 =head2 GetOpenIdToken
417  
418 =over
419  
420 =item IdentityId => Str
421  
422 =item [Logins => L<Paws::CognitoIdentity::LoginsMap>]
423  
424  
425 =back
426  
427 Each argument is described in detail in: L<Paws::CognitoIdentity::GetOpenIdToken>
428  
429 Returns: a L<Paws::CognitoIdentity::GetOpenIdTokenResponse> instance
430  
431 Gets an OpenID token, using a known Cognito ID. This known Cognito ID
432 is returned by GetId. You can optionally add additional logins for the
433 identity. Supplying multiple logins creates an implicit link.
434  
435 The OpenID token is valid for 10 minutes.
436  
437 This is a public API. You do not need any credentials to call this API.
438  
439  
440 =head2 GetOpenIdTokenForDeveloperIdentity
441  
442 =over
443  
444 =item IdentityPoolId => Str
445  
446 =item Logins => L<Paws::CognitoIdentity::LoginsMap>
447  
448 =item [IdentityId => Str]
449  
450 =item [PrincipalTags => L<Paws::CognitoIdentity::PrincipalTags>]
451  
452 =item [TokenDuration => Int]
453  
454  
455 =back
456  
457 Each argument is described in detail in: L<Paws::CognitoIdentity::GetOpenIdTokenForDeveloperIdentity>
458  
459 Returns: a L<Paws::CognitoIdentity::GetOpenIdTokenForDeveloperIdentityResponse> instance
460  
461 Registers (or retrieves) a Cognito C<IdentityId> and an OpenID Connect
462 token for a user authenticated by your backend authentication process.
463 Supplying multiple logins will create an implicit linked account. You
464 can only specify one developer provider as part of the C<Logins> map,
465 which is linked to the identity pool. The developer provider is the
466 "domain" by which Cognito will refer to your users.
467  
468 You can use C<GetOpenIdTokenForDeveloperIdentity> to create a new
469 identity and to link new logins (that is, user credentials issued by a
470 public provider or developer provider) to an existing identity. When
471 you want to create a new identity, the C<IdentityId> should be null.
472 When you want to associate a new login with an existing
473 authenticated/unauthenticated identity, you can do so by providing the
474 existing C<IdentityId>. This API will create the identity in the
475 specified C<IdentityPoolId>.
476  
477 You must use AWS Developer credentials to call this API.
478  
479  
480 =head2 GetPrincipalTagAttributeMap
481  
482 =over
483  
484 =item IdentityPoolId => Str
485  
486 =item IdentityProviderName => Str
487  
488  
489 =back
490  
491 Each argument is described in detail in: L<Paws::CognitoIdentity::GetPrincipalTagAttributeMap>
492  
493 Returns: a L<Paws::CognitoIdentity::GetPrincipalTagAttributeMapResponse> instance
494  
495 Use C<GetPrincipalTagAttributeMap> to list all mappings between
496 C<PrincipalTags> and user attributes.
497  
498  
499 =head2 ListIdentities
500  
501 =over
502  
503 =item IdentityPoolId => Str
504  
505 =item MaxResults => Int
506  
507 =item [HideDisabled => Bool]
508  
509 =item [NextToken => Str]
510  
511  
512 =back
513  
514 Each argument is described in detail in: L<Paws::CognitoIdentity::ListIdentities>
515  
516 Returns: a L<Paws::CognitoIdentity::ListIdentitiesResponse> instance
517  
518 Lists the identities in an identity pool.
519  
520 You must use AWS Developer credentials to call this API.
521  
522  
523 =head2 ListIdentityPools
524  
525 =over
526  
527 =item MaxResults => Int
528  
529 =item [NextToken => Str]
530  
531  
532 =back
533  
534 Each argument is described in detail in: L<Paws::CognitoIdentity::ListIdentityPools>
535  
536 Returns: a L<Paws::CognitoIdentity::ListIdentityPoolsResponse> instance
537  
538 Lists all of the Cognito identity pools registered for your account.
539  
540 You must use AWS Developer credentials to call this API.
541  
542  
543 =head2 ListTagsForResource
544  
545 =over
546  
547 =item ResourceArn => Str
548  
549  
550 =back
551  
552 Each argument is described in detail in: L<Paws::CognitoIdentity::ListTagsForResource>
553  
554 Returns: a L<Paws::CognitoIdentity::ListTagsForResourceResponse> instance
555  
556 Lists the tags that are assigned to an Amazon Cognito identity pool.
557  
558 A tag is a label that you can apply to identity pools to categorize and
559 manage them in different ways, such as by purpose, owner, environment,
560 or other criteria.
561  
562 You can use this action up to 10 times per second, per account.
563  
564  
565 =head2 LookupDeveloperIdentity
566  
567 =over
568  
569 =item IdentityPoolId => Str
570  
571 =item [DeveloperUserIdentifier => Str]
572  
573 =item [IdentityId => Str]
574  
575 =item [MaxResults => Int]
576  
577 =item [NextToken => Str]
578  
579  
580 =back
581  
582 Each argument is described in detail in: L<Paws::CognitoIdentity::LookupDeveloperIdentity>
583  
584 Returns: a L<Paws::CognitoIdentity::LookupDeveloperIdentityResponse> instance
585  
586 Retrieves the C<IdentityID> associated with a
587 C<DeveloperUserIdentifier> or the list of C<DeveloperUserIdentifier>
588 values associated with an C<IdentityId> for an existing identity.
589 Either C<IdentityID> or C<DeveloperUserIdentifier> must not be null. If
590 you supply only one of these values, the other value will be searched
591 in the database and returned as a part of the response. If you supply
592 both, C<DeveloperUserIdentifier> will be matched against C<IdentityID>.
593 If the values are verified against the database, the response returns
594 both values and is the same as the request. Otherwise a
595 C<ResourceConflictException> is thrown.
596  
597 C<LookupDeveloperIdentity> is intended for low-throughput control plane
598 operations: for example, to enable customer service to locate an
599 identity ID by username. If you are using it for higher-volume
600 operations such as user authentication, your requests are likely to be
601 throttled. GetOpenIdTokenForDeveloperIdentity is a better option for
602 higher-volume operations for user authentication.
603  
604 You must use AWS Developer credentials to call this API.
605  
606  
607 =head2 MergeDeveloperIdentities
608  
609 =over
610  
611 =item DestinationUserIdentifier => Str
612  
613 =item DeveloperProviderName => Str
614  
615 =item IdentityPoolId => Str
616  
617 =item SourceUserIdentifier => Str
618  
619  
620 =back
621  
622 Each argument is described in detail in: L<Paws::CognitoIdentity::MergeDeveloperIdentities>
623  
624 Returns: a L<Paws::CognitoIdentity::MergeDeveloperIdentitiesResponse> instance
625  
626 Merges two users having different C<IdentityId>s, existing in the same
627 identity pool, and identified by the same developer provider. You can
628 use this action to request that discrete users be merged and identified
629 as a single user in the Cognito environment. Cognito associates the
630 given source user (C<SourceUserIdentifier>) with the C<IdentityId> of
631 the C<DestinationUserIdentifier>. Only developer-authenticated users
632 can be merged. If the users to be merged are associated with the same
633 public provider, but as two different users, an exception will be
634 thrown.
635  
636 The number of linked logins is limited to 20. So, the number of linked
637 logins for the source user, C<SourceUserIdentifier>, and the
638 destination user, C<DestinationUserIdentifier>, together should not be
639 larger than 20. Otherwise, an exception will be thrown.
640  
641 You must use AWS Developer credentials to call this API.
642  
643  
644 =head2 SetIdentityPoolRoles
645  
646 =over
647  
648 =item IdentityPoolId => Str
649  
650 =item Roles => L<Paws::CognitoIdentity::RolesMap>
651  
652 =item [RoleMappings => L<Paws::CognitoIdentity::RoleMappingMap>]
653  
654  
655 =back
656  
657 Each argument is described in detail in: L<Paws::CognitoIdentity::SetIdentityPoolRoles>
658  
659 Returns: nothing
660  
661 Sets the roles for an identity pool. These roles are used when making
662 calls to GetCredentialsForIdentity action.
663  
664 You must use AWS Developer credentials to call this API.
665  
666  
667 =head2 SetPrincipalTagAttributeMap
668  
669 =over
670  
671 =item IdentityPoolId => Str
672  
673 =item IdentityProviderName => Str
674  
675 =item [PrincipalTags => L<Paws::CognitoIdentity::PrincipalTags>]
676  
677 =item [UseDefaults => Bool]
678  
679  
680 =back
681  
682 Each argument is described in detail in: L<Paws::CognitoIdentity::SetPrincipalTagAttributeMap>
683  
684 Returns: a L<Paws::CognitoIdentity::SetPrincipalTagAttributeMapResponse> instance
685  
686 You can use this operation to use default (username and clientID)
687 attribute or custom attribute mappings.
688  
689  
690 =head2 TagResource
691  
692 =over
693  
694 =item ResourceArn => Str
695  
696 =item Tags => L<Paws::CognitoIdentity::IdentityPoolTagsType>
697  
698  
699 =back
700  
701 Each argument is described in detail in: L<Paws::CognitoIdentity::TagResource>
702  
703 Returns: a L<Paws::CognitoIdentity::TagResourceResponse> instance
704  
705 Assigns a set of tags to the specified Amazon Cognito identity pool. A
706 tag is a label that you can use to categorize and manage identity pools
707 in different ways, such as by purpose, owner, environment, or other
708 criteria.
709  
710 Each tag consists of a key and value, both of which you define. A key
711 is a general category for more specific values. For example, if you
712 have two versions of an identity pool, one for testing and another for
713 production, you might assign an C<Environment> tag key to both identity
714 pools. The value of this key might be C<Test> for one identity pool and
715 C<Production> for the other.
716  
717 Tags are useful for cost tracking and access control. You can activate
718 your tags so that they appear on the Billing and Cost Management
719 console, where you can track the costs associated with your identity
720 pools. In an IAM policy, you can constrain permissions for identity
721 pools based on specific tags or tag values.
722  
723 You can use this action up to 5 times per second, per account. An
724 identity pool can have as many as 50 tags.
725  
726  
727 =head2 UnlinkDeveloperIdentity
728  
729 =over
730  
731 =item DeveloperProviderName => Str
732  
733 =item DeveloperUserIdentifier => Str
734  
735 =item IdentityId => Str
736  
737 =item IdentityPoolId => Str
738  
739  
740 =back
741  
742 Each argument is described in detail in: L<Paws::CognitoIdentity::UnlinkDeveloperIdentity>
743  
744 Returns: nothing
745  
746 Unlinks a C<DeveloperUserIdentifier> from an existing identity.
747 Unlinked developer users will be considered new identities next time
748 they are seen. If, for a given Cognito identity, you remove all
749 federated identities as well as the developer user identifier, the
750 Cognito identity becomes inaccessible.
751  
752 You must use AWS Developer credentials to call this API.
753  
754  
755 =head2 UnlinkIdentity
756  
757 =over
758  
759 =item IdentityId => Str
760  
761 =item Logins => L<Paws::CognitoIdentity::LoginsMap>
762  
763 =item LoginsToRemove => ArrayRef[Str|Undef]
764  
765  
766 =back
767  
768 Each argument is described in detail in: L<Paws::CognitoIdentity::UnlinkIdentity>
769  
770 Returns: nothing
771  
772 Unlinks a federated identity from an existing account. Unlinked logins
773 will be considered new identities next time they are seen. Removing the
774 last linked login will make this identity inaccessible.
775  
776 This is a public API. You do not need any credentials to call this API.
777  
778  
779 =head2 UntagResource
780  
781 =over
782  
783 =item ResourceArn => Str
784  
785 =item TagKeys => ArrayRef[Str|Undef]
786  
787  
788 =back
789  
790 Each argument is described in detail in: L<Paws::CognitoIdentity::UntagResource>
791  
792 Returns: a L<Paws::CognitoIdentity::UntagResourceResponse> instance
793  
794 Removes the specified tags from the specified Amazon Cognito identity
795 pool. You can use this action up to 5 times per second, per account
796  
797  
798 =head2 UpdateIdentityPool
799  
800 =over
801  
802 =item AllowUnauthenticatedIdentities => Bool
803  
804 =item IdentityPoolId => Str
805  
806 =item IdentityPoolName => Str
807  
808 =item [AllowClassicFlow => Bool]
809  
810 =item [CognitoIdentityProviders => ArrayRef[L<Paws::CognitoIdentity::CognitoIdentityProvider>]]
811  
812 =item [DeveloperProviderName => Str]
813  
814 =item [IdentityPoolTags => L<Paws::CognitoIdentity::IdentityPoolTagsType>]
815  
816 =item [OpenIdConnectProviderARNs => ArrayRef[Str|Undef]]
817  
818 =item [SamlProviderARNs => ArrayRef[Str|Undef]]
819  
820 =item [SupportedLoginProviders => L<Paws::CognitoIdentity::IdentityProviders>]
821  
822  
823 =back
824  
825 Each argument is described in detail in: L<Paws::CognitoIdentity::UpdateIdentityPool>
826  
827 Returns: a L<Paws::CognitoIdentity::IdentityPool> instance
828  
829 Updates an identity pool.
830  
831 You must use AWS Developer credentials to call this API.
832  
833  
834  
835  
836 =head1 PAGINATORS
837  
838 Paginator methods are helpers that repetively call methods that return partial results
839  
840 =head2 ListAllIdentityPools(sub { },MaxResults => Int, [NextToken => Str])
841  
842 =head2 ListAllIdentityPools(MaxResults => Int, [NextToken => Str])
843  
844  
845 If passed a sub as first parameter, it will call the sub for each element found in :
846  
847 - IdentityPools, passing the object as the first parameter, and the string 'IdentityPools' as the second parameter
848  
849 If not, it will return a a L<Paws::CognitoIdentity::ListIdentityPoolsResponse> 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.
850  
851  
852  
853  
854  
855 =head1 SEE ALSO
856  
857 This service class forms part of L<Paws>
858  
859 =head1 BUGS and CONTRIBUTIONS
860  
861 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
862  
863 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
864  
865 =cut
866  
« blib/lib/Paws/MQ.pm ↑ Summary blib/lib/Paws/Net/S3V4Signature.pm »