Documentation

Overview

Package ivs provides the API client, operations, and parameter types for Amazon Interactive Video Service.

Introduction The Amazon Interactive Video Service (IVS) API is REST compatible, using a standard HTTP API and an AWS SNS (http://aws.amazon.com/sns) event stream for responses. JSON is used for both requests and responses, including errors. The API is an AWS regional service, currently in these regions: us-west-2, us-east-1, and eu-west-1. All API request parameters and URLs are case sensitive. For a summary of notable documentation changes in each release, see Document History (https://docs.aws.amazon.com/ivs/latest/userguide/doc-history.html). Service Endpoints The following are the Amazon IVS service endpoints (all HTTPS): Region name: US West (Oregon)

* Region: us-west-2

* Endpoint: ivs.us-west-2.amazonaws.com

Region name: US East (Virginia)

* Region: us-east-1

* Endpoint: ivs.us-east-1.amazonaws.com

Region name: EU West (Dublin)

* Region: eu-west-1

* Endpoint: ivs.eu-west-1.amazonaws.com

Allowed Header Values

* Accept: application/json

* Accept-Encoding: gzip, deflate

* Content-Type: application/json

Resources The following resources contain information about your IVS live stream (see Getting Started with Amazon IVS (https://docs.aws.amazon.com/ivs/latest/userguide/GSIVS.html)):

* Channel — Stores configuration data related to your live stream. You first create a channel and then use the channel’s stream key to start your live stream. See the Channel endpoints for more information.

* Stream key — An identifier assigned by Amazon IVS when you create a channel, which is then used to authorize streaming. See the StreamKey endpoints for more information. Treat the stream key like a secret, since it allows anyone to stream to the channel.

* Playback key pair — Video playback may be restricted using playback-authorization tokens, which use public-key encryption. A playback key pair is the public-private pair of keys used to sign and validate the playback-authorization token. See the PlaybackKeyPair endpoints for more information.

Tagging A tag is a metadata label that you assign to an AWS resource. A tag comprises a key and a value, both set by you. For example, you might set a tag as topic:nature to label a particular video category. See Tagging AWS Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) for more information, including restrictions that apply to tags. Tags can help you identify and organize your AWS resources. For example, you can use the same tag for different resources to indicate that they are related. You can also use tags to manage access (see Access Tags (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)). The Amazon IVS API has these tag-related endpoints: TagResource, UntagResource, and ListTagsForResource. The following resources support tagging: Channels, Stream Keys, and Playback Key Pairs. Channel Endpoints

* CreateChannel — Creates a new channel and an associated stream key to start streaming.

* GetChannel — Gets the channel configuration for the specified channel ARN (Amazon Resource Name).

* BatchGetChannel — Performs GetChannel on multiple ARNs simultaneously.

* ListChannels — Gets summary information about all channels in your account, in the AWS region where the API request is processed. This list can be filtered to match a specified string.

* UpdateChannel — Updates a channel's configuration. This does not affect an ongoing stream of this channel. You must stop and restart the stream for the changes to take effect.

* DeleteChannel — Deletes the specified channel.

StreamKey Endpoints

* CreateStreamKey — Creates a stream key, used to initiate a stream, for the specified channel ARN.

* GetStreamKey — Gets stream key information for the specified ARN.

* BatchGetStreamKey — Performs GetStreamKey on multiple ARNs simultaneously.

* ListStreamKeys — Gets summary information about stream keys for the specified channel.

* DeleteStreamKey — Deletes the stream key for the specified ARN, so it can no longer be used to stream.

Stream Endpoints

* GetStream — Gets information about the active (live) stream on a specified channel.

* ListStreams — Gets summary information about live streams in your account, in the AWS region where the API request is processed.

* StopStream — Disconnects the incoming RTMPS stream for the specified channel. Can be used in conjunction with DeleteStreamKey to prevent further streaming to a channel.

* PutMetadata — Inserts metadata into an RTMPS stream for the specified channel. A maximum of 5 requests per second per channel is allowed, each with a maximum 1KB payload.

PlaybackKeyPair Endpoints

* ImportPlaybackKeyPair — Imports the public portion of a new key pair and returns its arn and fingerprint. The privateKey can then be used to generate viewer authorization tokens, to grant viewers access to authorized channels.

* GetPlaybackKeyPair — Gets a specified playback authorization key pair and returns the arn and fingerprint. The privateKey held by the caller can be used to generate viewer authorization tokens, to grant viewers access to authorized channels.

* ListPlaybackKeyPairs — Gets summary information about playback key pairs.

* DeletePlaybackKeyPair — Deletes a specified authorization key pair. This invalidates future viewer tokens generated using the key pair’s privateKey.

AWS Tags Endpoints

* TagResource — Adds or updates tags for the AWS resource with the specified ARN.

* UntagResource — Removes tags from the resource with the specified ARN.

* ListTagsForResource — Gets information about AWS tags for the specified ARN.

Index

Constants

View Source
const ServiceAPIVersion = "2020-07-14"
View Source
const ServiceID = "ivs"

Variables

This section is empty.

Functions

func NewDefaultEndpointResolver

func NewDefaultEndpointResolver() *internalendpoints.Resolver

    NewDefaultEndpointResolver constructs a new service endpoint resolver

    func WithAPIOptions

    func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

      WithAPIOptions returns a functional option for setting the Client's APIOptions option.

      func WithEndpointResolver

      func WithEndpointResolver(v EndpointResolver) func(*Options)

        WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

        Types

        type BatchGetChannelInput

        type BatchGetChannelInput struct {
        
        	// Array of ARNs, one per channel.
        	//
        	// This member is required.
        	Arns []string
        }

        type BatchGetChannelOutput

        type BatchGetChannelOutput struct {
        	Channels []types.Channel
        
        	// Each error object is related to a specific ARN in the request.
        	Errors []types.BatchError
        
        	// Metadata pertaining to the operation's result.
        	ResultMetadata middleware.Metadata
        }

        type BatchGetStreamKeyInput

        type BatchGetStreamKeyInput struct {
        
        	// Array of ARNs, one per channel.
        	//
        	// This member is required.
        	Arns []string
        }

        type BatchGetStreamKeyOutput

        type BatchGetStreamKeyOutput struct {
        	Errors []types.BatchError
        
        	StreamKeys []types.StreamKey
        
        	// Metadata pertaining to the operation's result.
        	ResultMetadata middleware.Metadata
        }

        type Client

        type Client struct {
        	// contains filtered or unexported fields
        }

          Client provides the API client to make operations call for Amazon Interactive Video Service.

          func New

          func New(options Options, optFns ...func(*Options)) *Client

            New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

            func NewFromConfig

            func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

              NewFromConfig returns a new client from the provided config.

              func (*Client) BatchGetChannel

              func (c *Client) BatchGetChannel(ctx context.Context, params *BatchGetChannelInput, optFns ...func(*Options)) (*BatchGetChannelOutput, error)

                Performs GetChannel on multiple ARNs simultaneously.

                func (*Client) BatchGetStreamKey

                func (c *Client) BatchGetStreamKey(ctx context.Context, params *BatchGetStreamKeyInput, optFns ...func(*Options)) (*BatchGetStreamKeyOutput, error)

                  Performs GetStreamKey on multiple ARNs simultaneously.

                  func (*Client) CreateChannel

                  func (c *Client) CreateChannel(ctx context.Context, params *CreateChannelInput, optFns ...func(*Options)) (*CreateChannelOutput, error)

                    Creates a new channel and an associated stream key to start streaming.

                    func (*Client) CreateStreamKey

                    func (c *Client) CreateStreamKey(ctx context.Context, params *CreateStreamKeyInput, optFns ...func(*Options)) (*CreateStreamKeyOutput, error)

                      Creates a stream key, used to initiate a stream, for the specified channel ARN. Note that CreateChannel creates a stream key. If you subsequently use CreateStreamKey on the same channel, it will fail because a stream key already exists and there is a limit of 1 stream key per channel. To reset the stream key on a channel, use DeleteStreamKey and then CreateStreamKey.

                      func (*Client) DeleteChannel

                      func (c *Client) DeleteChannel(ctx context.Context, params *DeleteChannelInput, optFns ...func(*Options)) (*DeleteChannelOutput, error)

                        Deletes the specified channel and its associated stream keys.

                        func (*Client) DeletePlaybackKeyPair

                        func (c *Client) DeletePlaybackKeyPair(ctx context.Context, params *DeletePlaybackKeyPairInput, optFns ...func(*Options)) (*DeletePlaybackKeyPairOutput, error)

                          Deletes a specified authorization key pair. This invalidates future viewer tokens generated using the key pair’s privateKey.

                          func (*Client) DeleteStreamKey

                          func (c *Client) DeleteStreamKey(ctx context.Context, params *DeleteStreamKeyInput, optFns ...func(*Options)) (*DeleteStreamKeyOutput, error)

                            Deletes the stream key for the specified ARN, so it can no longer be used to stream.

                            func (*Client) GetChannel

                            func (c *Client) GetChannel(ctx context.Context, params *GetChannelInput, optFns ...func(*Options)) (*GetChannelOutput, error)

                              Gets the channel configuration for the specified channel ARN. See also BatchGetChannel.

                              func (*Client) GetPlaybackKeyPair

                              func (c *Client) GetPlaybackKeyPair(ctx context.Context, params *GetPlaybackKeyPairInput, optFns ...func(*Options)) (*GetPlaybackKeyPairOutput, error)

                                Gets a specified playback authorization key pair and returns the arn and fingerprint. The privateKey held by the caller can be used to generate viewer authorization tokens, to grant viewers access to authorized channels.

                                func (*Client) GetStream

                                func (c *Client) GetStream(ctx context.Context, params *GetStreamInput, optFns ...func(*Options)) (*GetStreamOutput, error)

                                  Gets information about the active (live) stream on a specified channel.

                                  func (*Client) GetStreamKey

                                  func (c *Client) GetStreamKey(ctx context.Context, params *GetStreamKeyInput, optFns ...func(*Options)) (*GetStreamKeyOutput, error)

                                    Gets stream-key information for a specified ARN.

                                    func (*Client) ImportPlaybackKeyPair

                                    func (c *Client) ImportPlaybackKeyPair(ctx context.Context, params *ImportPlaybackKeyPairInput, optFns ...func(*Options)) (*ImportPlaybackKeyPairOutput, error)

                                      Imports the public portion of a new key pair and returns its arn and fingerprint. The privateKey can then be used to generate viewer authorization tokens, to grant viewers access to authorized channels.

                                      func (*Client) ListChannels

                                      func (c *Client) ListChannels(ctx context.Context, params *ListChannelsInput, optFns ...func(*Options)) (*ListChannelsOutput, error)

                                        Gets summary information about all channels in your account, in the AWS region where the API request is processed. This list can be filtered to match a specified string.

                                        func (*Client) ListPlaybackKeyPairs

                                        func (c *Client) ListPlaybackKeyPairs(ctx context.Context, params *ListPlaybackKeyPairsInput, optFns ...func(*Options)) (*ListPlaybackKeyPairsOutput, error)

                                          Gets summary information about playback key pairs.

                                          func (*Client) ListStreamKeys

                                          func (c *Client) ListStreamKeys(ctx context.Context, params *ListStreamKeysInput, optFns ...func(*Options)) (*ListStreamKeysOutput, error)

                                            Gets summary information about stream keys for the specified channel.

                                            func (*Client) ListStreams

                                            func (c *Client) ListStreams(ctx context.Context, params *ListStreamsInput, optFns ...func(*Options)) (*ListStreamsOutput, error)

                                              Gets summary information about live streams in your account, in the AWS region where the API request is processed.

                                              func (*Client) ListTagsForResource

                                              func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                Gets information about AWS tags for the specified ARN.

                                                func (*Client) PutMetadata

                                                func (c *Client) PutMetadata(ctx context.Context, params *PutMetadataInput, optFns ...func(*Options)) (*PutMetadataOutput, error)

                                                  Inserts metadata into an RTMPS stream for the specified channel. A maximum of 5 requests per second per channel is allowed, each with a maximum 1KB payload.

                                                  func (*Client) StopStream

                                                  func (c *Client) StopStream(ctx context.Context, params *StopStreamInput, optFns ...func(*Options)) (*StopStreamOutput, error)

                                                    Disconnects the incoming RTMPS stream for the specified channel. Can be used in conjunction with DeleteStreamKey to prevent further streaming to a channel. Many streaming client-software libraries automatically reconnect a dropped RTMPS session, so to stop the stream permanently, you may want to first revoke the streamKey attached to the channel.

                                                    func (*Client) TagResource

                                                    func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                      Adds or updates tags for the AWS resource with the specified ARN.

                                                      func (*Client) UntagResource

                                                      func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                        Removes tags from the resource with the specified ARN.

                                                        func (*Client) UpdateChannel

                                                        func (c *Client) UpdateChannel(ctx context.Context, params *UpdateChannelInput, optFns ...func(*Options)) (*UpdateChannelOutput, error)

                                                          Updates a channel's configuration. This does not affect an ongoing stream of this channel. You must stop and restart the stream for the changes to take effect.

                                                          type CreateChannelInput

                                                          type CreateChannelInput struct {
                                                          
                                                          	// Whether the channel is authorized. Default: false.
                                                          	Authorized bool
                                                          
                                                          	// Channel latency mode. Default: LOW.
                                                          	LatencyMode types.ChannelLatencyMode
                                                          
                                                          	// Channel name.
                                                          	Name *string
                                                          
                                                          	// See Channel$tags.
                                                          	Tags map[string]string
                                                          
                                                          	// Channel type, which determines the allowable resolution and bitrate. If you
                                                          	// exceed the allowable resolution or bitrate, the stream probably will disconnect
                                                          	// immediately. Valid values:
                                                          	//
                                                          	// * STANDARD: Multiple qualities are generated from
                                                          	// the original input, to automatically give viewers the best experience for their
                                                          	// devices and network conditions. Vertical resolution can be up to 1080 and
                                                          	// bitrate can be up to 8.5 Mbps.
                                                          	//
                                                          	// * BASIC: Amazon IVS delivers the original input
                                                          	// to viewers. The viewer’s video-quality choice is limited to the original input.
                                                          	// Vertical resolution can be up to 480 and bitrate can be up to 1.5
                                                          	// Mbps.
                                                          	//
                                                          	// Default: STANDARD.
                                                          	Type types.ChannelType
                                                          }

                                                          type CreateChannelOutput

                                                          type CreateChannelOutput struct {
                                                          
                                                          	// Object specifying a channel.
                                                          	Channel *types.Channel
                                                          
                                                          	// Object specifying a stream key.
                                                          	StreamKey *types.StreamKey
                                                          
                                                          	// Metadata pertaining to the operation's result.
                                                          	ResultMetadata middleware.Metadata
                                                          }

                                                          type CreateStreamKeyInput

                                                          type CreateStreamKeyInput struct {
                                                          
                                                          	// ARN of the channel for which to create the stream key.
                                                          	//
                                                          	// This member is required.
                                                          	ChannelArn *string
                                                          
                                                          	// See Channel$tags.
                                                          	Tags map[string]string
                                                          }

                                                          type CreateStreamKeyOutput

                                                          type CreateStreamKeyOutput struct {
                                                          
                                                          	// Stream key used to authenticate an RTMPS stream for ingestion.
                                                          	StreamKey *types.StreamKey
                                                          
                                                          	// Metadata pertaining to the operation's result.
                                                          	ResultMetadata middleware.Metadata
                                                          }

                                                          type DeleteChannelInput

                                                          type DeleteChannelInput struct {
                                                          
                                                          	// ARN of the channel to be deleted.
                                                          	//
                                                          	// This member is required.
                                                          	Arn *string
                                                          }

                                                          type DeleteChannelOutput

                                                          type DeleteChannelOutput struct {
                                                          	// Metadata pertaining to the operation's result.
                                                          	ResultMetadata middleware.Metadata
                                                          }

                                                          type DeletePlaybackKeyPairInput

                                                          type DeletePlaybackKeyPairInput struct {
                                                          
                                                          	// ARN of the key pair to be deleted.
                                                          	//
                                                          	// This member is required.
                                                          	Arn *string
                                                          }

                                                          type DeletePlaybackKeyPairOutput

                                                          type DeletePlaybackKeyPairOutput struct {
                                                          	// Metadata pertaining to the operation's result.
                                                          	ResultMetadata middleware.Metadata
                                                          }

                                                          type DeleteStreamKeyInput

                                                          type DeleteStreamKeyInput struct {
                                                          
                                                          	// ARN of the stream key to be deleted.
                                                          	//
                                                          	// This member is required.
                                                          	Arn *string
                                                          }

                                                          type DeleteStreamKeyOutput

                                                          type DeleteStreamKeyOutput struct {
                                                          	// Metadata pertaining to the operation's result.
                                                          	ResultMetadata middleware.Metadata
                                                          }

                                                          type EndpointResolver

                                                          type EndpointResolver interface {
                                                          	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                          }

                                                            EndpointResolver interface for resolving service endpoints.

                                                            func EndpointResolverFromURL

                                                            func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                              EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                              type EndpointResolverFunc

                                                              type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                func (EndpointResolverFunc) ResolveEndpoint

                                                                func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                type EndpointResolverOptions

                                                                type EndpointResolverOptions = internalendpoints.Options

                                                                  EndpointResolverOptions is the service endpoint resolver options

                                                                  type GetChannelInput

                                                                  type GetChannelInput struct {
                                                                  
                                                                  	// ARN of the channel for which the configuration is to be retrieved.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Arn *string
                                                                  }

                                                                  type GetChannelOutput

                                                                  type GetChannelOutput struct {
                                                                  
                                                                  	// Object specifying a channel.
                                                                  	Channel *types.Channel
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type GetPlaybackKeyPairInput

                                                                  type GetPlaybackKeyPairInput struct {
                                                                  
                                                                  	// ARN of the key pair to be returned.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Arn *string
                                                                  }

                                                                  type GetPlaybackKeyPairOutput

                                                                  type GetPlaybackKeyPairOutput struct {
                                                                  
                                                                  	// A key pair used to sign and validate a playback authorization token.
                                                                  	KeyPair *types.PlaybackKeyPair
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type GetStreamInput

                                                                  type GetStreamInput struct {
                                                                  
                                                                  	// Channel ARN for stream to be accessed.
                                                                  	//
                                                                  	// This member is required.
                                                                  	ChannelArn *string
                                                                  }

                                                                  type GetStreamKeyInput

                                                                  type GetStreamKeyInput struct {
                                                                  
                                                                  	// ARN for the stream key to be retrieved.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Arn *string
                                                                  }

                                                                  type GetStreamKeyOutput

                                                                  type GetStreamKeyOutput struct {
                                                                  
                                                                  	// Object specifying a stream key.
                                                                  	StreamKey *types.StreamKey
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type GetStreamOutput

                                                                  type GetStreamOutput struct {
                                                                  
                                                                  	// Specifies a live video stream that has been ingested and distributed.
                                                                  	Stream *types.Stream
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type HTTPClient

                                                                  type HTTPClient interface {
                                                                  	Do(*http.Request) (*http.Response, error)
                                                                  }

                                                                  type HTTPSignerV4

                                                                  type HTTPSignerV4 interface {
                                                                  	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                  }

                                                                  type ImportPlaybackKeyPairInput

                                                                  type ImportPlaybackKeyPairInput struct {
                                                                  
                                                                  	// The public portion of a customer-generated key pair.
                                                                  	//
                                                                  	// This member is required.
                                                                  	PublicKeyMaterial *string
                                                                  
                                                                  	// An arbitrary string (a nickname) assigned to a playback key pair that helps the
                                                                  	// customer identify that resource. The value does not need to be unique.
                                                                  	Name *string
                                                                  
                                                                  	// Any tags provided with the request are added to the playback key pair tags.
                                                                  	Tags map[string]string
                                                                  }

                                                                  type ImportPlaybackKeyPairOutput

                                                                  type ImportPlaybackKeyPairOutput struct {
                                                                  
                                                                  	// A key pair used to sign and validate a playback authorization token.
                                                                  	KeyPair *types.PlaybackKeyPair
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type ListChannelsAPIClient

                                                                  type ListChannelsAPIClient interface {
                                                                  	ListChannels(context.Context, *ListChannelsInput, ...func(*Options)) (*ListChannelsOutput, error)
                                                                  }

                                                                    ListChannelsAPIClient is a client that implements the ListChannels operation.

                                                                    type ListChannelsInput

                                                                    type ListChannelsInput struct {
                                                                    
                                                                    	// Filters the channel list to match the specified name.
                                                                    	FilterByName *string
                                                                    
                                                                    	// Maximum number of channels to return.
                                                                    	MaxResults int32
                                                                    
                                                                    	// The first channel to retrieve. This is used for pagination; see the nextToken
                                                                    	// response field.
                                                                    	NextToken *string
                                                                    }

                                                                    type ListChannelsOutput

                                                                    type ListChannelsOutput struct {
                                                                    
                                                                    	// List of the matching channels.
                                                                    	//
                                                                    	// This member is required.
                                                                    	Channels []types.ChannelSummary
                                                                    
                                                                    	// If there are more channels than maxResults, use nextToken in the request to get
                                                                    	// the next set.
                                                                    	NextToken *string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type ListChannelsPaginator

                                                                    type ListChannelsPaginator struct {
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                      ListChannelsPaginator is a paginator for ListChannels

                                                                      func NewListChannelsPaginator

                                                                      func NewListChannelsPaginator(client ListChannelsAPIClient, params *ListChannelsInput, optFns ...func(*ListChannelsPaginatorOptions)) *ListChannelsPaginator

                                                                        NewListChannelsPaginator returns a new ListChannelsPaginator

                                                                        func (*ListChannelsPaginator) HasMorePages

                                                                        func (p *ListChannelsPaginator) HasMorePages() bool

                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                          func (*ListChannelsPaginator) NextPage

                                                                          func (p *ListChannelsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListChannelsOutput, error)

                                                                            NextPage retrieves the next ListChannels page.

                                                                            type ListChannelsPaginatorOptions

                                                                            type ListChannelsPaginatorOptions struct {
                                                                            	// Maximum number of channels to return.
                                                                            	Limit int32
                                                                            
                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                            	// that matches the most recent token provided to the service.
                                                                            	StopOnDuplicateToken bool
                                                                            }

                                                                              ListChannelsPaginatorOptions is the paginator options for ListChannels

                                                                              type ListPlaybackKeyPairsAPIClient

                                                                              type ListPlaybackKeyPairsAPIClient interface {
                                                                              	ListPlaybackKeyPairs(context.Context, *ListPlaybackKeyPairsInput, ...func(*Options)) (*ListPlaybackKeyPairsOutput, error)
                                                                              }

                                                                                ListPlaybackKeyPairsAPIClient is a client that implements the ListPlaybackKeyPairs operation.

                                                                                type ListPlaybackKeyPairsInput

                                                                                type ListPlaybackKeyPairsInput struct {
                                                                                
                                                                                	// The first key pair to retrieve. This is used for pagination; see the nextToken
                                                                                	// response field.
                                                                                	MaxResults int32
                                                                                
                                                                                	// Maximum number of key pairs to return.
                                                                                	NextToken *string
                                                                                }

                                                                                type ListPlaybackKeyPairsOutput

                                                                                type ListPlaybackKeyPairsOutput struct {
                                                                                
                                                                                	// List of key pairs.
                                                                                	//
                                                                                	// This member is required.
                                                                                	KeyPairs []types.PlaybackKeyPairSummary
                                                                                
                                                                                	// If there are more key pairs than maxResults, use nextToken in the request to get
                                                                                	// the next set.
                                                                                	NextToken *string
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type ListPlaybackKeyPairsPaginator

                                                                                type ListPlaybackKeyPairsPaginator struct {
                                                                                	// contains filtered or unexported fields
                                                                                }

                                                                                  ListPlaybackKeyPairsPaginator is a paginator for ListPlaybackKeyPairs

                                                                                  func NewListPlaybackKeyPairsPaginator

                                                                                    NewListPlaybackKeyPairsPaginator returns a new ListPlaybackKeyPairsPaginator

                                                                                    func (*ListPlaybackKeyPairsPaginator) HasMorePages

                                                                                    func (p *ListPlaybackKeyPairsPaginator) HasMorePages() bool

                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                      func (*ListPlaybackKeyPairsPaginator) NextPage

                                                                                        NextPage retrieves the next ListPlaybackKeyPairs page.

                                                                                        type ListPlaybackKeyPairsPaginatorOptions

                                                                                        type ListPlaybackKeyPairsPaginatorOptions struct {
                                                                                        	// The first key pair to retrieve. This is used for pagination; see the nextToken
                                                                                        	// response field.
                                                                                        	Limit int32
                                                                                        
                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                        	// that matches the most recent token provided to the service.
                                                                                        	StopOnDuplicateToken bool
                                                                                        }

                                                                                          ListPlaybackKeyPairsPaginatorOptions is the paginator options for ListPlaybackKeyPairs

                                                                                          type ListStreamKeysAPIClient

                                                                                          type ListStreamKeysAPIClient interface {
                                                                                          	ListStreamKeys(context.Context, *ListStreamKeysInput, ...func(*Options)) (*ListStreamKeysOutput, error)
                                                                                          }

                                                                                            ListStreamKeysAPIClient is a client that implements the ListStreamKeys operation.

                                                                                            type ListStreamKeysInput

                                                                                            type ListStreamKeysInput struct {
                                                                                            
                                                                                            	// Channel ARN used to filter the list.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	ChannelArn *string
                                                                                            
                                                                                            	// Maximum number of streamKeys to return.
                                                                                            	MaxResults int32
                                                                                            
                                                                                            	// The first stream key to retrieve. This is used for pagination; see the nextToken
                                                                                            	// response field.
                                                                                            	NextToken *string
                                                                                            }

                                                                                            type ListStreamKeysOutput

                                                                                            type ListStreamKeysOutput struct {
                                                                                            
                                                                                            	// List of stream keys.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	StreamKeys []types.StreamKeySummary
                                                                                            
                                                                                            	// If there are more stream keys than maxResults, use nextToken in the request to
                                                                                            	// get the next set.
                                                                                            	NextToken *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type ListStreamKeysPaginator

                                                                                            type ListStreamKeysPaginator struct {
                                                                                            	// contains filtered or unexported fields
                                                                                            }

                                                                                              ListStreamKeysPaginator is a paginator for ListStreamKeys

                                                                                              func NewListStreamKeysPaginator

                                                                                              func NewListStreamKeysPaginator(client ListStreamKeysAPIClient, params *ListStreamKeysInput, optFns ...func(*ListStreamKeysPaginatorOptions)) *ListStreamKeysPaginator

                                                                                                NewListStreamKeysPaginator returns a new ListStreamKeysPaginator

                                                                                                func (*ListStreamKeysPaginator) HasMorePages

                                                                                                func (p *ListStreamKeysPaginator) HasMorePages() bool

                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                  func (*ListStreamKeysPaginator) NextPage

                                                                                                  func (p *ListStreamKeysPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListStreamKeysOutput, error)

                                                                                                    NextPage retrieves the next ListStreamKeys page.

                                                                                                    type ListStreamKeysPaginatorOptions

                                                                                                    type ListStreamKeysPaginatorOptions struct {
                                                                                                    	// Maximum number of streamKeys to return.
                                                                                                    	Limit int32
                                                                                                    
                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                    	StopOnDuplicateToken bool
                                                                                                    }

                                                                                                      ListStreamKeysPaginatorOptions is the paginator options for ListStreamKeys

                                                                                                      type ListStreamsAPIClient

                                                                                                      type ListStreamsAPIClient interface {
                                                                                                      	ListStreams(context.Context, *ListStreamsInput, ...func(*Options)) (*ListStreamsOutput, error)
                                                                                                      }

                                                                                                        ListStreamsAPIClient is a client that implements the ListStreams operation.

                                                                                                        type ListStreamsInput

                                                                                                        type ListStreamsInput struct {
                                                                                                        
                                                                                                        	// Maximum number of streams to return.
                                                                                                        	MaxResults int32
                                                                                                        
                                                                                                        	// The first stream to retrieve. This is used for pagination; see the nextToken
                                                                                                        	// response field.
                                                                                                        	NextToken *string
                                                                                                        }

                                                                                                        type ListStreamsOutput

                                                                                                        type ListStreamsOutput struct {
                                                                                                        
                                                                                                        	// List of streams.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Streams []types.StreamSummary
                                                                                                        
                                                                                                        	// If there are more streams than maxResults, use nextToken in the request to get
                                                                                                        	// the next set.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListStreamsPaginator

                                                                                                        type ListStreamsPaginator struct {
                                                                                                        	// contains filtered or unexported fields
                                                                                                        }

                                                                                                          ListStreamsPaginator is a paginator for ListStreams

                                                                                                          func NewListStreamsPaginator

                                                                                                          func NewListStreamsPaginator(client ListStreamsAPIClient, params *ListStreamsInput, optFns ...func(*ListStreamsPaginatorOptions)) *ListStreamsPaginator

                                                                                                            NewListStreamsPaginator returns a new ListStreamsPaginator

                                                                                                            func (*ListStreamsPaginator) HasMorePages

                                                                                                            func (p *ListStreamsPaginator) HasMorePages() bool

                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                              func (*ListStreamsPaginator) NextPage

                                                                                                              func (p *ListStreamsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListStreamsOutput, error)

                                                                                                                NextPage retrieves the next ListStreams page.

                                                                                                                type ListStreamsPaginatorOptions

                                                                                                                type ListStreamsPaginatorOptions struct {
                                                                                                                	// Maximum number of streams to return.
                                                                                                                	Limit int32
                                                                                                                
                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                	StopOnDuplicateToken bool
                                                                                                                }

                                                                                                                  ListStreamsPaginatorOptions is the paginator options for ListStreams

                                                                                                                  type ListTagsForResourceAPIClient

                                                                                                                  type ListTagsForResourceAPIClient interface {
                                                                                                                  	ListTagsForResource(context.Context, *ListTagsForResourceInput, ...func(*Options)) (*ListTagsForResourceOutput, error)
                                                                                                                  }

                                                                                                                    ListTagsForResourceAPIClient is a client that implements the ListTagsForResource operation.

                                                                                                                    type ListTagsForResourceInput

                                                                                                                    type ListTagsForResourceInput struct {
                                                                                                                    
                                                                                                                    	// The ARN of the resource to be retrieved.
                                                                                                                    	//
                                                                                                                    	// This member is required.
                                                                                                                    	ResourceArn *string
                                                                                                                    
                                                                                                                    	// Maximum number of tags to return.
                                                                                                                    	MaxResults int32
                                                                                                                    
                                                                                                                    	// The first tag to retrieve. This is used for pagination; see the nextToken
                                                                                                                    	// response field.
                                                                                                                    	NextToken *string
                                                                                                                    }

                                                                                                                    type ListTagsForResourceOutput

                                                                                                                    type ListTagsForResourceOutput struct {
                                                                                                                    
                                                                                                                    	// This member is required.
                                                                                                                    	Tags map[string]string
                                                                                                                    
                                                                                                                    	// If there are more tags than maxResults, use nextToken in the request to get the
                                                                                                                    	// next set.
                                                                                                                    	NextToken *string
                                                                                                                    
                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                    }

                                                                                                                    type ListTagsForResourcePaginator

                                                                                                                    type ListTagsForResourcePaginator struct {
                                                                                                                    	// contains filtered or unexported fields
                                                                                                                    }

                                                                                                                      ListTagsForResourcePaginator is a paginator for ListTagsForResource

                                                                                                                      func NewListTagsForResourcePaginator

                                                                                                                      func NewListTagsForResourcePaginator(client ListTagsForResourceAPIClient, params *ListTagsForResourceInput, optFns ...func(*ListTagsForResourcePaginatorOptions)) *ListTagsForResourcePaginator

                                                                                                                        NewListTagsForResourcePaginator returns a new ListTagsForResourcePaginator

                                                                                                                        func (*ListTagsForResourcePaginator) HasMorePages

                                                                                                                        func (p *ListTagsForResourcePaginator) HasMorePages() bool

                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                          func (*ListTagsForResourcePaginator) NextPage

                                                                                                                          func (p *ListTagsForResourcePaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                                                                                            NextPage retrieves the next ListTagsForResource page.

                                                                                                                            type ListTagsForResourcePaginatorOptions

                                                                                                                            type ListTagsForResourcePaginatorOptions struct {
                                                                                                                            	// Maximum number of tags to return.
                                                                                                                            	Limit int32
                                                                                                                            
                                                                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                            	// that matches the most recent token provided to the service.
                                                                                                                            	StopOnDuplicateToken bool
                                                                                                                            }

                                                                                                                              ListTagsForResourcePaginatorOptions is the paginator options for ListTagsForResource

                                                                                                                              type Options

                                                                                                                              type Options struct {
                                                                                                                              	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                              	// operations invoked for this client. Use functional options on operation call to
                                                                                                                              	// modify this list for per operation behavior.
                                                                                                                              	APIOptions []func(*middleware.Stack) error
                                                                                                                              
                                                                                                                              	// Configures the events that will be sent to the configured logger.
                                                                                                                              	ClientLogMode aws.ClientLogMode
                                                                                                                              
                                                                                                                              	// The credentials object to use when signing requests.
                                                                                                                              	Credentials aws.CredentialsProvider
                                                                                                                              
                                                                                                                              	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                              	EndpointOptions EndpointResolverOptions
                                                                                                                              
                                                                                                                              	// The service endpoint resolver.
                                                                                                                              	EndpointResolver EndpointResolver
                                                                                                                              
                                                                                                                              	// Signature Version 4 (SigV4) Signer
                                                                                                                              	HTTPSignerV4 HTTPSignerV4
                                                                                                                              
                                                                                                                              	// The logger writer interface to write logging messages to.
                                                                                                                              	Logger logging.Logger
                                                                                                                              
                                                                                                                              	// The region to send requests to. (Required)
                                                                                                                              	Region string
                                                                                                                              
                                                                                                                              	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                              	// failures. When nil the API client will use a default retryer.
                                                                                                                              	Retryer aws.Retryer
                                                                                                                              
                                                                                                                              	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                              	// implementation if nil.
                                                                                                                              	HTTPClient HTTPClient
                                                                                                                              }

                                                                                                                              func (Options) Copy

                                                                                                                              func (o Options) Copy() Options

                                                                                                                                Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                type PutMetadataInput

                                                                                                                                type PutMetadataInput struct {
                                                                                                                                
                                                                                                                                	// ARN of the channel into which metadata is inserted. This channel must have an
                                                                                                                                	// active stream.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ChannelArn *string
                                                                                                                                
                                                                                                                                	// Metadata to insert into the stream. Maximum: 1 KB per request.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Metadata *string
                                                                                                                                }

                                                                                                                                type PutMetadataOutput

                                                                                                                                type PutMetadataOutput struct {
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type ResolveEndpoint

                                                                                                                                type ResolveEndpoint struct {
                                                                                                                                	Resolver EndpointResolver
                                                                                                                                	Options  EndpointResolverOptions
                                                                                                                                }

                                                                                                                                func (*ResolveEndpoint) HandleSerialize

                                                                                                                                func (*ResolveEndpoint) ID

                                                                                                                                func (*ResolveEndpoint) ID() string

                                                                                                                                type StopStreamInput

                                                                                                                                type StopStreamInput struct {
                                                                                                                                
                                                                                                                                	// ARN of the channel for which the stream is to be stopped.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ChannelArn *string
                                                                                                                                }

                                                                                                                                type StopStreamOutput

                                                                                                                                type StopStreamOutput struct {
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type TagResourceInput

                                                                                                                                type TagResourceInput struct {
                                                                                                                                
                                                                                                                                	// ARN of the resource for which tags are to be added or updated.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ResourceArn *string
                                                                                                                                
                                                                                                                                	// Array of tags to be added or updated.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Tags map[string]string
                                                                                                                                }

                                                                                                                                type TagResourceOutput

                                                                                                                                type TagResourceOutput struct {
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type UntagResourceInput

                                                                                                                                type UntagResourceInput struct {
                                                                                                                                
                                                                                                                                	// ARN of the resource for which tags are to be removed.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	ResourceArn *string
                                                                                                                                
                                                                                                                                	// Array of tags to be removed.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	TagKeys []string
                                                                                                                                }

                                                                                                                                type UntagResourceOutput

                                                                                                                                type UntagResourceOutput struct {
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type UpdateChannelInput

                                                                                                                                type UpdateChannelInput struct {
                                                                                                                                
                                                                                                                                	// ARN of the channel to be updated.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Arn *string
                                                                                                                                
                                                                                                                                	// Whether the channel is authorized. Default: false.
                                                                                                                                	Authorized bool
                                                                                                                                
                                                                                                                                	// Channel latency mode. Default: LOW.
                                                                                                                                	LatencyMode types.ChannelLatencyMode
                                                                                                                                
                                                                                                                                	// Channel name.
                                                                                                                                	Name *string
                                                                                                                                
                                                                                                                                	// Channel type, which determines the allowable resolution and bitrate. If you
                                                                                                                                	// exceed the allowable resolution or bitrate, the stream probably will disconnect
                                                                                                                                	// immediately. Valid values:
                                                                                                                                	//
                                                                                                                                	// * STANDARD: Multiple qualities are generated from
                                                                                                                                	// the original input, to automatically give viewers the best experience for their
                                                                                                                                	// devices and network conditions. Vertical resolution can be up to 1080 and
                                                                                                                                	// bitrate can be up to 8.5 Mbps.
                                                                                                                                	//
                                                                                                                                	// * BASIC: Amazon IVS delivers the original input
                                                                                                                                	// to viewers. The viewer’s video-quality choice is limited to the original input.
                                                                                                                                	// Vertical resolution can be up to 480 and bitrate can be up to 1.5
                                                                                                                                	// Mbps.
                                                                                                                                	//
                                                                                                                                	// Default: STANDARD.
                                                                                                                                	Type types.ChannelType
                                                                                                                                }

                                                                                                                                type UpdateChannelOutput

                                                                                                                                type UpdateChannelOutput struct {
                                                                                                                                
                                                                                                                                	// Object specifying a channel.
                                                                                                                                	Channel *types.Channel
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                Directories

                                                                                                                                Path Synopsis
                                                                                                                                internal