blib/lib/Paws/KinesisVideo.pm untested

filter: Statementstmt 0.0% 0 / 110 Branchbran 0.0% 0 / 8 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 27 Podpod 0.0% 0 / 26 totaltotal 0.0% 0 / 171 CC 5 SCAR 13.7
CC
5
Cov
0%
ListAllSignalingChannels
12.0
ListAllStreams
12.0
service
2.0
CRAP 3.9
1 package Paws::KinesisVideo;
2 use Moose;
3 sub service { 'kinesisvideo' }
4 sub signing_name { 'kinesisvideo' }
5 sub version { '2017-09-30' }
6 sub flattened_arrays { 0 }
7 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8 has retry => (is => 'ro', isa => 'HashRef', default => sub {
9 { base => 'rand', type => 'exponential', growth_factor => 2 }
10 });
11 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12 ] });
13  
14 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller';
15  
16
17 sub CreateSignalingChannel {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::CreateSignalingChannel', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub CreateStream {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::CreateStream', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub DeleteSignalingChannel {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::DeleteSignalingChannel', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub DeleteStream {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::DeleteStream', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub DescribeSignalingChannel {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::DescribeSignalingChannel', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub DescribeStream {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::DescribeStream', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub GetDataEndpoint {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::GetDataEndpoint', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub GetSignalingChannelEndpoint {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::GetSignalingChannelEndpoint', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub ListSignalingChannels {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::ListSignalingChannels', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub ListStreams {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::ListStreams', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub ListTagsForResource {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::ListTagsForResource', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub ListTagsForStream {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::ListTagsForStream', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77 sub TagResource {
78 my $self = shift;
79 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::TagResource', @_);
80 return $self->caller->do_call($self, $call_object);
81 }
82 sub TagStream {
83 my $self = shift;
84 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::TagStream', @_);
85 return $self->caller->do_call($self, $call_object);
86 }
87 sub UntagResource {
88 my $self = shift;
89 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::UntagResource', @_);
90 return $self->caller->do_call($self, $call_object);
91 }
92 sub UntagStream {
93 my $self = shift;
94 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::UntagStream', @_);
95 return $self->caller->do_call($self, $call_object);
96 }
97 sub UpdateDataRetention {
98 my $self = shift;
99 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::UpdateDataRetention', @_);
100 return $self->caller->do_call($self, $call_object);
101 }
102 sub UpdateSignalingChannel {
103 my $self = shift;
104 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::UpdateSignalingChannel', @_);
105 return $self->caller->do_call($self, $call_object);
106 }
107 sub UpdateStream {
108 my $self = shift;
109 my $call_object = $self->new_with_coercions('Paws::KinesisVideo::UpdateStream', @_);
110 return $self->caller->do_call($self, $call_object);
111 }
112
113 sub ListAllSignalingChannels {
114 my $self = shift;
115  
116 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
117 my $result = $self->ListSignalingChannels(@_);
118 my $next_result = $result;
119  
120 if (not defined $callback) {
121 while ($next_result->NextToken) {
122 $next_result = $self->ListSignalingChannels(@_, NextToken => $next_result->NextToken);
123 push @{ $result->ChannelInfoList }, @{ $next_result->ChannelInfoList };
124 }
125 return $result;
126 } else {
127 while ($result->NextToken) {
128 $callback->($_ => 'ChannelInfoList') foreach (@{ $result->ChannelInfoList });
129 $result = $self->ListSignalingChannels(@_, NextToken => $result->NextToken);
130 }
131 $callback->($_ => 'ChannelInfoList') foreach (@{ $result->ChannelInfoList });
132 }
133  
134 return undef
135 }
136 sub ListAllStreams {
137 my $self = shift;
138  
139 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
140 my $result = $self->ListStreams(@_);
141 my $next_result = $result;
142  
143 if (not defined $callback) {
144 while ($next_result->NextToken) {
145 $next_result = $self->ListStreams(@_, NextToken => $next_result->NextToken);
146 push @{ $result->StreamInfoList }, @{ $next_result->StreamInfoList };
147 }
148 return $result;
149 } else {
150 while ($result->NextToken) {
151 $callback->($_ => 'StreamInfoList') foreach (@{ $result->StreamInfoList });
152 $result = $self->ListStreams(@_, NextToken => $result->NextToken);
153 }
154 $callback->($_ => 'StreamInfoList') foreach (@{ $result->StreamInfoList });
155 }
156  
157 return undef
158 }
159  
160  
161 sub operations { qw/CreateSignalingChannel CreateStream DeleteSignalingChannel DeleteStream DescribeSignalingChannel DescribeStream GetDataEndpoint GetSignalingChannelEndpoint ListSignalingChannels ListStreams ListTagsForResource ListTagsForStream TagResource TagStream UntagResource UntagStream UpdateDataRetention UpdateSignalingChannel UpdateStream / }
162  
163 1;
164  
165 ### main pod documentation begin ###
166  
167 =head1 NAME
168  
169 Paws::KinesisVideo - Perl Interface to AWS Amazon Kinesis Video Streams
170  
171 =head1 SYNOPSIS
172  
173 use Paws;
174  
175 my $obj = Paws->service('KinesisVideo');
176 my $res = $obj->Method(
177 Arg1 => $val1,
178 Arg2 => [ 'V1', 'V2' ],
179 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
180 # of the arguments type
181 Arg3 => { Att1 => 'Val1' },
182 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
183 # the constructor of the arguments type
184 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
185 );
186  
187 =head1 DESCRIPTION
188  
189  
190  
191 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30>
192  
193  
194 =head1 METHODS
195  
196 =head2 CreateSignalingChannel
197  
198 =over
199  
200 =item ChannelName => Str
201  
202 =item [ChannelType => Str]
203  
204 =item [SingleMasterConfiguration => L<Paws::KinesisVideo::SingleMasterConfiguration>]
205  
206 =item [Tags => ArrayRef[L<Paws::KinesisVideo::Tag>]]
207  
208  
209 =back
210  
211 Each argument is described in detail in: L<Paws::KinesisVideo::CreateSignalingChannel>
212  
213 Returns: a L<Paws::KinesisVideo::CreateSignalingChannelOutput> instance
214  
215 Creates a signaling channel.
216  
217 C<CreateSignalingChannel> is an asynchronous operation.
218  
219  
220 =head2 CreateStream
221  
222 =over
223  
224 =item StreamName => Str
225  
226 =item [DataRetentionInHours => Int]
227  
228 =item [DeviceName => Str]
229  
230 =item [KmsKeyId => Str]
231  
232 =item [MediaType => Str]
233  
234 =item [Tags => L<Paws::KinesisVideo::ResourceTags>]
235  
236  
237 =back
238  
239 Each argument is described in detail in: L<Paws::KinesisVideo::CreateStream>
240  
241 Returns: a L<Paws::KinesisVideo::CreateStreamOutput> instance
242  
243 Creates a new Kinesis video stream.
244  
245 When you create a new stream, Kinesis Video Streams assigns it a
246 version number. When you change the stream's metadata, Kinesis Video
247 Streams updates the version.
248  
249 C<CreateStream> is an asynchronous operation.
250  
251 For information about how the service works, see How it Works
252 (https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/how-it-works.html).
253  
254 You must have permissions for the C<KinesisVideo:CreateStream> action.
255  
256  
257 =head2 DeleteSignalingChannel
258  
259 =over
260  
261 =item ChannelARN => Str
262  
263 =item [CurrentVersion => Str]
264  
265  
266 =back
267  
268 Each argument is described in detail in: L<Paws::KinesisVideo::DeleteSignalingChannel>
269  
270 Returns: a L<Paws::KinesisVideo::DeleteSignalingChannelOutput> instance
271  
272 Deletes a specified signaling channel. C<DeleteSignalingChannel> is an
273 asynchronous operation. If you don't specify the channel's current
274 version, the most recent version is deleted.
275  
276  
277 =head2 DeleteStream
278  
279 =over
280  
281 =item StreamARN => Str
282  
283 =item [CurrentVersion => Str]
284  
285  
286 =back
287  
288 Each argument is described in detail in: L<Paws::KinesisVideo::DeleteStream>
289  
290 Returns: a L<Paws::KinesisVideo::DeleteStreamOutput> instance
291  
292 Deletes a Kinesis video stream and the data contained in the stream.
293  
294 This method marks the stream for deletion, and makes the data in the
295 stream inaccessible immediately.
296  
297 To ensure that you have the latest version of the stream before
298 deleting it, you can specify the stream version. Kinesis Video Streams
299 assigns a version to each stream. When you update a stream, Kinesis
300 Video Streams assigns a new version number. To get the latest stream
301 version, use the C<DescribeStream> API.
302  
303 This operation requires permission for the C<KinesisVideo:DeleteStream>
304 action.
305  
306  
307 =head2 DescribeSignalingChannel
308  
309 =over
310  
311 =item [ChannelARN => Str]
312  
313 =item [ChannelName => Str]
314  
315  
316 =back
317  
318 Each argument is described in detail in: L<Paws::KinesisVideo::DescribeSignalingChannel>
319  
320 Returns: a L<Paws::KinesisVideo::DescribeSignalingChannelOutput> instance
321  
322 Returns the most current information about the signaling channel. You
323 must specify either the name or the Amazon Resource Name (ARN) of the
324 channel that you want to describe.
325  
326  
327 =head2 DescribeStream
328  
329 =over
330  
331 =item [StreamARN => Str]
332  
333 =item [StreamName => Str]
334  
335  
336 =back
337  
338 Each argument is described in detail in: L<Paws::KinesisVideo::DescribeStream>
339  
340 Returns: a L<Paws::KinesisVideo::DescribeStreamOutput> instance
341  
342 Returns the most current information about the specified stream. You
343 must specify either the C<StreamName> or the C<StreamARN>.
344  
345  
346 =head2 GetDataEndpoint
347  
348 =over
349  
350 =item APIName => Str
351  
352 =item [StreamARN => Str]
353  
354 =item [StreamName => Str]
355  
356  
357 =back
358  
359 Each argument is described in detail in: L<Paws::KinesisVideo::GetDataEndpoint>
360  
361 Returns: a L<Paws::KinesisVideo::GetDataEndpointOutput> instance
362  
363 Gets an endpoint for a specified stream for either reading or writing.
364 Use this endpoint in your application to read from the specified stream
365 (using the C<GetMedia> or C<GetMediaForFragmentList> operations) or
366 write to it (using the C<PutMedia> operation).
367  
368 The returned endpoint does not have the API name appended. The client
369 needs to add the API name to the returned endpoint.
370  
371 In the request, specify the stream either by C<StreamName> or
372 C<StreamARN>.
373  
374  
375 =head2 GetSignalingChannelEndpoint
376  
377 =over
378  
379 =item ChannelARN => Str
380  
381 =item [SingleMasterChannelEndpointConfiguration => L<Paws::KinesisVideo::SingleMasterChannelEndpointConfiguration>]
382  
383  
384 =back
385  
386 Each argument is described in detail in: L<Paws::KinesisVideo::GetSignalingChannelEndpoint>
387  
388 Returns: a L<Paws::KinesisVideo::GetSignalingChannelEndpointOutput> instance
389  
390 Provides an endpoint for the specified signaling channel to send and
391 receive messages. This API uses the
392 C<SingleMasterChannelEndpointConfiguration> input parameter, which
393 consists of the C<Protocols> and C<Role> properties.
394  
395 C<Protocols> is used to determine the communication mechanism. For
396 example, if you specify C<WSS> as the protocol, this API produces a
397 secure websocket endpoint. If you specify C<HTTPS> as the protocol,
398 this API generates an HTTPS endpoint.
399  
400 C<Role> determines the messaging permissions. A C<MASTER> role results
401 in this API generating an endpoint that a client can use to communicate
402 with any of the viewers on the channel. A C<VIEWER> role results in
403 this API generating an endpoint that a client can use to communicate
404 only with a C<MASTER>.
405  
406  
407 =head2 ListSignalingChannels
408  
409 =over
410  
411 =item [ChannelNameCondition => L<Paws::KinesisVideo::ChannelNameCondition>]
412  
413 =item [MaxResults => Int]
414  
415 =item [NextToken => Str]
416  
417  
418 =back
419  
420 Each argument is described in detail in: L<Paws::KinesisVideo::ListSignalingChannels>
421  
422 Returns: a L<Paws::KinesisVideo::ListSignalingChannelsOutput> instance
423  
424 Returns an array of C<ChannelInfo> objects. Each object describes a
425 signaling channel. To retrieve only those channels that satisfy a
426 specific condition, you can specify a C<ChannelNameCondition>.
427  
428  
429 =head2 ListStreams
430  
431 =over
432  
433 =item [MaxResults => Int]
434  
435 =item [NextToken => Str]
436  
437 =item [StreamNameCondition => L<Paws::KinesisVideo::StreamNameCondition>]
438  
439  
440 =back
441  
442 Each argument is described in detail in: L<Paws::KinesisVideo::ListStreams>
443  
444 Returns: a L<Paws::KinesisVideo::ListStreamsOutput> instance
445  
446 Returns an array of C<StreamInfo> objects. Each object describes a
447 stream. To retrieve only streams that satisfy a specific condition, you
448 can specify a C<StreamNameCondition>.
449  
450  
451 =head2 ListTagsForResource
452  
453 =over
454  
455 =item ResourceARN => Str
456  
457 =item [NextToken => Str]
458  
459  
460 =back
461  
462 Each argument is described in detail in: L<Paws::KinesisVideo::ListTagsForResource>
463  
464 Returns: a L<Paws::KinesisVideo::ListTagsForResourceOutput> instance
465  
466 Returns a list of tags associated with the specified signaling channel.
467  
468  
469 =head2 ListTagsForStream
470  
471 =over
472  
473 =item [NextToken => Str]
474  
475 =item [StreamARN => Str]
476  
477 =item [StreamName => Str]
478  
479  
480 =back
481  
482 Each argument is described in detail in: L<Paws::KinesisVideo::ListTagsForStream>
483  
484 Returns: a L<Paws::KinesisVideo::ListTagsForStreamOutput> instance
485  
486 Returns a list of tags associated with the specified stream.
487  
488 In the request, you must specify either the C<StreamName> or the
489 C<StreamARN>.
490  
491  
492 =head2 TagResource
493  
494 =over
495  
496 =item ResourceARN => Str
497  
498 =item Tags => ArrayRef[L<Paws::KinesisVideo::Tag>]
499  
500  
501 =back
502  
503 Each argument is described in detail in: L<Paws::KinesisVideo::TagResource>
504  
505 Returns: a L<Paws::KinesisVideo::TagResourceOutput> instance
506  
507 Adds one or more tags to a signaling channel. A I<tag> is a key-value
508 pair (the value is optional) that you can define and assign to AWS
509 resources. If you specify a tag that already exists, the tag value is
510 replaced with the value that you specify in the request. For more
511 information, see Using Cost Allocation Tags
512 (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html)
513 in the I<AWS Billing and Cost Management User Guide>.
514  
515  
516 =head2 TagStream
517  
518 =over
519  
520 =item Tags => L<Paws::KinesisVideo::ResourceTags>
521  
522 =item [StreamARN => Str]
523  
524 =item [StreamName => Str]
525  
526  
527 =back
528  
529 Each argument is described in detail in: L<Paws::KinesisVideo::TagStream>
530  
531 Returns: a L<Paws::KinesisVideo::TagStreamOutput> instance
532  
533 Adds one or more tags to a stream. A I<tag> is a key-value pair (the
534 value is optional) that you can define and assign to AWS resources. If
535 you specify a tag that already exists, the tag value is replaced with
536 the value that you specify in the request. For more information, see
537 Using Cost Allocation Tags
538 (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html)
539 in the I<AWS Billing and Cost Management User Guide>.
540  
541 You must provide either the C<StreamName> or the C<StreamARN>.
542  
543 This operation requires permission for the C<KinesisVideo:TagStream>
544 action.
545  
546 Kinesis video streams support up to 50 tags.
547  
548  
549 =head2 UntagResource
550  
551 =over
552  
553 =item ResourceARN => Str
554  
555 =item TagKeyList => ArrayRef[Str|Undef]
556  
557  
558 =back
559  
560 Each argument is described in detail in: L<Paws::KinesisVideo::UntagResource>
561  
562 Returns: a L<Paws::KinesisVideo::UntagResourceOutput> instance
563  
564 Removes one or more tags from a signaling channel. In the request,
565 specify only a tag key or keys; don't specify the value. If you specify
566 a tag key that does not exist, it's ignored.
567  
568  
569 =head2 UntagStream
570  
571 =over
572  
573 =item TagKeyList => ArrayRef[Str|Undef]
574  
575 =item [StreamARN => Str]
576  
577 =item [StreamName => Str]
578  
579  
580 =back
581  
582 Each argument is described in detail in: L<Paws::KinesisVideo::UntagStream>
583  
584 Returns: a L<Paws::KinesisVideo::UntagStreamOutput> instance
585  
586 Removes one or more tags from a stream. In the request, specify only a
587 tag key or keys; don't specify the value. If you specify a tag key that
588 does not exist, it's ignored.
589  
590 In the request, you must provide the C<StreamName> or C<StreamARN>.
591  
592  
593 =head2 UpdateDataRetention
594  
595 =over
596  
597 =item CurrentVersion => Str
598  
599 =item DataRetentionChangeInHours => Int
600  
601 =item Operation => Str
602  
603 =item [StreamARN => Str]
604  
605 =item [StreamName => Str]
606  
607  
608 =back
609  
610 Each argument is described in detail in: L<Paws::KinesisVideo::UpdateDataRetention>
611  
612 Returns: a L<Paws::KinesisVideo::UpdateDataRetentionOutput> instance
613  
614 Increases or decreases the stream's data retention period by the value
615 that you specify. To indicate whether you want to increase or decrease
616 the data retention period, specify the C<Operation> parameter in the
617 request body. In the request, you must specify either the C<StreamName>
618 or the C<StreamARN>.
619  
620 The retention period that you specify replaces the current value.
621  
622 This operation requires permission for the
623 C<KinesisVideo:UpdateDataRetention> action.
624  
625 Changing the data retention period affects the data in the stream as
626 follows:
627  
628 =over
629  
630 =item *
631  
632 If the data retention period is increased, existing data is retained
633 for the new retention period. For example, if the data retention period
634 is increased from one hour to seven hours, all existing data is
635 retained for seven hours.
636  
637 =item *
638  
639 If the data retention period is decreased, existing data is retained
640 for the new retention period. For example, if the data retention period
641 is decreased from seven hours to one hour, all existing data is
642 retained for one hour, and any data older than one hour is deleted
643 immediately.
644  
645 =back
646  
647  
648  
649 =head2 UpdateSignalingChannel
650  
651 =over
652  
653 =item ChannelARN => Str
654  
655 =item CurrentVersion => Str
656  
657 =item [SingleMasterConfiguration => L<Paws::KinesisVideo::SingleMasterConfiguration>]
658  
659  
660 =back
661  
662 Each argument is described in detail in: L<Paws::KinesisVideo::UpdateSignalingChannel>
663  
664 Returns: a L<Paws::KinesisVideo::UpdateSignalingChannelOutput> instance
665  
666 Updates the existing signaling channel. This is an asynchronous
667 operation and takes time to complete.
668  
669 If the C<MessageTtlSeconds> value is updated (either increased or
670 reduced), it only applies to new messages sent via this channel after
671 it's been updated. Existing messages are still expired as per the
672 previous C<MessageTtlSeconds> value.
673  
674  
675 =head2 UpdateStream
676  
677 =over
678  
679 =item CurrentVersion => Str
680  
681 =item [DeviceName => Str]
682  
683 =item [MediaType => Str]
684  
685 =item [StreamARN => Str]
686  
687 =item [StreamName => Str]
688  
689  
690 =back
691  
692 Each argument is described in detail in: L<Paws::KinesisVideo::UpdateStream>
693  
694 Returns: a L<Paws::KinesisVideo::UpdateStreamOutput> instance
695  
696 Updates stream metadata, such as the device name and media type.
697  
698 You must provide the stream name or the Amazon Resource Name (ARN) of
699 the stream.
700  
701 To make sure that you have the latest version of the stream before
702 updating it, you can specify the stream version. Kinesis Video Streams
703 assigns a version to each stream. When you update a stream, Kinesis
704 Video Streams assigns a new version number. To get the latest stream
705 version, use the C<DescribeStream> API.
706  
707 C<UpdateStream> is an asynchronous operation, and takes time to
708 complete.
709  
710  
711  
712  
713 =head1 PAGINATORS
714  
715 Paginator methods are helpers that repetively call methods that return partial results
716  
717 =head2 ListAllSignalingChannels(sub { },[ChannelNameCondition => L<Paws::KinesisVideo::ChannelNameCondition>, MaxResults => Int, NextToken => Str])
718  
719 =head2 ListAllSignalingChannels([ChannelNameCondition => L<Paws::KinesisVideo::ChannelNameCondition>, MaxResults => Int, NextToken => Str])
720  
721  
722 If passed a sub as first parameter, it will call the sub for each element found in :
723  
724 - ChannelInfoList, passing the object as the first parameter, and the string 'ChannelInfoList' as the second parameter
725  
726 If not, it will return a a L<Paws::KinesisVideo::ListSignalingChannelsOutput> 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.
727  
728  
729 =head2 ListAllStreams(sub { },[MaxResults => Int, NextToken => Str, StreamNameCondition => L<Paws::KinesisVideo::StreamNameCondition>])
730  
731 =head2 ListAllStreams([MaxResults => Int, NextToken => Str, StreamNameCondition => L<Paws::KinesisVideo::StreamNameCondition>])
732  
733  
734 If passed a sub as first parameter, it will call the sub for each element found in :
735  
736 - StreamInfoList, passing the object as the first parameter, and the string 'StreamInfoList' as the second parameter
737  
738 If not, it will return a a L<Paws::KinesisVideo::ListStreamsOutput> 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.
739  
740  
741  
742  
743  
744 =head1 SEE ALSO
745  
746 This service class forms part of L<Paws>
747  
748 =head1 BUGS and CONTRIBUTIONS
749  
750 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
751  
752 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
753  
754 =cut
755