aws-sdk-kinesisvideomedia 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2fe24eaae846525e25174355d1552d60d2dd9f4
+  data.tar.gz: e6746992735607cdfc0e6e17fb641613faa64eea
+SHA512:
+  metadata.gz: 50d62ad19bbc73345d9c0beec96aaccc3105955c5feeff9d3174b74763ea673edca1eebe75851d1fe03e050730332ea049bf893f3f5c0f146effc77368860910
+  data.tar.gz: f3cdce76cd65d98346783d5451d353bb53d584689bee76e1fb2d92a57813d712899c0c05e27a248ef8976855370b2d16d07158481edd75b08626421587a7e00f

data/lib/aws-sdk-kinesisvideomedia.rb

@@ -0,0 +1,47 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+require 'aws-sdk-core'
+require 'aws-sigv4'
+
+require_relative 'aws-sdk-kinesisvideomedia/types'
+require_relative 'aws-sdk-kinesisvideomedia/client_api'
+require_relative 'aws-sdk-kinesisvideomedia/client'
+require_relative 'aws-sdk-kinesisvideomedia/errors'
+require_relative 'aws-sdk-kinesisvideomedia/resource'
+require_relative 'aws-sdk-kinesisvideomedia/customizations'
+
+# This module provides support for Amazon Kinesis Video Streams Media. This module is available in the
+# `aws-sdk-kinesisvideomedia` gem.
+#
+# # Client
+#
+# The {Client} class provides one method for each API operation. Operation
+# methods each accept a hash of request parameters and return a response
+# structure.
+#
+# See {Client} for more information.
+#
+# # Errors
+#
+# Errors returned from Amazon Kinesis Video Streams Media all
+# extend {Errors::ServiceError}.
+#
+#     begin
+#       # do stuff
+#     rescue Aws::KinesisVideoMedia::Errors::ServiceError
+#       # rescues all service API errors
+#     end
+#
+# See {Errors} for more information.
+#
+# @service
+module Aws::KinesisVideoMedia
+
+  GEM_VERSION = '1.0.0'
+
+end

data/lib/aws-sdk-kinesisvideomedia/client.rb

@@ -0,0 +1,251 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+require 'seahorse/client/plugins/content_length.rb'
+require 'aws-sdk-core/plugins/credentials_configuration.rb'
+require 'aws-sdk-core/plugins/logging.rb'
+require 'aws-sdk-core/plugins/param_converter.rb'
+require 'aws-sdk-core/plugins/param_validator.rb'
+require 'aws-sdk-core/plugins/user_agent.rb'
+require 'aws-sdk-core/plugins/helpful_socket_errors.rb'
+require 'aws-sdk-core/plugins/retry_errors.rb'
+require 'aws-sdk-core/plugins/global_configuration.rb'
+require 'aws-sdk-core/plugins/regional_endpoint.rb'
+require 'aws-sdk-core/plugins/response_paging.rb'
+require 'aws-sdk-core/plugins/stub_responses.rb'
+require 'aws-sdk-core/plugins/idempotency_token.rb'
+require 'aws-sdk-core/plugins/jsonvalue_converter.rb'
+require 'aws-sdk-core/plugins/signature_v4.rb'
+require 'aws-sdk-core/plugins/protocols/rest_json.rb'
+
+Aws::Plugins::GlobalConfiguration.add_identifier(:kinesisvideomedia)
+
+module Aws::KinesisVideoMedia
+  class Client < Seahorse::Client::Base
+
+    include Aws::ClientStubs
+
+    @identifier = :kinesisvideomedia
+
+    set_api(ClientApi::API)
+
+    add_plugin(Seahorse::Client::Plugins::ContentLength)
+    add_plugin(Aws::Plugins::CredentialsConfiguration)
+    add_plugin(Aws::Plugins::Logging)
+    add_plugin(Aws::Plugins::ParamConverter)
+    add_plugin(Aws::Plugins::ParamValidator)
+    add_plugin(Aws::Plugins::UserAgent)
+    add_plugin(Aws::Plugins::HelpfulSocketErrors)
+    add_plugin(Aws::Plugins::RetryErrors)
+    add_plugin(Aws::Plugins::GlobalConfiguration)
+    add_plugin(Aws::Plugins::RegionalEndpoint)
+    add_plugin(Aws::Plugins::ResponsePaging)
+    add_plugin(Aws::Plugins::StubResponses)
+    add_plugin(Aws::Plugins::IdempotencyToken)
+    add_plugin(Aws::Plugins::JsonvalueConverter)
+    add_plugin(Aws::Plugins::SignatureV4)
+    add_plugin(Aws::Plugins::Protocols::RestJson)
+
+    # @option options [required, Aws::CredentialProvider] :credentials
+    #   Your AWS credentials. This can be an instance of any one of the
+    #   following classes:
+    #
+    #   * `Aws::Credentials` - Used for configuring static, non-refreshing
+    #     credentials.
+    #
+    #   * `Aws::InstanceProfileCredentials` - Used for loading credentials
+    #     from an EC2 IMDS on an EC2 instance.
+    #
+    #   * `Aws::SharedCredentials` - Used for loading credentials from a
+    #     shared file, such as `~/.aws/config`.
+    #
+    #   * `Aws::AssumeRoleCredentials` - Used when you need to assume a role.
+    #
+    #   When `:credentials` are not configured directly, the following
+    #   locations will be searched for credentials:
+    #
+    #   * `Aws.config[:credentials]`
+    #   * The `:access_key_id`, `:secret_access_key`, and `:session_token` options.
+    #   * ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
+    #   * `~/.aws/credentials`
+    #   * `~/.aws/config`
+    #   * EC2 IMDS instance profile - When used by default, the timeouts are
+    #     very aggressive. Construct and pass an instance of
+    #     `Aws::InstanceProfileCredentails` to enable retries and extended
+    #     timeouts.
+    #
+    # @option options [required, String] :region
+    #   The AWS region to connect to.  The configured `:region` is
+    #   used to determine the service `:endpoint`. When not passed,
+    #   a default `:region` is search for in the following locations:
+    #
+    #   * `Aws.config[:region]`
+    #   * `ENV['AWS_REGION']`
+    #   * `ENV['AMAZON_REGION']`
+    #   * `ENV['AWS_DEFAULT_REGION']`
+    #   * `~/.aws/credentials`
+    #   * `~/.aws/config`
+    #
+    # @option options [String] :access_key_id
+    #
+    # @option options [Boolean] :convert_params (true)
+    #   When `true`, an attempt is made to coerce request parameters into
+    #   the required types.
+    #
+    # @option options [String] :endpoint
+    #   The client endpoint is normally constructed from the `:region`
+    #   option. You should only configure an `:endpoint` when connecting
+    #   to test endpoints. This should be avalid HTTP(S) URI.
+    #
+    # @option options [Aws::Log::Formatter] :log_formatter (Aws::Log::Formatter.default)
+    #   The log formatter.
+    #
+    # @option options [Symbol] :log_level (:info)
+    #   The log level to send messages to the `:logger` at.
+    #
+    # @option options [Logger] :logger
+    #   The Logger instance to send log messages to.  If this option
+    #   is not set, logging will be disabled.
+    #
+    # @option options [String] :profile ("default")
+    #   Used when loading credentials from the shared credentials file
+    #   at HOME/.aws/credentials.  When not specified, 'default' is used.
+    #
+    # @option options [Integer] :retry_limit (3)
+    #   The maximum number of times to retry failed requests.  Only
+    #   ~ 500 level server errors and certain ~ 400 level client errors
+    #   are retried.  Generally, these are throttling errors, data
+    #   checksum errors, networking errors, timeout errors and auth
+    #   errors from expired credentials.
+    #
+    # @option options [String] :secret_access_key
+    #
+    # @option options [String] :session_token
+    #
+    # @option options [Boolean] :stub_responses (false)
+    #   Causes the client to return stubbed responses. By default
+    #   fake responses are generated and returned. You can specify
+    #   the response data to return or errors to raise by calling
+    #   {ClientStubs#stub_responses}. See {ClientStubs} for more information.
+    #
+    #   ** Please note ** When response stubbing is enabled, no HTTP
+    #   requests are made, and retries are disabled.
+    #
+    # @option options [Boolean] :validate_params (true)
+    #   When `true`, request parameters are validated before
+    #   sending the request.
+    #
+    def initialize(*args)
+      super
+    end
+
+    # @!group API Operations
+
+    # Use this API to retrieve media content from a Kinesis video stream. In
+    # the request, you identify stream name or stream Amazon Resource Name
+    # (ARN), and the starting chunk. Kinesis Video Streams then returns a
+    # stream of chunks in order by fragment number.
+    #
+    # <note markdown="1"> You must first call the `GetDataEndpoint` API to get an endpoint to
+    # which you can then send the `GetMedia` requests.
+    #
+    #  </note>
+    #
+    # When you put media data (fragments) on a stream, Kinesis Video Streams
+    # stores each incoming fragment and related metadata in what is called a
+    # "chunk." For more information, see . The `GetMedia` API returns a
+    # stream of these chunks starting from the chunk that you specify in the
+    # request.
+    #
+    # The following limits apply when using the `GetMedia` API:
+    #
+    # * A client can call `GetMedia` up to five times per second per stream.
+    #
+    # * Kinesis Video Streams sends media data at a rate of up to 25
+    #   megabytes per second (or 200 megabits per second) during a
+    #   `GetMedia` session.
+    #
+    # @option params [String] :stream_name
+    #   The Kinesis video stream name from where you want to get the media
+    #   content. If you don't specify the `streamName`, you must specify the
+    #   `streamARN`.
+    #
+    # @option params [String] :stream_arn
+    #   The ARN of the stream from where you want to get the media content. If
+    #   you don't specify the `streamARN`, you must specify the `streamName`.
+    #
+    # @option params [required, Types::StartSelector] :start_selector
+    #   Identifies the starting chunk to get from the specified stream.
+    #
+    # @return [Types::GetMediaOutput] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
+    #
+    #   * {Types::GetMediaOutput#content_type #content_type} => String
+    #   * {Types::GetMediaOutput#payload #payload} => IO
+    #
+    # @example Request syntax with placeholder values
+    #
+    #   resp = client.get_media({
+    #     stream_name: "StreamName",
+    #     stream_arn: "ResourceARN",
+    #     start_selector: { # required
+    #       start_selector_type: "FRAGMENT_NUMBER", # required, accepts FRAGMENT_NUMBER, SERVER_TIMESTAMP, PRODUCER_TIMESTAMP, NOW, EARLIEST, CONTINUATION_TOKEN
+    #       after_fragment_number: "FragmentNumberString",
+    #       start_timestamp: Time.now,
+    #       continuation_token: "ContinuationToken",
+    #     },
+    #   })
+    #
+    # @example Response structure
+    #
+    #   resp.content_type #=> String
+    #   resp.payload #=> IO
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-media-2017-09-30/GetMedia AWS API Documentation
+    #
+    # @overload get_media(params = {})
+    # @param [Hash] params ({})
+    def get_media(params = {}, options = {}, &block)
+      req = build_request(:get_media, params)
+      req.send_request(options, &block)
+    end
+
+    # @!endgroup
+
+    # @param params ({})
+    # @api private
+    def build_request(operation_name, params = {})
+      handlers = @handlers.for(operation_name)
+      context = Seahorse::Client::RequestContext.new(
+        operation_name: operation_name,
+        operation: config.api.operation(operation_name),
+        client: self,
+        params: params,
+        config: config)
+      context[:gem_name] = 'aws-sdk-kinesisvideomedia'
+      context[:gem_version] = '1.0.0'
+      Seahorse::Client::Request.new(handlers, context)
+    end
+
+    # @api private
+    # @deprecated
+    def waiter_names
+      []
+    end
+
+    class << self
+
+      # @api private
+      attr_reader :identifier
+
+      # @api private
+      def errors_module
+        Errors
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-kinesisvideomedia/client_api.rb

@@ -0,0 +1,79 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::KinesisVideoMedia
+  # @api private
+  module ClientApi
+
+    include Seahorse::Model
+
+    ClientLimitExceededException = Shapes::StructureShape.new(name: 'ClientLimitExceededException')
+    ConnectionLimitExceededException = Shapes::StructureShape.new(name: 'ConnectionLimitExceededException')
+    ContentType = Shapes::StringShape.new(name: 'ContentType')
+    ContinuationToken = Shapes::StringShape.new(name: 'ContinuationToken')
+    ErrorMessage = Shapes::StringShape.new(name: 'ErrorMessage')
+    FragmentNumberString = Shapes::StringShape.new(name: 'FragmentNumberString')
+    GetMediaInput = Shapes::StructureShape.new(name: 'GetMediaInput')
+    GetMediaOutput = Shapes::StructureShape.new(name: 'GetMediaOutput')
+    InvalidArgumentException = Shapes::StructureShape.new(name: 'InvalidArgumentException')
+    InvalidEndpointException = Shapes::StructureShape.new(name: 'InvalidEndpointException')
+    NotAuthorizedException = Shapes::StructureShape.new(name: 'NotAuthorizedException')
+    Payload = Shapes::BlobShape.new(name: 'Payload')
+    ResourceARN = Shapes::StringShape.new(name: 'ResourceARN')
+    ResourceNotFoundException = Shapes::StructureShape.new(name: 'ResourceNotFoundException')
+    StartSelector = Shapes::StructureShape.new(name: 'StartSelector')
+    StartSelectorType = Shapes::StringShape.new(name: 'StartSelectorType')
+    StreamName = Shapes::StringShape.new(name: 'StreamName')
+    Timestamp = Shapes::TimestampShape.new(name: 'Timestamp')
+
+    GetMediaInput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, location_name: "StreamName"))
+    GetMediaInput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: ResourceARN, location_name: "StreamARN"))
+    GetMediaInput.add_member(:start_selector, Shapes::ShapeRef.new(shape: StartSelector, required: true, location_name: "StartSelector"))
+    GetMediaInput.struct_class = Types::GetMediaInput
+
+    GetMediaOutput.add_member(:content_type, Shapes::ShapeRef.new(shape: ContentType, location: "header", location_name: "Content-Type"))
+    GetMediaOutput.add_member(:payload, Shapes::ShapeRef.new(shape: Payload, location_name: "Payload"))
+    GetMediaOutput.struct_class = Types::GetMediaOutput
+    GetMediaOutput[:payload] = :payload
+    GetMediaOutput[:payload_member] = GetMediaOutput.member(:payload)
+
+    StartSelector.add_member(:start_selector_type, Shapes::ShapeRef.new(shape: StartSelectorType, required: true, location_name: "StartSelectorType"))
+    StartSelector.add_member(:after_fragment_number, Shapes::ShapeRef.new(shape: FragmentNumberString, location_name: "AfterFragmentNumber"))
+    StartSelector.add_member(:start_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "StartTimestamp"))
+    StartSelector.add_member(:continuation_token, Shapes::ShapeRef.new(shape: ContinuationToken, location_name: "ContinuationToken"))
+    StartSelector.struct_class = Types::StartSelector
+
+
+    # @api private
+    API = Seahorse::Model::Api.new.tap do |api|
+
+      api.version = "2017-09-30"
+
+      api.metadata = {
+        "endpointPrefix" => "kinesisvideo",
+        "protocol" => "rest-json",
+        "serviceFullName" => "Amazon Kinesis Video Streams Media",
+        "signatureVersion" => "v4",
+      }
+
+      api.add_operation(:get_media, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "GetMedia"
+        o.http_method = "POST"
+        o.http_request_uri = "/getMedia"
+        o.input = Shapes::ShapeRef.new(shape: GetMediaInput)
+        o.output = Shapes::ShapeRef.new(shape: GetMediaOutput)
+        o.errors << Shapes::ShapeRef.new(shape: ResourceNotFoundException)
+        o.errors << Shapes::ShapeRef.new(shape: NotAuthorizedException)
+        o.errors << Shapes::ShapeRef.new(shape: InvalidEndpointException)
+        o.errors << Shapes::ShapeRef.new(shape: ClientLimitExceededException)
+        o.errors << Shapes::ShapeRef.new(shape: ConnectionLimitExceededException)
+        o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
+      end)
+    end
+
+  end
+end

data/lib/aws-sdk-kinesisvideomedia/errors.rb

@@ -0,0 +1,14 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::KinesisVideoMedia
+  module Errors
+
+    extend Aws::Errors::DynamicErrors
+
+  end
+end

data/lib/aws-sdk-kinesisvideomedia/resource.rb

@@ -0,0 +1,23 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::KinesisVideoMedia
+  class Resource
+
+    # @param options ({})
+    # @option options [Client] :client
+    def initialize(options = {})
+      @client = options[:client] || Client.new(options)
+    end
+
+    # @return [Client]
+    def client
+      @client
+    end
+
+  end
+end

data/lib/aws-sdk-kinesisvideomedia/types.rb

@@ -0,0 +1,195 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::KinesisVideoMedia
+  module Types
+
+    # @note When making an API call, you may pass GetMediaInput
+    #   data as a hash:
+    #
+    #       {
+    #         stream_name: "StreamName",
+    #         stream_arn: "ResourceARN",
+    #         start_selector: { # required
+    #           start_selector_type: "FRAGMENT_NUMBER", # required, accepts FRAGMENT_NUMBER, SERVER_TIMESTAMP, PRODUCER_TIMESTAMP, NOW, EARLIEST, CONTINUATION_TOKEN
+    #           after_fragment_number: "FragmentNumberString",
+    #           start_timestamp: Time.now,
+    #           continuation_token: "ContinuationToken",
+    #         },
+    #       }
+    #
+    # @!attribute [rw] stream_name
+    #   The Kinesis video stream name from where you want to get the media
+    #   content. If you don't specify the `streamName`, you must specify
+    #   the `streamARN`.
+    #   @return [String]
+    #
+    # @!attribute [rw] stream_arn
+    #   The ARN of the stream from where you want to get the media content.
+    #   If you don't specify the `streamARN`, you must specify the
+    #   `streamName`.
+    #   @return [String]
+    #
+    # @!attribute [rw] start_selector
+    #   Identifies the starting chunk to get from the specified stream.
+    #   @return [Types::StartSelector]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-media-2017-09-30/GetMediaInput AWS API Documentation
+    #
+    class GetMediaInput < Struct.new(
+      :stream_name,
+      :stream_arn,
+      :start_selector)
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] content_type
+    #   The content type of the requested media.
+    #   @return [String]
+    #
+    # @!attribute [rw] payload
+    #   The payload Kinesis Video Streams returns is a sequence of chunks
+    #   from the specified stream. For information about the chunks, see .
+    #   The chunks that Kinesis Video Streams returns in the `GetMedia` call
+    #   also include the following additional Matroska (MKV) tags:
+    #
+    #   * AWS\_KINESISVIDEO\_CONTINUATION\_TOKEN (UTF-8 string) - In the
+    #     event your `GetMedia` call terminates, you can use this
+    #     continuation token in your next request to get the next chunk
+    #     where the last request terminated.
+    #
+    #   * AWS\_KINESISVIDEO\_MILLIS\_BEHIND\_NOW (UTF-8 string) - Client
+    #     applications can use this tag value to determine how far behind
+    #     the chunk returned in the response is from the latest chunk on the
+    #     stream.
+    #
+    #   * AWS\_KINESISVIDEO\_FRAGMENT\_NUMBER - Fragment number returned in
+    #     the chunk.
+    #
+    #   * AWS\_KINESISVIDEO\_SERVER\_TIMESTAMP - Server time stamp of the
+    #     fragment.
+    #
+    #   * AWS\_KINESISVIDEO\_PRODUCER\_TIMESTAMP - Producer time stamp of
+    #     the fragment.
+    #
+    #   The following tags will be present if an error occurs:
+    #
+    #   * AWS\_KINESISVIDEO\_ERROR\_CODE - String description of an error
+    #     that caused GetMedia to stop.
+    #
+    #   * AWS\_KINESISVIDEO\_ERROR\_ID: Integer code of the error.
+    #
+    #   The error codes are as follows:
+    #
+    #   * 3002 - Error writing to the stream
+    #
+    #   * 4000 - Requested fragment is not found
+    #
+    #   * 4500 - Access denied for the stream's KMS key
+    #
+    #   * 4501 - Stream's KMS key is disabled
+    #
+    #   * 4502 - Validation error on the Stream's KMS key
+    #
+    #   * 4503 - KMS key specified in the stream is unavailable
+    #
+    #   * 4504 - Invalid usage of the KMS key specified in the stream
+    #
+    #   * 4505 - Invalid state of the KMS key specified in the stream
+    #
+    #   * 4506 - Unable to find the KMS key specified in the stream
+    #
+    #   * 5000 - Internal error
+    #   @return [IO]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-media-2017-09-30/GetMediaOutput AWS API Documentation
+    #
+    class GetMediaOutput < Struct.new(
+      :content_type,
+      :payload)
+      include Aws::Structure
+    end
+
+    # 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 time stamp (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.
+    #
+    # @note When making an API call, you may pass StartSelector
+    #   data as a hash:
+    #
+    #       {
+    #         start_selector_type: "FRAGMENT_NUMBER", # required, accepts FRAGMENT_NUMBER, SERVER_TIMESTAMP, PRODUCER_TIMESTAMP, NOW, EARLIEST, CONTINUATION_TOKEN
+    #         after_fragment_number: "FragmentNumberString",
+    #         start_timestamp: Time.now,
+    #         continuation_token: "ContinuationToken",
+    #       }
+    #
+    # @!attribute [rw] start_selector_type
+    #   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 containing the specific
+    #     fragment. You must also specify the `StartFragmentNumber`.
+    #
+    #   * PRODUCER\_TIMESTAMP or SERVER\_TIMESTAMP - Start with the chunk
+    #     containing a fragment with the specified producer or server time
+    #     stamp. You specify the time stamp by adding `StartTimestamp`.
+    #
+    #   * CONTINUATION\_TOKEN - Read using the specified continuation token.
+    #
+    #   <note markdown="1"> If you choose the NOW, EARLIEST, or CONTINUATION\_TOKEN as the
+    #   `startSelectorType`, you don't provide any additional information
+    #   in the `startSelector`.
+    #
+    #    </note>
+    #   @return [String]
+    #
+    # @!attribute [rw] after_fragment_number
+    #   Specifies the fragment number from where you want the `GetMedia` API
+    #   to start returning the fragments.
+    #   @return [String]
+    #
+    # @!attribute [rw] start_timestamp
+    #   A time stamp 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 time stamp.
+    #   @return [Time]
+    #
+    # @!attribute [rw] continuation_token
+    #   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.
+    #   @return [String]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-media-2017-09-30/StartSelector AWS API Documentation
+    #
+    class StartSelector < Struct.new(
+      :start_selector_type,
+      :after_fragment_number,
+      :start_timestamp,
+      :continuation_token)
+      include Aws::Structure
+    end
+
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: aws-sdk-kinesisvideomedia
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Amazon Web Services
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: aws-sigv4
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Official AWS Ruby gem for Amazon Kinesis Video Streams Media (Kinesis
+  Video Media). This gem is part of the AWS SDK for Ruby.
+email:
+- trevrowe@amazon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/aws-sdk-kinesisvideomedia.rb
+- lib/aws-sdk-kinesisvideomedia/client.rb
+- lib/aws-sdk-kinesisvideomedia/client_api.rb
+- lib/aws-sdk-kinesisvideomedia/customizations.rb
+- lib/aws-sdk-kinesisvideomedia/errors.rb
+- lib/aws-sdk-kinesisvideomedia/resource.rb
+- lib/aws-sdk-kinesisvideomedia/types.rb
+homepage: http://github.com/aws/aws-sdk-ruby
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://github.com/aws/aws-sdk-ruby/tree/master/gems/aws-sdk-kinesisvideomedia
+  changelog_uri: https://github.com/aws/aws-sdk-ruby/tree/master/gems/aws-sdk-kinesisvideomedia/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: AWS SDK for Ruby - Kinesis Video Media
+test_files: []