Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ClientLimitExceededException

type ClientLimitExceededException struct {
	Message *string
}

    Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client calls. Try making the call later.

    func (*ClientLimitExceededException) Error

    func (*ClientLimitExceededException) ErrorCode

    func (e *ClientLimitExceededException) ErrorCode() string

    func (*ClientLimitExceededException) ErrorFault

    func (*ClientLimitExceededException) ErrorMessage

    func (e *ClientLimitExceededException) ErrorMessage() string

    type ConnectionLimitExceededException

    type ConnectionLimitExceededException struct {
    	Message *string
    }

      Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client connections.

      func (*ConnectionLimitExceededException) Error

      func (*ConnectionLimitExceededException) ErrorCode

      func (*ConnectionLimitExceededException) ErrorFault

      func (*ConnectionLimitExceededException) ErrorMessage

      func (e *ConnectionLimitExceededException) ErrorMessage() string

      type InvalidArgumentException

      type InvalidArgumentException struct {
      	Message *string
      }

        The value for this input parameter is invalid.

        func (*InvalidArgumentException) Error

        func (e *InvalidArgumentException) Error() string

        func (*InvalidArgumentException) ErrorCode

        func (e *InvalidArgumentException) ErrorCode() string

        func (*InvalidArgumentException) ErrorFault

        func (e *InvalidArgumentException) ErrorFault() smithy.ErrorFault

        func (*InvalidArgumentException) ErrorMessage

        func (e *InvalidArgumentException) ErrorMessage() string

        type InvalidEndpointException

        type InvalidEndpointException struct {
        	Message *string
        }

          Status Code: 400, Caller used wrong endpoint to write data to a stream. On receiving such an exception, the user must call GetDataEndpoint with AccessMode set to "READ" and use the endpoint Kinesis Video returns in the next GetMedia call.

          func (*InvalidEndpointException) Error

          func (e *InvalidEndpointException) Error() string

          func (*InvalidEndpointException) ErrorCode

          func (e *InvalidEndpointException) ErrorCode() string

          func (*InvalidEndpointException) ErrorFault

          func (e *InvalidEndpointException) ErrorFault() smithy.ErrorFault

          func (*InvalidEndpointException) ErrorMessage

          func (e *InvalidEndpointException) ErrorMessage() string

          type NotAuthorizedException

          type NotAuthorizedException struct {
          	Message *string
          }

            Status Code: 403, The caller is not authorized to perform an operation on the given stream, or the token has expired.

            func (*NotAuthorizedException) Error

            func (e *NotAuthorizedException) Error() string

            func (*NotAuthorizedException) ErrorCode

            func (e *NotAuthorizedException) ErrorCode() string

            func (*NotAuthorizedException) ErrorFault

            func (e *NotAuthorizedException) ErrorFault() smithy.ErrorFault

            func (*NotAuthorizedException) ErrorMessage

            func (e *NotAuthorizedException) ErrorMessage() string

            type ResourceNotFoundException

            type ResourceNotFoundException struct {
            	Message *string
            }

              Status Code: 404, The stream with the given name does not exist.

              func (*ResourceNotFoundException) Error

              func (e *ResourceNotFoundException) Error() string

              func (*ResourceNotFoundException) ErrorCode

              func (e *ResourceNotFoundException) ErrorCode() string

              func (*ResourceNotFoundException) ErrorFault

              func (*ResourceNotFoundException) ErrorMessage

              func (e *ResourceNotFoundException) ErrorMessage() string

              type StartSelector

              type StartSelector struct {
              
              	// Identifies the fragment on the Kinesis video stream where you want to start
              	// getting the data from.
              	//
              	// * NOW - Start with the latest chunk on the stream.
              	//
              	// *
              	// EARLIEST - Start with earliest available chunk on the stream.
              	//
              	// * FRAGMENT_NUMBER
              	// - Start with the chunk after a specific fragment. You must also specify the
              	// AfterFragmentNumber parameter.
              	//
              	// * PRODUCER_TIMESTAMP or SERVER_TIMESTAMP - Start
              	// with the chunk containing a fragment with the specified producer or server
              	// timestamp. You specify the timestamp by adding StartTimestamp.
              	//
              	// *
              	// CONTINUATION_TOKEN - Read using the specified continuation token.
              	//
              	// If you choose
              	// the NOW, EARLIEST, or CONTINUATION_TOKEN as the startSelectorType, you don't
              	// provide any additional information in the startSelector.
              	//
              	// This member is required.
              	StartSelectorType StartSelectorType
              
              	// Specifies the fragment number from where you want the GetMedia API to start
              	// returning the fragments.
              	AfterFragmentNumber *string
              
              	// Continuation token that Kinesis Video Streams returned in the previous GetMedia
              	// response. The GetMedia API then starts with the chunk identified by the
              	// continuation token.
              	ContinuationToken *string
              
              	// A timestamp value. This value is required if you choose the PRODUCER_TIMESTAMP
              	// or the SERVER_TIMESTAMP as the startSelectorType. The GetMedia API then starts
              	// with the chunk containing the fragment that has the specified timestamp.
              	StartTimestamp *time.Time
              }

                Identifies the chunk on the Kinesis video stream where you want the GetMedia API to start returning media data. You have the following options to identify the starting chunk:

                * Choose the latest (or oldest) chunk.

                * Identify a specific chunk. You can identify a specific chunk either by providing a fragment number or timestamp (server or producer).

                * Each chunk's metadata includes a continuation token as a Matroska (MKV) tag (AWS_KINESISVIDEO_CONTINUATION_TOKEN). If your previous GetMedia request terminated, you can use this tag value in your next GetMedia request. The API then starts returning chunks starting where the last API ended.

                type StartSelectorType

                type StartSelectorType string
                const (
                	StartSelectorTypeFragmentNumber    StartSelectorType = "FRAGMENT_NUMBER"
                	StartSelectorTypeServerTimestamp   StartSelectorType = "SERVER_TIMESTAMP"
                	StartSelectorTypeProducerTimestamp StartSelectorType = "PRODUCER_TIMESTAMP"
                	StartSelectorTypeNow               StartSelectorType = "NOW"
                	StartSelectorTypeEarliest          StartSelectorType = "EARLIEST"
                	StartSelectorTypeContinuationToken StartSelectorType = "CONTINUATION_TOKEN"
                )

                  Enum values for StartSelectorType

                  func (StartSelectorType) Values

                    Values returns all known values for StartSelectorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.