blib/lib/Paws/IVS.pm untested

filter: Statementstmt 0.0% 0 / 191 Branchbran 0.0% 0 / 20 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 37 Podpod 0.0% 0 / 36 totaltotal 0.0% 0 / 284 CC 11 SCAR 16.5
CC
11
Cov
0%
ListAllChannels
12.0
ListAllPlaybackKeyPairs
12.0
ListAllRecordingConfigurations
12.0
CRAP 5.2
1 package Paws::IVS;
2 use Moose;
3 sub service { 'ivs' }
4 sub signing_name { 'ivs' }
5 sub version { '2020-07-14' }
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 BatchGetChannel {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::IVS::BatchGetChannel', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub BatchGetStreamKey {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::IVS::BatchGetStreamKey', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub CreateChannel {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::IVS::CreateChannel', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub CreateRecordingConfiguration {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::IVS::CreateRecordingConfiguration', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub CreateStreamKey {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::IVS::CreateStreamKey', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub DeleteChannel {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::IVS::DeleteChannel', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub DeletePlaybackKeyPair {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::IVS::DeletePlaybackKeyPair', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub DeleteRecordingConfiguration {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::IVS::DeleteRecordingConfiguration', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub DeleteStreamKey {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::IVS::DeleteStreamKey', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub GetChannel {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::IVS::GetChannel', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub GetPlaybackKeyPair {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::IVS::GetPlaybackKeyPair', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub GetRecordingConfiguration {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::IVS::GetRecordingConfiguration', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77 sub GetStream {
78 my $self = shift;
79 my $call_object = $self->new_with_coercions('Paws::IVS::GetStream', @_);
80 return $self->caller->do_call($self, $call_object);
81 }
82 sub GetStreamKey {
83 my $self = shift;
84 my $call_object = $self->new_with_coercions('Paws::IVS::GetStreamKey', @_);
85 return $self->caller->do_call($self, $call_object);
86 }
87 sub ImportPlaybackKeyPair {
88 my $self = shift;
89 my $call_object = $self->new_with_coercions('Paws::IVS::ImportPlaybackKeyPair', @_);
90 return $self->caller->do_call($self, $call_object);
91 }
92 sub ListChannels {
93 my $self = shift;
94 my $call_object = $self->new_with_coercions('Paws::IVS::ListChannels', @_);
95 return $self->caller->do_call($self, $call_object);
96 }
97 sub ListPlaybackKeyPairs {
98 my $self = shift;
99 my $call_object = $self->new_with_coercions('Paws::IVS::ListPlaybackKeyPairs', @_);
100 return $self->caller->do_call($self, $call_object);
101 }
102 sub ListRecordingConfigurations {
103 my $self = shift;
104 my $call_object = $self->new_with_coercions('Paws::IVS::ListRecordingConfigurations', @_);
105 return $self->caller->do_call($self, $call_object);
106 }
107 sub ListStreamKeys {
108 my $self = shift;
109 my $call_object = $self->new_with_coercions('Paws::IVS::ListStreamKeys', @_);
110 return $self->caller->do_call($self, $call_object);
111 }
112 sub ListStreams {
113 my $self = shift;
114 my $call_object = $self->new_with_coercions('Paws::IVS::ListStreams', @_);
115 return $self->caller->do_call($self, $call_object);
116 }
117 sub ListTagsForResource {
118 my $self = shift;
119 my $call_object = $self->new_with_coercions('Paws::IVS::ListTagsForResource', @_);
120 return $self->caller->do_call($self, $call_object);
121 }
122 sub PutMetadata {
123 my $self = shift;
124 my $call_object = $self->new_with_coercions('Paws::IVS::PutMetadata', @_);
125 return $self->caller->do_call($self, $call_object);
126 }
127 sub StopStream {
128 my $self = shift;
129 my $call_object = $self->new_with_coercions('Paws::IVS::StopStream', @_);
130 return $self->caller->do_call($self, $call_object);
131 }
132 sub TagResource {
133 my $self = shift;
134 my $call_object = $self->new_with_coercions('Paws::IVS::TagResource', @_);
135 return $self->caller->do_call($self, $call_object);
136 }
137 sub UntagResource {
138 my $self = shift;
139 my $call_object = $self->new_with_coercions('Paws::IVS::UntagResource', @_);
140 return $self->caller->do_call($self, $call_object);
141 }
142 sub UpdateChannel {
143 my $self = shift;
144 my $call_object = $self->new_with_coercions('Paws::IVS::UpdateChannel', @_);
145 return $self->caller->do_call($self, $call_object);
146 }
147
148 sub ListAllChannels {
149 my $self = shift;
150  
151 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
152 my $result = $self->ListChannels(@_);
153 my $next_result = $result;
154  
155 if (not defined $callback) {
156 while ($next_result->nextToken) {
157 $next_result = $self->ListChannels(@_, nextToken => $next_result->nextToken);
158 push @{ $result->channels }, @{ $next_result->channels };
159 }
160 return $result;
161 } else {
162 while ($result->nextToken) {
163 $callback->($_ => 'channels') foreach (@{ $result->channels });
164 $result = $self->ListChannels(@_, nextToken => $result->nextToken);
165 }
166 $callback->($_ => 'channels') foreach (@{ $result->channels });
167 }
168  
169 return undef
170 }
171 sub ListAllPlaybackKeyPairs {
172 my $self = shift;
173  
174 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
175 my $result = $self->ListPlaybackKeyPairs(@_);
176 my $next_result = $result;
177  
178 if (not defined $callback) {
179 while ($next_result->nextToken) {
180 $next_result = $self->ListPlaybackKeyPairs(@_, nextToken => $next_result->nextToken);
181 push @{ $result->keyPairs }, @{ $next_result->keyPairs };
182 }
183 return $result;
184 } else {
185 while ($result->nextToken) {
186 $callback->($_ => 'keyPairs') foreach (@{ $result->keyPairs });
187 $result = $self->ListPlaybackKeyPairs(@_, nextToken => $result->nextToken);
188 }
189 $callback->($_ => 'keyPairs') foreach (@{ $result->keyPairs });
190 }
191  
192 return undef
193 }
194 sub ListAllRecordingConfigurations {
195 my $self = shift;
196  
197 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
198 my $result = $self->ListRecordingConfigurations(@_);
199 my $next_result = $result;
200  
201 if (not defined $callback) {
202 while ($next_result->nextToken) {
203 $next_result = $self->ListRecordingConfigurations(@_, nextToken => $next_result->nextToken);
204 push @{ $result->recordingConfigurations }, @{ $next_result->recordingConfigurations };
205 }
206 return $result;
207 } else {
208 while ($result->nextToken) {
209 $callback->($_ => 'recordingConfigurations') foreach (@{ $result->recordingConfigurations });
210 $result = $self->ListRecordingConfigurations(@_, nextToken => $result->nextToken);
211 }
212 $callback->($_ => 'recordingConfigurations') foreach (@{ $result->recordingConfigurations });
213 }
214  
215 return undef
216 }
217 sub ListAllStreamKeys {
218 my $self = shift;
219  
220 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
221 my $result = $self->ListStreamKeys(@_);
222 my $next_result = $result;
223  
224 if (not defined $callback) {
225 while ($next_result->nextToken) {
226 $next_result = $self->ListStreamKeys(@_, nextToken => $next_result->nextToken);
227 push @{ $result->streamKeys }, @{ $next_result->streamKeys };
228 }
229 return $result;
230 } else {
231 while ($result->nextToken) {
232 $callback->($_ => 'streamKeys') foreach (@{ $result->streamKeys });
233 $result = $self->ListStreamKeys(@_, nextToken => $result->nextToken);
234 }
235 $callback->($_ => 'streamKeys') foreach (@{ $result->streamKeys });
236 }
237  
238 return undef
239 }
240 sub ListAllStreams {
241 my $self = shift;
242  
243 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
244 my $result = $self->ListStreams(@_);
245 my $next_result = $result;
246  
247 if (not defined $callback) {
248 while ($next_result->nextToken) {
249 $next_result = $self->ListStreams(@_, nextToken => $next_result->nextToken);
250 push @{ $result->streams }, @{ $next_result->streams };
251 }
252 return $result;
253 } else {
254 while ($result->nextToken) {
255 $callback->($_ => 'streams') foreach (@{ $result->streams });
256 $result = $self->ListStreams(@_, nextToken => $result->nextToken);
257 }
258 $callback->($_ => 'streams') foreach (@{ $result->streams });
259 }
260  
261 return undef
262 }
263  
264  
265 sub operations { qw/BatchGetChannel BatchGetStreamKey CreateChannel CreateRecordingConfiguration CreateStreamKey DeleteChannel DeletePlaybackKeyPair DeleteRecordingConfiguration DeleteStreamKey GetChannel GetPlaybackKeyPair GetRecordingConfiguration GetStream GetStreamKey ImportPlaybackKeyPair ListChannels ListPlaybackKeyPairs ListRecordingConfigurations ListStreamKeys ListStreams ListTagsForResource PutMetadata StopStream TagResource UntagResource UpdateChannel / }
266  
267 1;
268  
269 ### main pod documentation begin ###
270  
271 =head1 NAME
272  
273 Paws::IVS - Perl Interface to AWS Amazon Interactive Video Service
274  
275 =head1 SYNOPSIS
276  
277 use Paws;
278  
279 my $obj = Paws->service('IVS');
280 my $res = $obj->Method(
281 Arg1 => $val1,
282 Arg2 => [ 'V1', 'V2' ],
283 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
284 # of the arguments type
285 Arg3 => { Att1 => 'Val1' },
286 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
287 # the constructor of the arguments type
288 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
289 );
290  
291 =head1 DESCRIPTION
292  
293 B<Introduction>
294  
295 The Amazon Interactive Video Service (IVS) API is REST compatible,
296 using a standard HTTP API and an AWS EventBridge event stream for
297 responses. JSON is used for both requests and responses, including
298 errors.
299  
300 The API is an AWS regional service, currently in these regions:
301 us-west-2, us-east-1, and eu-west-1.
302  
303 I<B<All API request parameters and URLs are case sensitive. >>
304  
305 For a summary of notable documentation changes in each release, see
306 Document History
307 (https://docs.aws.amazon.com/ivs/latest/userguide/doc-history.html).
308  
309 B<Service Endpoints>
310  
311 The following are the Amazon IVS service endpoints (all HTTPS):
312  
313 Region name: US West (Oregon)
314  
315 =over
316  
317 =item *
318  
319 Region: C<us-west-2>
320  
321 =item *
322  
323 Endpoint: C<ivs.us-west-2.amazonaws.com>
324  
325 =back
326  
327 Region name: US East (Virginia)
328  
329 =over
330  
331 =item *
332  
333 Region: C<us-east-1>
334  
335 =item *
336  
337 Endpoint: C<ivs.us-east-1.amazonaws.com>
338  
339 =back
340  
341 Region name: EU West (Dublin)
342  
343 =over
344  
345 =item *
346  
347 Region: C<eu-west-1>
348  
349 =item *
350  
351 Endpoint: C<ivs.eu-west-1.amazonaws.com>
352  
353 =back
354  
355 B<Allowed Header Values>
356  
357 =over
358  
359 =item *
360  
361 C<B<Accept:> > application/json
362  
363 =item *
364  
365 C<B<Accept-Encoding:> > gzip, deflate
366  
367 =item *
368  
369 C<B<Content-Type:> >application/json
370  
371 =back
372  
373 B<Resources>
374  
375 The following resources contain information about your IVS live stream
376 (see Getting Started with Amazon IVS
377 (https://docs.aws.amazon.com/ivs/latest/userguide/getting-started.html)):
378  
379 =over
380  
381 =item *
382  
383 Channel E<mdash> Stores configuration data related to your live stream.
384 You first create a channel and then use the channelE<rsquo>s stream key
385 to start your live stream. See the Channel endpoints for more
386 information.
387  
388 =item *
389  
390 Stream key E<mdash> An identifier assigned by Amazon IVS when you
391 create a channel, which is then used to authorize streaming. See the
392 StreamKey endpoints for more information. I< B<Treat the stream key
393 like a secret, since it allows anyone to stream to the channel.>>
394  
395 =item *
396  
397 Playback key pair E<mdash> Video playback may be restricted using
398 playback-authorization tokens, which use public-key encryption. A
399 playback key pair is the public-private pair of keys used to sign and
400 validate the playback-authorization token. See the PlaybackKeyPair
401 endpoints for more information.
402  
403 =item *
404  
405 Recording configuration E<mdash> Stores configuration related to
406 recording a live stream and where to store the recorded content.
407 Multiple channels can reference the same recording configuration. See
408 the Recording Configuration endpoints for more information.
409  
410 =back
411  
412 B<Tagging>
413  
414 A I<tag> is a metadata label that you assign to an AWS resource. A tag
415 comprises a I<key> and a I<value>, both set by you. For example, you
416 might set a tag as C<topic:nature> to label a particular video
417 category. See Tagging AWS Resources
418 (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) for
419 more information, including restrictions that apply to tags.
420  
421 Tags can help you identify and organize your AWS resources. For
422 example, you can use the same tag for different resources to indicate
423 that they are related. You can also use tags to manage access (see
424 Access Tags
425 (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)).
426  
427 The Amazon IVS API has these tag-related endpoints: TagResource,
428 UntagResource, and ListTagsForResource. The following resources support
429 tagging: Channels, Stream Keys, Playback Key Pairs, and Recording
430 Configurations.
431  
432 B<Authentication versus Authorization>
433  
434 Note the differences between these concepts:
435  
436 =over
437  
438 =item *
439  
440 I<Authentication> is about verifying identity. You need to be
441 authenticated to sign Amazon IVS API requests.
442  
443 =item *
444  
445 I<Authorization> is about granting permissions. You need to be
446 authorized to view Amazon IVS private channels
447 (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html).
448 (Private channels are channels that are enabled for "playback
449 authorization.")
450  
451 =back
452  
453 B<Authentication>
454  
455 All Amazon IVS API requests must be authenticated with a signature. The
456 AWS Command-Line Interface (CLI) and Amazon IVS Player SDKs take care
457 of signing the underlying API calls for you. However, if your
458 application calls the Amazon IVS API directly, itE<rsquo>s your
459 responsibility to sign the requests.
460  
461 You generate a signature using valid AWS credentials that have
462 permission to perform the requested action. For example, you must sign
463 PutMetadata requests with a signature generated from an IAM user
464 account that has the C<ivs:PutMetadata> permission.
465  
466 For more information:
467  
468 =over
469  
470 =item *
471  
472 Authentication and generating signatures E<mdash> See Authenticating
473 Requests (AWS Signature Version 4)
474 (https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html)
475 in the I<AWS General Reference>.
476  
477 =item *
478  
479 Managing Amazon IVS permissions E<mdash> See Identity and Access
480 Management
481 (https://docs.aws.amazon.com/ivs/latest/userguide/security-iam.html) on
482 the Security page of the I<Amazon IVS User Guide>.
483  
484 =back
485  
486 B<Channel Endpoints>
487  
488 =over
489  
490 =item *
491  
492 CreateChannel E<mdash> Creates a new channel and an associated stream
493 key to start streaming.
494  
495 =item *
496  
497 GetChannel E<mdash> Gets the channel configuration for the specified
498 channel ARN (Amazon Resource Name).
499  
500 =item *
501  
502 BatchGetChannel E<mdash> Performs GetChannel on multiple ARNs
503 simultaneously.
504  
505 =item *
506  
507 ListChannels E<mdash> Gets summary information about all channels in
508 your account, in the AWS region where the API request is processed.
509 This list can be filtered to match a specified name or
510 recording-configuration ARN. Filters are mutually exclusive and cannot
511 be used together. If you try to use both filters, you will get an error
512 (409 Conflict Exception).
513  
514 =item *
515  
516 UpdateChannel E<mdash> Updates a channel's configuration. This does not
517 affect an ongoing stream of this channel. You must stop and restart the
518 stream for the changes to take effect.
519  
520 =item *
521  
522 DeleteChannel E<mdash> Deletes the specified channel.
523  
524 =back
525  
526 B<StreamKey Endpoints>
527  
528 =over
529  
530 =item *
531  
532 CreateStreamKey E<mdash> Creates a stream key, used to initiate a
533 stream, for the specified channel ARN.
534  
535 =item *
536  
537 GetStreamKey E<mdash> Gets stream key information for the specified
538 ARN.
539  
540 =item *
541  
542 BatchGetStreamKey E<mdash> Performs GetStreamKey on multiple ARNs
543 simultaneously.
544  
545 =item *
546  
547 ListStreamKeys E<mdash> Gets summary information about stream keys for
548 the specified channel.
549  
550 =item *
551  
552 DeleteStreamKey E<mdash> Deletes the stream key for the specified ARN,
553 so it can no longer be used to stream.
554  
555 =back
556  
557 B<Stream Endpoints>
558  
559 =over
560  
561 =item *
562  
563 GetStream E<mdash> Gets information about the active (live) stream on a
564 specified channel.
565  
566 =item *
567  
568 ListStreams E<mdash> Gets summary information about live streams in
569 your account, in the AWS region where the API request is processed.
570  
571 =item *
572  
573 StopStream E<mdash> Disconnects the incoming RTMPS stream for the
574 specified channel. Can be used in conjunction with DeleteStreamKey to
575 prevent further streaming to a channel.
576  
577 =item *
578  
579 PutMetadata E<mdash> Inserts metadata into the active stream of the
580 specified channel. A maximum of 5 requests per second per channel is
581 allowed, each with a maximum 1 KB payload. (If 5 TPS is not sufficient
582 for your needs, we recommend batching your data into a single
583 PutMetadata call.)
584  
585 =back
586  
587 B<PlaybackKeyPair Endpoints>
588  
589 For more information, see Setting Up Private Channels
590 (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
591 in the I<Amazon IVS User Guide>.
592  
593 =over
594  
595 =item *
596  
597 ImportPlaybackKeyPair E<mdash> Imports the public portion of a new key
598 pair and returns its C<arn> and C<fingerprint>. The C<privateKey> can
599 then be used to generate viewer authorization tokens, to grant viewers
600 access to private channels (channels enabled for playback
601 authorization).
602  
603 =item *
604  
605 GetPlaybackKeyPair E<mdash> Gets a specified playback authorization key
606 pair and returns the C<arn> and C<fingerprint>. The C<privateKey> held
607 by the caller can be used to generate viewer authorization tokens, to
608 grant viewers access to private channels.
609  
610 =item *
611  
612 ListPlaybackKeyPairs E<mdash> Gets summary information about playback
613 key pairs.
614  
615 =item *
616  
617 DeletePlaybackKeyPair E<mdash> Deletes a specified authorization key
618 pair. This invalidates future viewer tokens generated using the key
619 pairE<rsquo>s C<privateKey>.
620  
621 =back
622  
623 B<RecordingConfiguration Endpoints>
624  
625 =over
626  
627 =item *
628  
629 CreateRecordingConfiguration E<mdash> Creates a new recording
630 configuration, used to enable recording to Amazon S3.
631  
632 =item *
633  
634 GetRecordingConfiguration E<mdash> Gets the recording-configuration
635 metadata for the specified ARN.
636  
637 =item *
638  
639 ListRecordingConfigurations E<mdash> Gets summary information about all
640 recording configurations in your account, in the AWS region where the
641 API request is processed.
642  
643 =item *
644  
645 DeleteRecordingConfiguration E<mdash> Deletes the recording
646 configuration for the specified ARN.
647  
648 =back
649  
650 B<AWS Tags Endpoints>
651  
652 =over
653  
654 =item *
655  
656 TagResource E<mdash> Adds or updates tags for the AWS resource with the
657 specified ARN.
658  
659 =item *
660  
661 UntagResource E<mdash> Removes tags from the resource with the
662 specified ARN.
663  
664 =item *
665  
666 ListTagsForResource E<mdash> Gets information about AWS tags for the
667 specified ARN.
668  
669 =back
670  
671  
672 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/ivs-2020-07-14>
673  
674  
675 =head1 METHODS
676  
677 =head2 BatchGetChannel
678  
679 =over
680  
681 =item Arns => ArrayRef[Str|Undef]
682  
683  
684 =back
685  
686 Each argument is described in detail in: L<Paws::IVS::BatchGetChannel>
687  
688 Returns: a L<Paws::IVS::BatchGetChannelResponse> instance
689  
690 Performs GetChannel on multiple ARNs simultaneously.
691  
692  
693 =head2 BatchGetStreamKey
694  
695 =over
696  
697 =item Arns => ArrayRef[Str|Undef]
698  
699  
700 =back
701  
702 Each argument is described in detail in: L<Paws::IVS::BatchGetStreamKey>
703  
704 Returns: a L<Paws::IVS::BatchGetStreamKeyResponse> instance
705  
706 Performs GetStreamKey on multiple ARNs simultaneously.
707  
708  
709 =head2 CreateChannel
710  
711 =over
712  
713 =item [Authorized => Bool]
714  
715 =item [LatencyMode => Str]
716  
717 =item [Name => Str]
718  
719 =item [RecordingConfigurationArn => Str]
720  
721 =item [Tags => L<Paws::IVS::Tags>]
722  
723 =item [Type => Str]
724  
725  
726 =back
727  
728 Each argument is described in detail in: L<Paws::IVS::CreateChannel>
729  
730 Returns: a L<Paws::IVS::CreateChannelResponse> instance
731  
732 Creates a new channel and an associated stream key to start streaming.
733  
734  
735 =head2 CreateRecordingConfiguration
736  
737 =over
738  
739 =item DestinationConfiguration => L<Paws::IVS::DestinationConfiguration>
740  
741 =item [Name => Str]
742  
743 =item [Tags => L<Paws::IVS::Tags>]
744  
745  
746 =back
747  
748 Each argument is described in detail in: L<Paws::IVS::CreateRecordingConfiguration>
749  
750 Returns: a L<Paws::IVS::CreateRecordingConfigurationResponse> instance
751  
752 Creates a new recording configuration, used to enable recording to
753 Amazon S3.
754  
755 B<Known issue:> In the us-east-1 region, if you use the AWS CLI to
756 create a recording configuration, it returns success even if the S3
757 bucket is in a different region. In this case, the C<state> of the
758 recording configuration is C<CREATE_FAILED> (instead of C<ACTIVE>). (In
759 other regions, the CLI correctly returns failure if the bucket is in a
760 different region.)
761  
762 B<Workaround:> Ensure that your S3 bucket is in the same region as the
763 recording configuration. If you create a recording configuration in a
764 different region as your S3 bucket, delete that recording configuration
765 and create a new one with an S3 bucket from the correct region.
766  
767  
768 =head2 CreateStreamKey
769  
770 =over
771  
772 =item ChannelArn => Str
773  
774 =item [Tags => L<Paws::IVS::Tags>]
775  
776  
777 =back
778  
779 Each argument is described in detail in: L<Paws::IVS::CreateStreamKey>
780  
781 Returns: a L<Paws::IVS::CreateStreamKeyResponse> instance
782  
783 Creates a stream key, used to initiate a stream, for the specified
784 channel ARN.
785  
786 Note that CreateChannel creates a stream key. If you subsequently use
787 CreateStreamKey on the same channel, it will fail because a stream key
788 already exists and there is a limit of 1 stream key per channel. To
789 reset the stream key on a channel, use DeleteStreamKey and then
790 CreateStreamKey.
791  
792  
793 =head2 DeleteChannel
794  
795 =over
796  
797 =item Arn => Str
798  
799  
800 =back
801  
802 Each argument is described in detail in: L<Paws::IVS::DeleteChannel>
803  
804 Returns: nothing
805  
806 Deletes the specified channel and its associated stream keys.
807  
808 If you try to delete a live channel, you will get an error (409
809 ConflictException). To delete a channel that is live, call StopStream,
810 wait for the Amazon EventBridge "Stream End" event (to verify that the
811 stream's state was changed from Live to Offline), then call
812 DeleteChannel. (See Using EventBridge with Amazon IVS
813 (https://docs.aws.amazon.com/ivs/latest/userguide/eventbridge.html).)
814  
815  
816 =head2 DeletePlaybackKeyPair
817  
818 =over
819  
820 =item Arn => Str
821  
822  
823 =back
824  
825 Each argument is described in detail in: L<Paws::IVS::DeletePlaybackKeyPair>
826  
827 Returns: a L<Paws::IVS::DeletePlaybackKeyPairResponse> instance
828  
829 Deletes a specified authorization key pair. This invalidates future
830 viewer tokens generated using the key pairE<rsquo>s C<privateKey>. For
831 more information, see Setting Up Private Channels
832 (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
833 in the I<Amazon IVS User Guide>.
834  
835  
836 =head2 DeleteRecordingConfiguration
837  
838 =over
839  
840 =item Arn => Str
841  
842  
843 =back
844  
845 Each argument is described in detail in: L<Paws::IVS::DeleteRecordingConfiguration>
846  
847 Returns: nothing
848  
849 Deletes the recording configuration for the specified ARN.
850  
851 If you try to delete a recording configuration that is associated with
852 a channel, you will get an error (409 ConflictException). To avoid
853 this, for all channels that reference the recording configuration,
854 first use UpdateChannel to set the C<recordingConfigurationArn> field
855 to an empty string, then use DeleteRecordingConfiguration.
856  
857  
858 =head2 DeleteStreamKey
859  
860 =over
861  
862 =item Arn => Str
863  
864  
865 =back
866  
867 Each argument is described in detail in: L<Paws::IVS::DeleteStreamKey>
868  
869 Returns: nothing
870  
871 Deletes the stream key for the specified ARN, so it can no longer be
872 used to stream.
873  
874  
875 =head2 GetChannel
876  
877 =over
878  
879 =item Arn => Str
880  
881  
882 =back
883  
884 Each argument is described in detail in: L<Paws::IVS::GetChannel>
885  
886 Returns: a L<Paws::IVS::GetChannelResponse> instance
887  
888 Gets the channel configuration for the specified channel ARN. See also
889 BatchGetChannel.
890  
891  
892 =head2 GetPlaybackKeyPair
893  
894 =over
895  
896 =item Arn => Str
897  
898  
899 =back
900  
901 Each argument is described in detail in: L<Paws::IVS::GetPlaybackKeyPair>
902  
903 Returns: a L<Paws::IVS::GetPlaybackKeyPairResponse> instance
904  
905 Gets a specified playback authorization key pair and returns the C<arn>
906 and C<fingerprint>. The C<privateKey> held by the caller can be used to
907 generate viewer authorization tokens, to grant viewers access to
908 private channels. For more information, see Setting Up Private Channels
909 (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
910 in the I<Amazon IVS User Guide>.
911  
912  
913 =head2 GetRecordingConfiguration
914  
915 =over
916  
917 =item Arn => Str
918  
919  
920 =back
921  
922 Each argument is described in detail in: L<Paws::IVS::GetRecordingConfiguration>
923  
924 Returns: a L<Paws::IVS::GetRecordingConfigurationResponse> instance
925  
926 Gets the recording configuration for the specified ARN.
927  
928  
929 =head2 GetStream
930  
931 =over
932  
933 =item ChannelArn => Str
934  
935  
936 =back
937  
938 Each argument is described in detail in: L<Paws::IVS::GetStream>
939  
940 Returns: a L<Paws::IVS::GetStreamResponse> instance
941  
942 Gets information about the active (live) stream on a specified channel.
943  
944  
945 =head2 GetStreamKey
946  
947 =over
948  
949 =item Arn => Str
950  
951  
952 =back
953  
954 Each argument is described in detail in: L<Paws::IVS::GetStreamKey>
955  
956 Returns: a L<Paws::IVS::GetStreamKeyResponse> instance
957  
958 Gets stream-key information for a specified ARN.
959  
960  
961 =head2 ImportPlaybackKeyPair
962  
963 =over
964  
965 =item PublicKeyMaterial => Str
966  
967 =item [Name => Str]
968  
969 =item [Tags => L<Paws::IVS::Tags>]
970  
971  
972 =back
973  
974 Each argument is described in detail in: L<Paws::IVS::ImportPlaybackKeyPair>
975  
976 Returns: a L<Paws::IVS::ImportPlaybackKeyPairResponse> instance
977  
978 Imports the public portion of a new key pair and returns its C<arn> and
979 C<fingerprint>. The C<privateKey> can then be used to generate viewer
980 authorization tokens, to grant viewers access to private channels. For
981 more information, see Setting Up Private Channels
982 (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
983 in the I<Amazon IVS User Guide>.
984  
985  
986 =head2 ListChannels
987  
988 =over
989  
990 =item [FilterByName => Str]
991  
992 =item [FilterByRecordingConfigurationArn => Str]
993  
994 =item [MaxResults => Int]
995  
996 =item [NextToken => Str]
997  
998  
999 =back
1000  
1001 Each argument is described in detail in: L<Paws::IVS::ListChannels>
1002  
1003 Returns: a L<Paws::IVS::ListChannelsResponse> instance
1004  
1005 Gets summary information about all channels in your account, in the AWS
1006 region where the API request is processed. This list can be filtered to
1007 match a specified name or recording-configuration ARN. Filters are
1008 mutually exclusive and cannot be used together. If you try to use both
1009 filters, you will get an error (409 ConflictException).
1010  
1011  
1012 =head2 ListPlaybackKeyPairs
1013  
1014 =over
1015  
1016 =item [MaxResults => Int]
1017  
1018 =item [NextToken => Str]
1019  
1020  
1021 =back
1022  
1023 Each argument is described in detail in: L<Paws::IVS::ListPlaybackKeyPairs>
1024  
1025 Returns: a L<Paws::IVS::ListPlaybackKeyPairsResponse> instance
1026  
1027 Gets summary information about playback key pairs. For more
1028 information, see Setting Up Private Channels
1029 (https://docs.aws.amazon.com/ivs/latest/userguide/private-channels.html)
1030 in the I<Amazon IVS User Guide>.
1031  
1032  
1033 =head2 ListRecordingConfigurations
1034  
1035 =over
1036  
1037 =item [MaxResults => Int]
1038  
1039 =item [NextToken => Str]
1040  
1041  
1042 =back
1043  
1044 Each argument is described in detail in: L<Paws::IVS::ListRecordingConfigurations>
1045  
1046 Returns: a L<Paws::IVS::ListRecordingConfigurationsResponse> instance
1047  
1048 Gets summary information about all recording configurations in your
1049 account, in the AWS region where the API request is processed.
1050  
1051  
1052 =head2 ListStreamKeys
1053  
1054 =over
1055  
1056 =item ChannelArn => Str
1057  
1058 =item [MaxResults => Int]
1059  
1060 =item [NextToken => Str]
1061  
1062  
1063 =back
1064  
1065 Each argument is described in detail in: L<Paws::IVS::ListStreamKeys>
1066  
1067 Returns: a L<Paws::IVS::ListStreamKeysResponse> instance
1068  
1069 Gets summary information about stream keys for the specified channel.
1070  
1071  
1072 =head2 ListStreams
1073  
1074 =over
1075  
1076 =item [MaxResults => Int]
1077  
1078 =item [NextToken => Str]
1079  
1080  
1081 =back
1082  
1083 Each argument is described in detail in: L<Paws::IVS::ListStreams>
1084  
1085 Returns: a L<Paws::IVS::ListStreamsResponse> instance
1086  
1087 Gets summary information about live streams in your account, in the AWS
1088 region where the API request is processed.
1089  
1090  
1091 =head2 ListTagsForResource
1092  
1093 =over
1094  
1095 =item ResourceArn => Str
1096  
1097 =item [MaxResults => Int]
1098  
1099 =item [NextToken => Str]
1100  
1101  
1102 =back
1103  
1104 Each argument is described in detail in: L<Paws::IVS::ListTagsForResource>
1105  
1106 Returns: a L<Paws::IVS::ListTagsForResourceResponse> instance
1107  
1108 Gets information about AWS tags for the specified ARN.
1109  
1110  
1111 =head2 PutMetadata
1112  
1113 =over
1114  
1115 =item ChannelArn => Str
1116  
1117 =item Metadata => Str
1118  
1119  
1120 =back
1121  
1122 Each argument is described in detail in: L<Paws::IVS::PutMetadata>
1123  
1124 Returns: nothing
1125  
1126 Inserts metadata into the active stream of the specified channel. A
1127 maximum of 5 requests per second per channel is allowed, each with a
1128 maximum 1 KB payload. (If 5 TPS is not sufficient for your needs, we
1129 recommend batching your data into a single PutMetadata call.) Also see
1130 Embedding Metadata within a Video Stream
1131 (https://docs.aws.amazon.com/ivs/latest/userguide/metadata.html) in the
1132 I<Amazon IVS User Guide>.
1133  
1134  
1135 =head2 StopStream
1136  
1137 =over
1138  
1139 =item ChannelArn => Str
1140  
1141  
1142 =back
1143  
1144 Each argument is described in detail in: L<Paws::IVS::StopStream>
1145  
1146 Returns: a L<Paws::IVS::StopStreamResponse> instance
1147  
1148 Disconnects the incoming RTMPS stream for the specified channel. Can be
1149 used in conjunction with DeleteStreamKey to prevent further streaming
1150 to a channel.
1151  
1152 Many streaming client-software libraries automatically reconnect a
1153 dropped RTMPS session, so to stop the stream permanently, you may want
1154 to first revoke the C<streamKey> attached to the channel.
1155  
1156  
1157 =head2 TagResource
1158  
1159 =over
1160  
1161 =item ResourceArn => Str
1162  
1163 =item Tags => L<Paws::IVS::Tags>
1164  
1165  
1166 =back
1167  
1168 Each argument is described in detail in: L<Paws::IVS::TagResource>
1169  
1170 Returns: a L<Paws::IVS::TagResourceResponse> instance
1171  
1172 Adds or updates tags for the AWS resource with the specified ARN.
1173  
1174  
1175 =head2 UntagResource
1176  
1177 =over
1178  
1179 =item ResourceArn => Str
1180  
1181 =item TagKeys => ArrayRef[Str|Undef]
1182  
1183  
1184 =back
1185  
1186 Each argument is described in detail in: L<Paws::IVS::UntagResource>
1187  
1188 Returns: a L<Paws::IVS::UntagResourceResponse> instance
1189  
1190 Removes tags from the resource with the specified ARN.
1191  
1192  
1193 =head2 UpdateChannel
1194  
1195 =over
1196  
1197 =item Arn => Str
1198  
1199 =item [Authorized => Bool]
1200  
1201 =item [LatencyMode => Str]
1202  
1203 =item [Name => Str]
1204  
1205 =item [RecordingConfigurationArn => Str]
1206  
1207 =item [Type => Str]
1208  
1209  
1210 =back
1211  
1212 Each argument is described in detail in: L<Paws::IVS::UpdateChannel>
1213  
1214 Returns: a L<Paws::IVS::UpdateChannelResponse> instance
1215  
1216 Updates a channel's configuration. This does not affect an ongoing
1217 stream of this channel. You must stop and restart the stream for the
1218 changes to take effect.
1219  
1220  
1221  
1222  
1223 =head1 PAGINATORS
1224  
1225 Paginator methods are helpers that repetively call methods that return partial results
1226  
1227 =head2 ListAllChannels(sub { },[FilterByName => Str, FilterByRecordingConfigurationArn => Str, MaxResults => Int, NextToken => Str])
1228  
1229 =head2 ListAllChannels([FilterByName => Str, FilterByRecordingConfigurationArn => Str, MaxResults => Int, NextToken => Str])
1230  
1231  
1232 If passed a sub as first parameter, it will call the sub for each element found in :
1233  
1234 - channels, passing the object as the first parameter, and the string 'channels' as the second parameter
1235  
1236 If not, it will return a a L<Paws::IVS::ListChannelsResponse> 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.
1237  
1238  
1239 =head2 ListAllPlaybackKeyPairs(sub { },[MaxResults => Int, NextToken => Str])
1240  
1241 =head2 ListAllPlaybackKeyPairs([MaxResults => Int, NextToken => Str])
1242  
1243  
1244 If passed a sub as first parameter, it will call the sub for each element found in :
1245  
1246 - keyPairs, passing the object as the first parameter, and the string 'keyPairs' as the second parameter
1247  
1248 If not, it will return a a L<Paws::IVS::ListPlaybackKeyPairsResponse> 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.
1249  
1250  
1251 =head2 ListAllRecordingConfigurations(sub { },[MaxResults => Int, NextToken => Str])
1252  
1253 =head2 ListAllRecordingConfigurations([MaxResults => Int, NextToken => Str])
1254  
1255  
1256 If passed a sub as first parameter, it will call the sub for each element found in :
1257  
1258 - recordingConfigurations, passing the object as the first parameter, and the string 'recordingConfigurations' as the second parameter
1259  
1260 If not, it will return a a L<Paws::IVS::ListRecordingConfigurationsResponse> 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.
1261  
1262  
1263 =head2 ListAllStreamKeys(sub { },ChannelArn => Str, [MaxResults => Int, NextToken => Str])
1264  
1265 =head2 ListAllStreamKeys(ChannelArn => Str, [MaxResults => Int, NextToken => Str])
1266  
1267  
1268 If passed a sub as first parameter, it will call the sub for each element found in :
1269  
1270 - streamKeys, passing the object as the first parameter, and the string 'streamKeys' as the second parameter
1271  
1272 If not, it will return a a L<Paws::IVS::ListStreamKeysResponse> 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.
1273  
1274  
1275 =head2 ListAllStreams(sub { },[MaxResults => Int, NextToken => Str])
1276  
1277 =head2 ListAllStreams([MaxResults => Int, NextToken => Str])
1278  
1279  
1280 If passed a sub as first parameter, it will call the sub for each element found in :
1281  
1282 - streams, passing the object as the first parameter, and the string 'streams' as the second parameter
1283  
1284 If not, it will return a a L<Paws::IVS::ListStreamsResponse> 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.
1285  
1286  
1287  
1288  
1289  
1290 =head1 SEE ALSO
1291  
1292 This service class forms part of L<Paws>
1293  
1294 =head1 BUGS and CONTRIBUTIONS
1295  
1296 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1297  
1298 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1299  
1300 =cut
1301