File Coverage

blib/lib/Paws/IoT.pm
Criterion Covered Total %
statement 3 3 100.0
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 4 4 100.0


line stmt bran cond sub pod time code
1             package Paws::IoT;
2 1     1   5030 use Moose;
  1         2  
  1         8  
3             sub service { 'iot' }
4             sub version { '2015-05-28' }
5             sub flattened_arrays { 0 }
6             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
7             has retry => (is => 'ro', isa => 'HashRef', default => sub {
8             { base => 'rand', type => 'exponential', growth_factor => 2 }
9             });
10             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
11             ] });
12              
13             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller', 'Paws::Net::RestJsonResponse';
14              
15            
16             sub AcceptCertificateTransfer {
17             my $self = shift;
18             my $call_object = $self->new_with_coercions('Paws::IoT::AcceptCertificateTransfer', @_);
19             return $self->caller->do_call($self, $call_object);
20             }
21             sub AttachPrincipalPolicy {
22             my $self = shift;
23             my $call_object = $self->new_with_coercions('Paws::IoT::AttachPrincipalPolicy', @_);
24             return $self->caller->do_call($self, $call_object);
25             }
26             sub AttachThingPrincipal {
27             my $self = shift;
28             my $call_object = $self->new_with_coercions('Paws::IoT::AttachThingPrincipal', @_);
29             return $self->caller->do_call($self, $call_object);
30             }
31             sub CancelCertificateTransfer {
32             my $self = shift;
33             my $call_object = $self->new_with_coercions('Paws::IoT::CancelCertificateTransfer', @_);
34             return $self->caller->do_call($self, $call_object);
35             }
36             sub CreateCertificateFromCsr {
37             my $self = shift;
38             my $call_object = $self->new_with_coercions('Paws::IoT::CreateCertificateFromCsr', @_);
39             return $self->caller->do_call($self, $call_object);
40             }
41             sub CreateKeysAndCertificate {
42             my $self = shift;
43             my $call_object = $self->new_with_coercions('Paws::IoT::CreateKeysAndCertificate', @_);
44             return $self->caller->do_call($self, $call_object);
45             }
46             sub CreatePolicy {
47             my $self = shift;
48             my $call_object = $self->new_with_coercions('Paws::IoT::CreatePolicy', @_);
49             return $self->caller->do_call($self, $call_object);
50             }
51             sub CreatePolicyVersion {
52             my $self = shift;
53             my $call_object = $self->new_with_coercions('Paws::IoT::CreatePolicyVersion', @_);
54             return $self->caller->do_call($self, $call_object);
55             }
56             sub CreateThing {
57             my $self = shift;
58             my $call_object = $self->new_with_coercions('Paws::IoT::CreateThing', @_);
59             return $self->caller->do_call($self, $call_object);
60             }
61             sub CreateThingType {
62             my $self = shift;
63             my $call_object = $self->new_with_coercions('Paws::IoT::CreateThingType', @_);
64             return $self->caller->do_call($self, $call_object);
65             }
66             sub CreateTopicRule {
67             my $self = shift;
68             my $call_object = $self->new_with_coercions('Paws::IoT::CreateTopicRule', @_);
69             return $self->caller->do_call($self, $call_object);
70             }
71             sub DeleteCACertificate {
72             my $self = shift;
73             my $call_object = $self->new_with_coercions('Paws::IoT::DeleteCACertificate', @_);
74             return $self->caller->do_call($self, $call_object);
75             }
76             sub DeleteCertificate {
77             my $self = shift;
78             my $call_object = $self->new_with_coercions('Paws::IoT::DeleteCertificate', @_);
79             return $self->caller->do_call($self, $call_object);
80             }
81             sub DeletePolicy {
82             my $self = shift;
83             my $call_object = $self->new_with_coercions('Paws::IoT::DeletePolicy', @_);
84             return $self->caller->do_call($self, $call_object);
85             }
86             sub DeletePolicyVersion {
87             my $self = shift;
88             my $call_object = $self->new_with_coercions('Paws::IoT::DeletePolicyVersion', @_);
89             return $self->caller->do_call($self, $call_object);
90             }
91             sub DeleteRegistrationCode {
92             my $self = shift;
93             my $call_object = $self->new_with_coercions('Paws::IoT::DeleteRegistrationCode', @_);
94             return $self->caller->do_call($self, $call_object);
95             }
96             sub DeleteThing {
97             my $self = shift;
98             my $call_object = $self->new_with_coercions('Paws::IoT::DeleteThing', @_);
99             return $self->caller->do_call($self, $call_object);
100             }
101             sub DeleteThingType {
102             my $self = shift;
103             my $call_object = $self->new_with_coercions('Paws::IoT::DeleteThingType', @_);
104             return $self->caller->do_call($self, $call_object);
105             }
106             sub DeleteTopicRule {
107             my $self = shift;
108             my $call_object = $self->new_with_coercions('Paws::IoT::DeleteTopicRule', @_);
109             return $self->caller->do_call($self, $call_object);
110             }
111             sub DeprecateThingType {
112             my $self = shift;
113             my $call_object = $self->new_with_coercions('Paws::IoT::DeprecateThingType', @_);
114             return $self->caller->do_call($self, $call_object);
115             }
116             sub DescribeCACertificate {
117             my $self = shift;
118             my $call_object = $self->new_with_coercions('Paws::IoT::DescribeCACertificate', @_);
119             return $self->caller->do_call($self, $call_object);
120             }
121             sub DescribeCertificate {
122             my $self = shift;
123             my $call_object = $self->new_with_coercions('Paws::IoT::DescribeCertificate', @_);
124             return $self->caller->do_call($self, $call_object);
125             }
126             sub DescribeEndpoint {
127             my $self = shift;
128             my $call_object = $self->new_with_coercions('Paws::IoT::DescribeEndpoint', @_);
129             return $self->caller->do_call($self, $call_object);
130             }
131             sub DescribeThing {
132             my $self = shift;
133             my $call_object = $self->new_with_coercions('Paws::IoT::DescribeThing', @_);
134             return $self->caller->do_call($self, $call_object);
135             }
136             sub DescribeThingType {
137             my $self = shift;
138             my $call_object = $self->new_with_coercions('Paws::IoT::DescribeThingType', @_);
139             return $self->caller->do_call($self, $call_object);
140             }
141             sub DetachPrincipalPolicy {
142             my $self = shift;
143             my $call_object = $self->new_with_coercions('Paws::IoT::DetachPrincipalPolicy', @_);
144             return $self->caller->do_call($self, $call_object);
145             }
146             sub DetachThingPrincipal {
147             my $self = shift;
148             my $call_object = $self->new_with_coercions('Paws::IoT::DetachThingPrincipal', @_);
149             return $self->caller->do_call($self, $call_object);
150             }
151             sub DisableTopicRule {
152             my $self = shift;
153             my $call_object = $self->new_with_coercions('Paws::IoT::DisableTopicRule', @_);
154             return $self->caller->do_call($self, $call_object);
155             }
156             sub EnableTopicRule {
157             my $self = shift;
158             my $call_object = $self->new_with_coercions('Paws::IoT::EnableTopicRule', @_);
159             return $self->caller->do_call($self, $call_object);
160             }
161             sub GetLoggingOptions {
162             my $self = shift;
163             my $call_object = $self->new_with_coercions('Paws::IoT::GetLoggingOptions', @_);
164             return $self->caller->do_call($self, $call_object);
165             }
166             sub GetPolicy {
167             my $self = shift;
168             my $call_object = $self->new_with_coercions('Paws::IoT::GetPolicy', @_);
169             return $self->caller->do_call($self, $call_object);
170             }
171             sub GetPolicyVersion {
172             my $self = shift;
173             my $call_object = $self->new_with_coercions('Paws::IoT::GetPolicyVersion', @_);
174             return $self->caller->do_call($self, $call_object);
175             }
176             sub GetRegistrationCode {
177             my $self = shift;
178             my $call_object = $self->new_with_coercions('Paws::IoT::GetRegistrationCode', @_);
179             return $self->caller->do_call($self, $call_object);
180             }
181             sub GetTopicRule {
182             my $self = shift;
183             my $call_object = $self->new_with_coercions('Paws::IoT::GetTopicRule', @_);
184             return $self->caller->do_call($self, $call_object);
185             }
186             sub ListCACertificates {
187             my $self = shift;
188             my $call_object = $self->new_with_coercions('Paws::IoT::ListCACertificates', @_);
189             return $self->caller->do_call($self, $call_object);
190             }
191             sub ListCertificates {
192             my $self = shift;
193             my $call_object = $self->new_with_coercions('Paws::IoT::ListCertificates', @_);
194             return $self->caller->do_call($self, $call_object);
195             }
196             sub ListCertificatesByCA {
197             my $self = shift;
198             my $call_object = $self->new_with_coercions('Paws::IoT::ListCertificatesByCA', @_);
199             return $self->caller->do_call($self, $call_object);
200             }
201             sub ListOutgoingCertificates {
202             my $self = shift;
203             my $call_object = $self->new_with_coercions('Paws::IoT::ListOutgoingCertificates', @_);
204             return $self->caller->do_call($self, $call_object);
205             }
206             sub ListPolicies {
207             my $self = shift;
208             my $call_object = $self->new_with_coercions('Paws::IoT::ListPolicies', @_);
209             return $self->caller->do_call($self, $call_object);
210             }
211             sub ListPolicyPrincipals {
212             my $self = shift;
213             my $call_object = $self->new_with_coercions('Paws::IoT::ListPolicyPrincipals', @_);
214             return $self->caller->do_call($self, $call_object);
215             }
216             sub ListPolicyVersions {
217             my $self = shift;
218             my $call_object = $self->new_with_coercions('Paws::IoT::ListPolicyVersions', @_);
219             return $self->caller->do_call($self, $call_object);
220             }
221             sub ListPrincipalPolicies {
222             my $self = shift;
223             my $call_object = $self->new_with_coercions('Paws::IoT::ListPrincipalPolicies', @_);
224             return $self->caller->do_call($self, $call_object);
225             }
226             sub ListPrincipalThings {
227             my $self = shift;
228             my $call_object = $self->new_with_coercions('Paws::IoT::ListPrincipalThings', @_);
229             return $self->caller->do_call($self, $call_object);
230             }
231             sub ListThingPrincipals {
232             my $self = shift;
233             my $call_object = $self->new_with_coercions('Paws::IoT::ListThingPrincipals', @_);
234             return $self->caller->do_call($self, $call_object);
235             }
236             sub ListThings {
237             my $self = shift;
238             my $call_object = $self->new_with_coercions('Paws::IoT::ListThings', @_);
239             return $self->caller->do_call($self, $call_object);
240             }
241             sub ListThingTypes {
242             my $self = shift;
243             my $call_object = $self->new_with_coercions('Paws::IoT::ListThingTypes', @_);
244             return $self->caller->do_call($self, $call_object);
245             }
246             sub ListTopicRules {
247             my $self = shift;
248             my $call_object = $self->new_with_coercions('Paws::IoT::ListTopicRules', @_);
249             return $self->caller->do_call($self, $call_object);
250             }
251             sub RegisterCACertificate {
252             my $self = shift;
253             my $call_object = $self->new_with_coercions('Paws::IoT::RegisterCACertificate', @_);
254             return $self->caller->do_call($self, $call_object);
255             }
256             sub RegisterCertificate {
257             my $self = shift;
258             my $call_object = $self->new_with_coercions('Paws::IoT::RegisterCertificate', @_);
259             return $self->caller->do_call($self, $call_object);
260             }
261             sub RejectCertificateTransfer {
262             my $self = shift;
263             my $call_object = $self->new_with_coercions('Paws::IoT::RejectCertificateTransfer', @_);
264             return $self->caller->do_call($self, $call_object);
265             }
266             sub ReplaceTopicRule {
267             my $self = shift;
268             my $call_object = $self->new_with_coercions('Paws::IoT::ReplaceTopicRule', @_);
269             return $self->caller->do_call($self, $call_object);
270             }
271             sub SetDefaultPolicyVersion {
272             my $self = shift;
273             my $call_object = $self->new_with_coercions('Paws::IoT::SetDefaultPolicyVersion', @_);
274             return $self->caller->do_call($self, $call_object);
275             }
276             sub SetLoggingOptions {
277             my $self = shift;
278             my $call_object = $self->new_with_coercions('Paws::IoT::SetLoggingOptions', @_);
279             return $self->caller->do_call($self, $call_object);
280             }
281             sub TransferCertificate {
282             my $self = shift;
283             my $call_object = $self->new_with_coercions('Paws::IoT::TransferCertificate', @_);
284             return $self->caller->do_call($self, $call_object);
285             }
286             sub UpdateCACertificate {
287             my $self = shift;
288             my $call_object = $self->new_with_coercions('Paws::IoT::UpdateCACertificate', @_);
289             return $self->caller->do_call($self, $call_object);
290             }
291             sub UpdateCertificate {
292             my $self = shift;
293             my $call_object = $self->new_with_coercions('Paws::IoT::UpdateCertificate', @_);
294             return $self->caller->do_call($self, $call_object);
295             }
296             sub UpdateThing {
297             my $self = shift;
298             my $call_object = $self->new_with_coercions('Paws::IoT::UpdateThing', @_);
299             return $self->caller->do_call($self, $call_object);
300             }
301            
302             sub ListAllCACertificates {
303             my $self = shift;
304              
305             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
306             my $result = $self->ListCACertificates(@_);
307             my $next_result = $result;
308              
309             if (not defined $callback) {
310             while ($next_result->nextMarker) {
311             $next_result = $self->ListCACertificates(@_, marker => $next_result->nextMarker);
312             push @{ $result->certificates }, @{ $next_result->certificates };
313             }
314             return $result;
315             } else {
316             while ($result->nextMarker) {
317             $callback->($_ => 'certificates') foreach (@{ $result->certificates });
318             $result = $self->ListCACertificates(@_, marker => $result->nextMarker);
319             }
320             $callback->($_ => 'certificates') foreach (@{ $result->certificates });
321             }
322              
323             return undef
324             }
325             sub ListAllCertificates {
326             my $self = shift;
327              
328             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
329             my $result = $self->ListCertificates(@_);
330             my $next_result = $result;
331              
332             if (not defined $callback) {
333             while ($next_result->nextMarker) {
334             $next_result = $self->ListCertificates(@_, marker => $next_result->nextMarker);
335             push @{ $result->certificates }, @{ $next_result->certificates };
336             }
337             return $result;
338             } else {
339             while ($result->nextMarker) {
340             $callback->($_ => 'certificates') foreach (@{ $result->certificates });
341             $result = $self->ListCertificates(@_, marker => $result->nextMarker);
342             }
343             $callback->($_ => 'certificates') foreach (@{ $result->certificates });
344             }
345              
346             return undef
347             }
348             sub ListAllCertificatesByCA {
349             my $self = shift;
350              
351             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
352             my $result = $self->ListCertificatesByCA(@_);
353             my $next_result = $result;
354              
355             if (not defined $callback) {
356             while ($next_result->nextMarker) {
357             $next_result = $self->ListCertificatesByCA(@_, marker => $next_result->nextMarker);
358             push @{ $result->certificates }, @{ $next_result->certificates };
359             }
360             return $result;
361             } else {
362             while ($result->nextMarker) {
363             $callback->($_ => 'certificates') foreach (@{ $result->certificates });
364             $result = $self->ListCertificatesByCA(@_, marker => $result->nextMarker);
365             }
366             $callback->($_ => 'certificates') foreach (@{ $result->certificates });
367             }
368              
369             return undef
370             }
371             sub ListAllOutgoingCertificates {
372             my $self = shift;
373              
374             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
375             my $result = $self->ListOutgoingCertificates(@_);
376             my $next_result = $result;
377              
378             if (not defined $callback) {
379             while ($next_result->nextMarker) {
380             $next_result = $self->ListOutgoingCertificates(@_, marker => $next_result->nextMarker);
381             push @{ $result->outgoingCertificates }, @{ $next_result->outgoingCertificates };
382             }
383             return $result;
384             } else {
385             while ($result->nextMarker) {
386             $callback->($_ => 'outgoingCertificates') foreach (@{ $result->outgoingCertificates });
387             $result = $self->ListOutgoingCertificates(@_, marker => $result->nextMarker);
388             }
389             $callback->($_ => 'outgoingCertificates') foreach (@{ $result->outgoingCertificates });
390             }
391              
392             return undef
393             }
394             sub ListAllPolicies {
395             my $self = shift;
396              
397             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
398             my $result = $self->ListPolicies(@_);
399             my $next_result = $result;
400              
401             if (not defined $callback) {
402             while ($next_result->nextMarker) {
403             $next_result = $self->ListPolicies(@_, marker => $next_result->nextMarker);
404             push @{ $result->policies }, @{ $next_result->policies };
405             }
406             return $result;
407             } else {
408             while ($result->nextMarker) {
409             $callback->($_ => 'policies') foreach (@{ $result->policies });
410             $result = $self->ListPolicies(@_, marker => $result->nextMarker);
411             }
412             $callback->($_ => 'policies') foreach (@{ $result->policies });
413             }
414              
415             return undef
416             }
417             sub ListAllPolicyPrincipals {
418             my $self = shift;
419              
420             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
421             my $result = $self->ListPolicyPrincipals(@_);
422             my $next_result = $result;
423              
424             if (not defined $callback) {
425             while ($next_result->nextMarker) {
426             $next_result = $self->ListPolicyPrincipals(@_, marker => $next_result->nextMarker);
427             push @{ $result->principals }, @{ $next_result->principals };
428             }
429             return $result;
430             } else {
431             while ($result->nextMarker) {
432             $callback->($_ => 'principals') foreach (@{ $result->principals });
433             $result = $self->ListPolicyPrincipals(@_, marker => $result->nextMarker);
434             }
435             $callback->($_ => 'principals') foreach (@{ $result->principals });
436             }
437              
438             return undef
439             }
440             sub ListAllPrincipalPolicies {
441             my $self = shift;
442              
443             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
444             my $result = $self->ListPrincipalPolicies(@_);
445             my $next_result = $result;
446              
447             if (not defined $callback) {
448             while ($next_result->nextMarker) {
449             $next_result = $self->ListPrincipalPolicies(@_, marker => $next_result->nextMarker);
450             push @{ $result->policies }, @{ $next_result->policies };
451             }
452             return $result;
453             } else {
454             while ($result->nextMarker) {
455             $callback->($_ => 'policies') foreach (@{ $result->policies });
456             $result = $self->ListPrincipalPolicies(@_, marker => $result->nextMarker);
457             }
458             $callback->($_ => 'policies') foreach (@{ $result->policies });
459             }
460              
461             return undef
462             }
463             sub ListAllPrincipalThings {
464             my $self = shift;
465              
466             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
467             my $result = $self->ListPrincipalThings(@_);
468             my $next_result = $result;
469              
470             if (not defined $callback) {
471             while ($next_result->nextToken) {
472             $next_result = $self->ListPrincipalThings(@_, nextToken => $next_result->nextToken);
473             push @{ $result->things }, @{ $next_result->things };
474             }
475             return $result;
476             } else {
477             while ($result->nextToken) {
478             $callback->($_ => 'things') foreach (@{ $result->things });
479             $result = $self->ListPrincipalThings(@_, nextToken => $result->nextToken);
480             }
481             $callback->($_ => 'things') foreach (@{ $result->things });
482             }
483              
484             return undef
485             }
486             sub ListAllThings {
487             my $self = shift;
488              
489             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
490             my $result = $self->ListThings(@_);
491             my $next_result = $result;
492              
493             if (not defined $callback) {
494             while ($next_result->nextToken) {
495             $next_result = $self->ListThings(@_, nextToken => $next_result->nextToken);
496             push @{ $result->things }, @{ $next_result->things };
497             }
498             return $result;
499             } else {
500             while ($result->nextToken) {
501             $callback->($_ => 'things') foreach (@{ $result->things });
502             $result = $self->ListThings(@_, nextToken => $result->nextToken);
503             }
504             $callback->($_ => 'things') foreach (@{ $result->things });
505             }
506              
507             return undef
508             }
509             sub ListAllThingTypes {
510             my $self = shift;
511              
512             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
513             my $result = $self->ListThingTypes(@_);
514             my $next_result = $result;
515              
516             if (not defined $callback) {
517             while ($next_result->nextToken) {
518             $next_result = $self->ListThingTypes(@_, nextToken => $next_result->nextToken);
519             push @{ $result->thingTypes }, @{ $next_result->thingTypes };
520             }
521             return $result;
522             } else {
523             while ($result->nextToken) {
524             $callback->($_ => 'thingTypes') foreach (@{ $result->thingTypes });
525             $result = $self->ListThingTypes(@_, nextToken => $result->nextToken);
526             }
527             $callback->($_ => 'thingTypes') foreach (@{ $result->thingTypes });
528             }
529              
530             return undef
531             }
532             sub ListAllTopicRules {
533             my $self = shift;
534              
535             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
536             my $result = $self->ListTopicRules(@_);
537             my $next_result = $result;
538              
539             if (not defined $callback) {
540             while ($next_result->nextToken) {
541             $next_result = $self->ListTopicRules(@_, nextToken => $next_result->nextToken);
542             push @{ $result->rules }, @{ $next_result->rules };
543             }
544             return $result;
545             } else {
546             while ($result->nextToken) {
547             $callback->($_ => 'rules') foreach (@{ $result->rules });
548             $result = $self->ListTopicRules(@_, nextToken => $result->nextToken);
549             }
550             $callback->($_ => 'rules') foreach (@{ $result->rules });
551             }
552              
553             return undef
554             }
555              
556              
557             sub operations { qw/AcceptCertificateTransfer AttachPrincipalPolicy AttachThingPrincipal CancelCertificateTransfer CreateCertificateFromCsr CreateKeysAndCertificate CreatePolicy CreatePolicyVersion CreateThing CreateThingType CreateTopicRule DeleteCACertificate DeleteCertificate DeletePolicy DeletePolicyVersion DeleteRegistrationCode DeleteThing DeleteThingType DeleteTopicRule DeprecateThingType DescribeCACertificate DescribeCertificate DescribeEndpoint DescribeThing DescribeThingType DetachPrincipalPolicy DetachThingPrincipal DisableTopicRule EnableTopicRule GetLoggingOptions GetPolicy GetPolicyVersion GetRegistrationCode GetTopicRule ListCACertificates ListCertificates ListCertificatesByCA ListOutgoingCertificates ListPolicies ListPolicyPrincipals ListPolicyVersions ListPrincipalPolicies ListPrincipalThings ListThingPrincipals ListThings ListThingTypes ListTopicRules RegisterCACertificate RegisterCertificate RejectCertificateTransfer ReplaceTopicRule SetDefaultPolicyVersion SetLoggingOptions TransferCertificate UpdateCACertificate UpdateCertificate UpdateThing / }
558              
559             1;
560              
561             ### main pod documentation begin ###
562              
563             =head1 NAME
564              
565             Paws::IoT - Perl Interface to AWS AWS IoT
566              
567             =head1 SYNOPSIS
568              
569             use Paws;
570              
571             my $obj = Paws->service('IoT');
572             my $res = $obj->Method(
573             Arg1 => $val1,
574             Arg2 => [ 'V1', 'V2' ],
575             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
576             # of the arguments type
577             Arg3 => { Att1 => 'Val1' },
578             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
579             # the constructor of the arguments type
580             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
581             );
582              
583             =head1 DESCRIPTION
584              
585             AWS IoT
586              
587             AWS IoT provides secure, bi-directional communication between
588             Internet-connected things (such as sensors, actuators, embedded
589             devices, or smart appliances) and the AWS cloud. You can discover your
590             custom IoT-Data endpoint to communicate with, configure rules for data
591             processing and integration with other services, organize resources
592             associated with each thing (Thing Registry), configure logging, and
593             create and manage policies and credentials to authenticate things.
594              
595             For more information about how AWS IoT works, see the Developer Guide.
596              
597             =head1 METHODS
598              
599             =head2 AcceptCertificateTransfer(CertificateId => Str, [SetAsActive => Bool])
600              
601             Each argument is described in detail in: L<Paws::IoT::AcceptCertificateTransfer>
602              
603             Returns: nothing
604              
605             Accepts a pending certificate transfer. The default state of the
606             certificate is INACTIVE.
607              
608             To check for pending certificate transfers, call ListCertificates to
609             enumerate your certificates.
610              
611              
612             =head2 AttachPrincipalPolicy(PolicyName => Str, Principal => Str)
613              
614             Each argument is described in detail in: L<Paws::IoT::AttachPrincipalPolicy>
615              
616             Returns: nothing
617              
618             Attaches the specified policy to the specified principal (certificate
619             or other credential).
620              
621              
622             =head2 AttachThingPrincipal(Principal => Str, ThingName => Str)
623              
624             Each argument is described in detail in: L<Paws::IoT::AttachThingPrincipal>
625              
626             Returns: a L<Paws::IoT::AttachThingPrincipalResponse> instance
627              
628             Attaches the specified principal to the specified thing.
629              
630              
631             =head2 CancelCertificateTransfer(CertificateId => Str)
632              
633             Each argument is described in detail in: L<Paws::IoT::CancelCertificateTransfer>
634              
635             Returns: nothing
636              
637             Cancels a pending transfer for the specified certificate.
638              
639             B<Note> Only the transfer source account can use this operation to
640             cancel a transfer. (Transfer destinations can use
641             RejectCertificateTransfer instead.) After transfer, AWS IoT returns the
642             certificate to the source account in the INACTIVE state. After the
643             destination account has accepted the transfer, the transfer cannot be
644             cancelled.
645              
646             After a certificate transfer is cancelled, the status of the
647             certificate changes from PENDING_TRANSFER to INACTIVE.
648              
649              
650             =head2 CreateCertificateFromCsr(CertificateSigningRequest => Str, [SetAsActive => Bool])
651              
652             Each argument is described in detail in: L<Paws::IoT::CreateCertificateFromCsr>
653              
654             Returns: a L<Paws::IoT::CreateCertificateFromCsrResponse> instance
655              
656             Creates an X.509 certificate using the specified certificate signing
657             request.
658              
659             B<Note:> The CSR must include a public key that is either an RSA key
660             with a length of at least 2048 bits or an ECC key from NIST P-256 or
661             NIST P-384 curves.
662              
663             B<Note:> Reusing the same certificate signing request (CSR) results in
664             a distinct certificate.
665              
666             You can create multiple certificates in a batch by creating a
667             directory, copying multiple .csr files into that directory, and then
668             specifying that directory on the command line. The following commands
669             show how to create a batch of certificates given a batch of CSRs.
670              
671             Assuming a set of CSRs are located inside of the directory
672             my-csr-directory:
673              
674             On Linux and OS X, the command is:
675              
676             $ ls my-csr-directory/ | xargs -I {} aws iot
677             create-certificate-from-csr --certificate-signing-request
678             file://my-csr-directory/{}
679              
680             This command lists all of the CSRs in my-csr-directory and pipes each
681             CSR file name to the aws iot create-certificate-from-csr AWS CLI
682             command to create a certificate for the corresponding CSR.
683              
684             The aws iot create-certificate-from-csr part of the command can also be
685             run in parallel to speed up the certificate creation process:
686              
687             $ ls my-csr-directory/ | xargs -P 10 -I {} aws iot
688             create-certificate-from-csr --certificate-signing-request
689             file://my-csr-directory/{}
690              
691             On Windows PowerShell, the command to create certificates for all CSRs
692             in my-csr-directory is:
693              
694             E<gt> ls -Name my-csr-directory | %{aws iot create-certificate-from-csr
695             --certificate-signing-request file://my-csr-directory/$_}
696              
697             On a Windows command prompt, the command to create certificates for all
698             CSRs in my-csr-directory is:
699              
700             E<gt> forfiles /p my-csr-directory /c "cmd /c aws iot
701             create-certificate-from-csr --certificate-signing-request file://@path"
702              
703              
704             =head2 CreateKeysAndCertificate([SetAsActive => Bool])
705              
706             Each argument is described in detail in: L<Paws::IoT::CreateKeysAndCertificate>
707              
708             Returns: a L<Paws::IoT::CreateKeysAndCertificateResponse> instance
709              
710             Creates a 2048-bit RSA key pair and issues an X.509 certificate using
711             the issued public key.
712              
713             B<Note> This is the only time AWS IoT issues the private key for this
714             certificate, so it is important to keep it in a secure location.
715              
716              
717             =head2 CreatePolicy(PolicyDocument => Str, PolicyName => Str)
718              
719             Each argument is described in detail in: L<Paws::IoT::CreatePolicy>
720              
721             Returns: a L<Paws::IoT::CreatePolicyResponse> instance
722              
723             Creates an AWS IoT policy.
724              
725             The created policy is the default version for the policy. This
726             operation creates a policy version with a version identifier of B<1>
727             and sets B<1> as the policy's default version.
728              
729              
730             =head2 CreatePolicyVersion(PolicyDocument => Str, PolicyName => Str, [SetAsDefault => Bool])
731              
732             Each argument is described in detail in: L<Paws::IoT::CreatePolicyVersion>
733              
734             Returns: a L<Paws::IoT::CreatePolicyVersionResponse> instance
735              
736             Creates a new version of the specified AWS IoT policy. To update a
737             policy, create a new policy version. A managed policy can have up to
738             five versions. If the policy has five versions, you must use
739             DeletePolicyVersion to delete an existing version before you create a
740             new one.
741              
742             Optionally, you can set the new version as the policy's default
743             version. The default version is the operative version (that is, the
744             version that is in effect for the certificates to which the policy is
745             attached).
746              
747              
748             =head2 CreateThing(ThingName => Str, [AttributePayload => L<Paws::IoT::AttributePayload>, ThingTypeName => Str])
749              
750             Each argument is described in detail in: L<Paws::IoT::CreateThing>
751              
752             Returns: a L<Paws::IoT::CreateThingResponse> instance
753              
754             Creates a thing record in the thing registry.
755              
756              
757             =head2 CreateThingType(ThingTypeName => Str, [ThingTypeProperties => L<Paws::IoT::ThingTypeProperties>])
758              
759             Each argument is described in detail in: L<Paws::IoT::CreateThingType>
760              
761             Returns: a L<Paws::IoT::CreateThingTypeResponse> instance
762              
763             Creates a new thing type.
764              
765              
766             =head2 CreateTopicRule(RuleName => Str, TopicRulePayload => L<Paws::IoT::TopicRulePayload>)
767              
768             Each argument is described in detail in: L<Paws::IoT::CreateTopicRule>
769              
770             Returns: nothing
771              
772             Creates a rule. Creating rules is an administrator-level action. Any
773             user who has permission to create rules will be able to access data
774             processed by the rule.
775              
776              
777             =head2 DeleteCACertificate(CertificateId => Str)
778              
779             Each argument is described in detail in: L<Paws::IoT::DeleteCACertificate>
780              
781             Returns: a L<Paws::IoT::DeleteCACertificateResponse> instance
782              
783             Deletes a registered CA certificate.
784              
785              
786             =head2 DeleteCertificate(CertificateId => Str)
787              
788             Each argument is described in detail in: L<Paws::IoT::DeleteCertificate>
789              
790             Returns: nothing
791              
792             Deletes the specified certificate.
793              
794             A certificate cannot be deleted if it has a policy attached to it or if
795             its status is set to ACTIVE. To delete a certificate, first use the
796             DetachPrincipalPolicy API to detach all policies. Next, use the
797             UpdateCertificate API to set the certificate to the INACTIVE status.
798              
799              
800             =head2 DeletePolicy(PolicyName => Str)
801              
802             Each argument is described in detail in: L<Paws::IoT::DeletePolicy>
803              
804             Returns: nothing
805              
806             Deletes the specified policy.
807              
808             A policy cannot be deleted if it has non-default versions or it is
809             attached to any certificate.
810              
811             To delete a policy, use the DeletePolicyVersion API to delete all
812             non-default versions of the policy; use the DetachPrincipalPolicy API
813             to detach the policy from any certificate; and then use the
814             DeletePolicy API to delete the policy.
815              
816             When a policy is deleted using DeletePolicy, its default version is
817             deleted with it.
818              
819              
820             =head2 DeletePolicyVersion(PolicyName => Str, PolicyVersionId => Str)
821              
822             Each argument is described in detail in: L<Paws::IoT::DeletePolicyVersion>
823              
824             Returns: nothing
825              
826             Deletes the specified version of the specified policy. You cannot
827             delete the default version of a policy using this API. To delete the
828             default version of a policy, use DeletePolicy. To find out which
829             version of a policy is marked as the default version, use
830             ListPolicyVersions.
831              
832              
833             =head2 DeleteRegistrationCode()
834              
835             Each argument is described in detail in: L<Paws::IoT::DeleteRegistrationCode>
836              
837             Returns: a L<Paws::IoT::DeleteRegistrationCodeResponse> instance
838              
839             Deletes a CA certificate registration code.
840              
841              
842             =head2 DeleteThing(ThingName => Str, [ExpectedVersion => Int])
843              
844             Each argument is described in detail in: L<Paws::IoT::DeleteThing>
845              
846             Returns: a L<Paws::IoT::DeleteThingResponse> instance
847              
848             Deletes the specified thing.
849              
850              
851             =head2 DeleteThingType(ThingTypeName => Str)
852              
853             Each argument is described in detail in: L<Paws::IoT::DeleteThingType>
854              
855             Returns: a L<Paws::IoT::DeleteThingTypeResponse> instance
856              
857             Deletes the specified thing type . You cannot delete a thing type if it
858             has things associated with it. To delete a thing type, first mark it as
859             deprecated by calling DeprecateThingType, then remove any associated
860             things by calling UpdateThing to change the thing type on any
861             associated thing, and finally use DeleteThingType to delete the thing
862             type.
863              
864              
865             =head2 DeleteTopicRule(RuleName => Str)
866              
867             Each argument is described in detail in: L<Paws::IoT::DeleteTopicRule>
868              
869             Returns: nothing
870              
871             Deletes the specified rule.
872              
873              
874             =head2 DeprecateThingType(ThingTypeName => Str, [UndoDeprecate => Bool])
875              
876             Each argument is described in detail in: L<Paws::IoT::DeprecateThingType>
877              
878             Returns: a L<Paws::IoT::DeprecateThingTypeResponse> instance
879              
880             Deprecates a thing type. You can not associate new things with
881             deprecated thing type.
882              
883              
884             =head2 DescribeCACertificate(CertificateId => Str)
885              
886             Each argument is described in detail in: L<Paws::IoT::DescribeCACertificate>
887              
888             Returns: a L<Paws::IoT::DescribeCACertificateResponse> instance
889              
890             Describes a registered CA certificate.
891              
892              
893             =head2 DescribeCertificate(CertificateId => Str)
894              
895             Each argument is described in detail in: L<Paws::IoT::DescribeCertificate>
896              
897             Returns: a L<Paws::IoT::DescribeCertificateResponse> instance
898              
899             Gets information about the specified certificate.
900              
901              
902             =head2 DescribeEndpoint()
903              
904             Each argument is described in detail in: L<Paws::IoT::DescribeEndpoint>
905              
906             Returns: a L<Paws::IoT::DescribeEndpointResponse> instance
907              
908             Returns a unique endpoint specific to the AWS account making the call.
909              
910              
911             =head2 DescribeThing(ThingName => Str)
912              
913             Each argument is described in detail in: L<Paws::IoT::DescribeThing>
914              
915             Returns: a L<Paws::IoT::DescribeThingResponse> instance
916              
917             Gets information about the specified thing.
918              
919              
920             =head2 DescribeThingType(ThingTypeName => Str)
921              
922             Each argument is described in detail in: L<Paws::IoT::DescribeThingType>
923              
924             Returns: a L<Paws::IoT::DescribeThingTypeResponse> instance
925              
926             Gets information about the specified thing type.
927              
928              
929             =head2 DetachPrincipalPolicy(PolicyName => Str, Principal => Str)
930              
931             Each argument is described in detail in: L<Paws::IoT::DetachPrincipalPolicy>
932              
933             Returns: nothing
934              
935             Removes the specified policy from the specified certificate.
936              
937              
938             =head2 DetachThingPrincipal(Principal => Str, ThingName => Str)
939              
940             Each argument is described in detail in: L<Paws::IoT::DetachThingPrincipal>
941              
942             Returns: a L<Paws::IoT::DetachThingPrincipalResponse> instance
943              
944             Detaches the specified principal from the specified thing.
945              
946              
947             =head2 DisableTopicRule(RuleName => Str)
948              
949             Each argument is described in detail in: L<Paws::IoT::DisableTopicRule>
950              
951             Returns: nothing
952              
953             Disables the specified rule.
954              
955              
956             =head2 EnableTopicRule(RuleName => Str)
957              
958             Each argument is described in detail in: L<Paws::IoT::EnableTopicRule>
959              
960             Returns: nothing
961              
962             Enables the specified rule.
963              
964              
965             =head2 GetLoggingOptions()
966              
967             Each argument is described in detail in: L<Paws::IoT::GetLoggingOptions>
968              
969             Returns: a L<Paws::IoT::GetLoggingOptionsResponse> instance
970              
971             Gets the logging options.
972              
973              
974             =head2 GetPolicy(PolicyName => Str)
975              
976             Each argument is described in detail in: L<Paws::IoT::GetPolicy>
977              
978             Returns: a L<Paws::IoT::GetPolicyResponse> instance
979              
980             Gets information about the specified policy with the policy document of
981             the default version.
982              
983              
984             =head2 GetPolicyVersion(PolicyName => Str, PolicyVersionId => Str)
985              
986             Each argument is described in detail in: L<Paws::IoT::GetPolicyVersion>
987              
988             Returns: a L<Paws::IoT::GetPolicyVersionResponse> instance
989              
990             Gets information about the specified policy version.
991              
992              
993             =head2 GetRegistrationCode()
994              
995             Each argument is described in detail in: L<Paws::IoT::GetRegistrationCode>
996              
997             Returns: a L<Paws::IoT::GetRegistrationCodeResponse> instance
998              
999             Gets a registration code used to register a CA certificate with AWS
1000             IoT.
1001              
1002              
1003             =head2 GetTopicRule(RuleName => Str)
1004              
1005             Each argument is described in detail in: L<Paws::IoT::GetTopicRule>
1006              
1007             Returns: a L<Paws::IoT::GetTopicRuleResponse> instance
1008              
1009             Gets information about the specified rule.
1010              
1011              
1012             =head2 ListCACertificates([AscendingOrder => Bool, Marker => Str, PageSize => Int])
1013              
1014             Each argument is described in detail in: L<Paws::IoT::ListCACertificates>
1015              
1016             Returns: a L<Paws::IoT::ListCACertificatesResponse> instance
1017              
1018             Lists the CA certificates registered for your AWS account.
1019              
1020             The results are paginated with a default page size of 25. You can use
1021             the returned marker to retrieve additional results.
1022              
1023              
1024             =head2 ListCertificates([AscendingOrder => Bool, Marker => Str, PageSize => Int])
1025              
1026             Each argument is described in detail in: L<Paws::IoT::ListCertificates>
1027              
1028             Returns: a L<Paws::IoT::ListCertificatesResponse> instance
1029              
1030             Lists the certificates registered in your AWS account.
1031              
1032             The results are paginated with a default page size of 25. You can use
1033             the returned marker to retrieve additional results.
1034              
1035              
1036             =head2 ListCertificatesByCA(CaCertificateId => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1037              
1038             Each argument is described in detail in: L<Paws::IoT::ListCertificatesByCA>
1039              
1040             Returns: a L<Paws::IoT::ListCertificatesByCAResponse> instance
1041              
1042             List the device certificates signed by the specified CA certificate.
1043              
1044              
1045             =head2 ListOutgoingCertificates([AscendingOrder => Bool, Marker => Str, PageSize => Int])
1046              
1047             Each argument is described in detail in: L<Paws::IoT::ListOutgoingCertificates>
1048              
1049             Returns: a L<Paws::IoT::ListOutgoingCertificatesResponse> instance
1050              
1051             Lists certificates that are being transfered but not yet accepted.
1052              
1053              
1054             =head2 ListPolicies([AscendingOrder => Bool, Marker => Str, PageSize => Int])
1055              
1056             Each argument is described in detail in: L<Paws::IoT::ListPolicies>
1057              
1058             Returns: a L<Paws::IoT::ListPoliciesResponse> instance
1059              
1060             Lists your policies.
1061              
1062              
1063             =head2 ListPolicyPrincipals(PolicyName => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1064              
1065             Each argument is described in detail in: L<Paws::IoT::ListPolicyPrincipals>
1066              
1067             Returns: a L<Paws::IoT::ListPolicyPrincipalsResponse> instance
1068              
1069             Lists the principals associated with the specified policy.
1070              
1071              
1072             =head2 ListPolicyVersions(PolicyName => Str)
1073              
1074             Each argument is described in detail in: L<Paws::IoT::ListPolicyVersions>
1075              
1076             Returns: a L<Paws::IoT::ListPolicyVersionsResponse> instance
1077              
1078             Lists the versions of the specified policy and identifies the default
1079             version.
1080              
1081              
1082             =head2 ListPrincipalPolicies(Principal => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1083              
1084             Each argument is described in detail in: L<Paws::IoT::ListPrincipalPolicies>
1085              
1086             Returns: a L<Paws::IoT::ListPrincipalPoliciesResponse> instance
1087              
1088             Lists the policies attached to the specified principal. If you use an
1089             Cognito identity, the ID must be in AmazonCognito Identity format.
1090              
1091              
1092             =head2 ListPrincipalThings(Principal => Str, [MaxResults => Int, NextToken => Str])
1093              
1094             Each argument is described in detail in: L<Paws::IoT::ListPrincipalThings>
1095              
1096             Returns: a L<Paws::IoT::ListPrincipalThingsResponse> instance
1097              
1098             Lists the things associated with the specified principal.
1099              
1100              
1101             =head2 ListThingPrincipals(ThingName => Str)
1102              
1103             Each argument is described in detail in: L<Paws::IoT::ListThingPrincipals>
1104              
1105             Returns: a L<Paws::IoT::ListThingPrincipalsResponse> instance
1106              
1107             Lists the principals associated with the specified thing.
1108              
1109              
1110             =head2 ListThings([AttributeName => Str, AttributeValue => Str, MaxResults => Int, NextToken => Str, ThingTypeName => Str])
1111              
1112             Each argument is described in detail in: L<Paws::IoT::ListThings>
1113              
1114             Returns: a L<Paws::IoT::ListThingsResponse> instance
1115              
1116             Lists your things. Use the B<attributeName> and B<attributeValue>
1117             parameters to filter your things. For example, calling C<ListThings>
1118             with attributeName=Color and attributeValue=Red retrieves all things in
1119             the registry that contain an attribute B<Color> with the value B<Red>.
1120              
1121              
1122             =head2 ListThingTypes([MaxResults => Int, NextToken => Str, ThingTypeName => Str])
1123              
1124             Each argument is described in detail in: L<Paws::IoT::ListThingTypes>
1125              
1126             Returns: a L<Paws::IoT::ListThingTypesResponse> instance
1127              
1128             Lists the existing thing types.
1129              
1130              
1131             =head2 ListTopicRules([MaxResults => Int, NextToken => Str, RuleDisabled => Bool, Topic => Str])
1132              
1133             Each argument is described in detail in: L<Paws::IoT::ListTopicRules>
1134              
1135             Returns: a L<Paws::IoT::ListTopicRulesResponse> instance
1136              
1137             Lists the rules for the specific topic.
1138              
1139              
1140             =head2 RegisterCACertificate(CaCertificate => Str, VerificationCertificate => Str, [AllowAutoRegistration => Bool, SetAsActive => Bool])
1141              
1142             Each argument is described in detail in: L<Paws::IoT::RegisterCACertificate>
1143              
1144             Returns: a L<Paws::IoT::RegisterCACertificateResponse> instance
1145              
1146             Registers a CA certificate with AWS IoT. This CA certificate can then
1147             be used to sign device certificates, which can be then registered with
1148             AWS IoT. You can register up to 10 CA certificates per AWS account that
1149             have the same subject field. This enables you to have up to 10
1150             certificate authorities sign your device certificates. If you have more
1151             than one CA certificate registered, make sure you pass the CA
1152             certificate when you register your device certificates with the
1153             RegisterCertificate API.
1154              
1155              
1156             =head2 RegisterCertificate(CertificatePem => Str, [CaCertificatePem => Str, SetAsActive => Bool, Status => Str])
1157              
1158             Each argument is described in detail in: L<Paws::IoT::RegisterCertificate>
1159              
1160             Returns: a L<Paws::IoT::RegisterCertificateResponse> instance
1161              
1162             Registers a device certificate with AWS IoT. If you have more than one
1163             CA certificate that has the same subject field, you must specify the CA
1164             certificate that was used to sign the device certificate being
1165             registered.
1166              
1167              
1168             =head2 RejectCertificateTransfer(CertificateId => Str, [RejectReason => Str])
1169              
1170             Each argument is described in detail in: L<Paws::IoT::RejectCertificateTransfer>
1171              
1172             Returns: nothing
1173              
1174             Rejects a pending certificate transfer. After AWS IoT rejects a
1175             certificate transfer, the certificate status changes from
1176             B<PENDING_TRANSFER> to B<INACTIVE>.
1177              
1178             To check for pending certificate transfers, call ListCertificates to
1179             enumerate your certificates.
1180              
1181             This operation can only be called by the transfer destination. After it
1182             is called, the certificate will be returned to the source's account in
1183             the INACTIVE state.
1184              
1185              
1186             =head2 ReplaceTopicRule(RuleName => Str, TopicRulePayload => L<Paws::IoT::TopicRulePayload>)
1187              
1188             Each argument is described in detail in: L<Paws::IoT::ReplaceTopicRule>
1189              
1190             Returns: nothing
1191              
1192             Replaces the specified rule. You must specify all parameters for the
1193             new rule. Creating rules is an administrator-level action. Any user who
1194             has permission to create rules will be able to access data processed by
1195             the rule.
1196              
1197              
1198             =head2 SetDefaultPolicyVersion(PolicyName => Str, PolicyVersionId => Str)
1199              
1200             Each argument is described in detail in: L<Paws::IoT::SetDefaultPolicyVersion>
1201              
1202             Returns: nothing
1203              
1204             Sets the specified version of the specified policy as the policy's
1205             default (operative) version. This action affects all certificates to
1206             which the policy is attached. To list the principals the policy is
1207             attached to, use the ListPrincipalPolicy API.
1208              
1209              
1210             =head2 SetLoggingOptions(LoggingOptionsPayload => L<Paws::IoT::LoggingOptionsPayload>)
1211              
1212             Each argument is described in detail in: L<Paws::IoT::SetLoggingOptions>
1213              
1214             Returns: nothing
1215              
1216             Sets the logging options.
1217              
1218              
1219             =head2 TransferCertificate(CertificateId => Str, TargetAwsAccount => Str, [TransferMessage => Str])
1220              
1221             Each argument is described in detail in: L<Paws::IoT::TransferCertificate>
1222              
1223             Returns: a L<Paws::IoT::TransferCertificateResponse> instance
1224              
1225             Transfers the specified certificate to the specified AWS account.
1226              
1227             You can cancel the transfer until it is acknowledged by the recipient.
1228              
1229             No notification is sent to the transfer destination's account. It is up
1230             to the caller to notify the transfer target.
1231              
1232             The certificate being transferred must not be in the ACTIVE state. You
1233             can use the UpdateCertificate API to deactivate it.
1234              
1235             The certificate must not have any policies attached to it. You can use
1236             the DetachPrincipalPolicy API to detach them.
1237              
1238              
1239             =head2 UpdateCACertificate(CertificateId => Str, [NewAutoRegistrationStatus => Str, NewStatus => Str])
1240              
1241             Each argument is described in detail in: L<Paws::IoT::UpdateCACertificate>
1242              
1243             Returns: nothing
1244              
1245             Updates a registered CA certificate.
1246              
1247              
1248             =head2 UpdateCertificate(CertificateId => Str, NewStatus => Str)
1249              
1250             Each argument is described in detail in: L<Paws::IoT::UpdateCertificate>
1251              
1252             Returns: nothing
1253              
1254             Updates the status of the specified certificate. This operation is
1255             idempotent.
1256              
1257             Moving a certificate from the ACTIVE state (including REVOKED) will not
1258             disconnect currently connected devices, but these devices will be
1259             unable to reconnect.
1260              
1261             The ACTIVE state is required to authenticate devices connecting to AWS
1262             IoT using a certificate.
1263              
1264              
1265             =head2 UpdateThing(ThingName => Str, [AttributePayload => L<Paws::IoT::AttributePayload>, ExpectedVersion => Int, RemoveThingType => Bool, ThingTypeName => Str])
1266              
1267             Each argument is described in detail in: L<Paws::IoT::UpdateThing>
1268              
1269             Returns: a L<Paws::IoT::UpdateThingResponse> instance
1270              
1271             Updates the data for a thing.
1272              
1273              
1274              
1275              
1276             =head1 PAGINATORS
1277              
1278             Paginator methods are helpers that repetively call methods that return partial results
1279              
1280             =head2 ListAllCACertificates(sub { },[AscendingOrder => Bool, Marker => Str, PageSize => Int])
1281              
1282             =head2 ListAllCACertificates([AscendingOrder => Bool, Marker => Str, PageSize => Int])
1283              
1284              
1285             If passed a sub as first parameter, it will call the sub for each element found in :
1286              
1287             - certificates, passing the object as the first parameter, and the string 'certificates' as the second parameter
1288              
1289             If not, it will return a a L<Paws::IoT::ListCACertificatesResponse> 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.
1290              
1291              
1292             =head2 ListAllCertificates(sub { },[AscendingOrder => Bool, Marker => Str, PageSize => Int])
1293              
1294             =head2 ListAllCertificates([AscendingOrder => Bool, Marker => Str, PageSize => Int])
1295              
1296              
1297             If passed a sub as first parameter, it will call the sub for each element found in :
1298              
1299             - certificates, passing the object as the first parameter, and the string 'certificates' as the second parameter
1300              
1301             If not, it will return a a L<Paws::IoT::ListCertificatesResponse> 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.
1302              
1303              
1304             =head2 ListAllCertificatesByCA(sub { },CaCertificateId => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1305              
1306             =head2 ListAllCertificatesByCA(CaCertificateId => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1307              
1308              
1309             If passed a sub as first parameter, it will call the sub for each element found in :
1310              
1311             - certificates, passing the object as the first parameter, and the string 'certificates' as the second parameter
1312              
1313             If not, it will return a a L<Paws::IoT::ListCertificatesByCAResponse> 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.
1314              
1315              
1316             =head2 ListAllOutgoingCertificates(sub { },[AscendingOrder => Bool, Marker => Str, PageSize => Int])
1317              
1318             =head2 ListAllOutgoingCertificates([AscendingOrder => Bool, Marker => Str, PageSize => Int])
1319              
1320              
1321             If passed a sub as first parameter, it will call the sub for each element found in :
1322              
1323             - outgoingCertificates, passing the object as the first parameter, and the string 'outgoingCertificates' as the second parameter
1324              
1325             If not, it will return a a L<Paws::IoT::ListOutgoingCertificatesResponse> 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.
1326              
1327              
1328             =head2 ListAllPolicies(sub { },[AscendingOrder => Bool, Marker => Str, PageSize => Int])
1329              
1330             =head2 ListAllPolicies([AscendingOrder => Bool, Marker => Str, PageSize => Int])
1331              
1332              
1333             If passed a sub as first parameter, it will call the sub for each element found in :
1334              
1335             - policies, passing the object as the first parameter, and the string 'policies' as the second parameter
1336              
1337             If not, it will return a a L<Paws::IoT::ListPoliciesResponse> 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.
1338              
1339              
1340             =head2 ListAllPolicyPrincipals(sub { },PolicyName => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1341              
1342             =head2 ListAllPolicyPrincipals(PolicyName => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1343              
1344              
1345             If passed a sub as first parameter, it will call the sub for each element found in :
1346              
1347             - principals, passing the object as the first parameter, and the string 'principals' as the second parameter
1348              
1349             If not, it will return a a L<Paws::IoT::ListPolicyPrincipalsResponse> 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.
1350              
1351              
1352             =head2 ListAllPrincipalPolicies(sub { },Principal => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1353              
1354             =head2 ListAllPrincipalPolicies(Principal => Str, [AscendingOrder => Bool, Marker => Str, PageSize => Int])
1355              
1356              
1357             If passed a sub as first parameter, it will call the sub for each element found in :
1358              
1359             - policies, passing the object as the first parameter, and the string 'policies' as the second parameter
1360              
1361             If not, it will return a a L<Paws::IoT::ListPrincipalPoliciesResponse> 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.
1362              
1363              
1364             =head2 ListAllPrincipalThings(sub { },Principal => Str, [MaxResults => Int, NextToken => Str])
1365              
1366             =head2 ListAllPrincipalThings(Principal => Str, [MaxResults => Int, NextToken => Str])
1367              
1368              
1369             If passed a sub as first parameter, it will call the sub for each element found in :
1370              
1371             - things, passing the object as the first parameter, and the string 'things' as the second parameter
1372              
1373             If not, it will return a a L<Paws::IoT::ListPrincipalThingsResponse> 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.
1374              
1375              
1376             =head2 ListAllThings(sub { },[AttributeName => Str, AttributeValue => Str, MaxResults => Int, NextToken => Str, ThingTypeName => Str])
1377              
1378             =head2 ListAllThings([AttributeName => Str, AttributeValue => Str, MaxResults => Int, NextToken => Str, ThingTypeName => Str])
1379              
1380              
1381             If passed a sub as first parameter, it will call the sub for each element found in :
1382              
1383             - things, passing the object as the first parameter, and the string 'things' as the second parameter
1384              
1385             If not, it will return a a L<Paws::IoT::ListThingsResponse> 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.
1386              
1387              
1388             =head2 ListAllThingTypes(sub { },[MaxResults => Int, NextToken => Str, ThingTypeName => Str])
1389              
1390             =head2 ListAllThingTypes([MaxResults => Int, NextToken => Str, ThingTypeName => Str])
1391              
1392              
1393             If passed a sub as first parameter, it will call the sub for each element found in :
1394              
1395             - thingTypes, passing the object as the first parameter, and the string 'thingTypes' as the second parameter
1396              
1397             If not, it will return a a L<Paws::IoT::ListThingTypesResponse> 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.
1398              
1399              
1400             =head2 ListAllTopicRules(sub { },[MaxResults => Int, NextToken => Str, RuleDisabled => Bool, Topic => Str])
1401              
1402             =head2 ListAllTopicRules([MaxResults => Int, NextToken => Str, RuleDisabled => Bool, Topic => Str])
1403              
1404              
1405             If passed a sub as first parameter, it will call the sub for each element found in :
1406              
1407             - rules, passing the object as the first parameter, and the string 'rules' as the second parameter
1408              
1409             If not, it will return a a L<Paws::IoT::ListTopicRulesResponse> 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.
1410              
1411              
1412              
1413              
1414              
1415             =head1 SEE ALSO
1416              
1417             This service class forms part of L<Paws>
1418              
1419             =head1 BUGS and CONTRIBUTIONS
1420              
1421             The source code is located here: https://github.com/pplu/aws-sdk-perl
1422              
1423             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
1424              
1425             =cut
1426