aws-sdk-kinesis 1.38.0 → 1.52.0

data/lib/aws-sdk-kinesis/endpoint_provider.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::Kinesis
+  class EndpointProvider
+    def resolve_endpoint(parameters)
+      region = parameters.region
+      use_dual_stack = parameters.use_dual_stack
+      use_fips = parameters.use_fips
+      endpoint = parameters.endpoint
+      stream_arn = parameters.stream_arn
+      operation_type = parameters.operation_type
+      consumer_arn = parameters.consumer_arn
+      if Aws::Endpoints::Matchers.set?(stream_arn) && Aws::Endpoints::Matchers.not(Aws::Endpoints::Matchers.set?(endpoint)) && Aws::Endpoints::Matchers.set?(region) && (partition_result = Aws::Endpoints::Matchers.aws_partition(region)) && Aws::Endpoints::Matchers.not(Aws::Endpoints::Matchers.string_equals?(Aws::Endpoints::Matchers.attr(partition_result, "name"), "aws-iso")) && Aws::Endpoints::Matchers.not(Aws::Endpoints::Matchers.string_equals?(Aws::Endpoints::Matchers.attr(partition_result, "name"), "aws-iso-b"))
+        if (arn = Aws::Endpoints::Matchers.aws_parse_arn(stream_arn))
+          if Aws::Endpoints::Matchers.valid_host_label?(Aws::Endpoints::Matchers.attr(arn, "accountId"), false)
+            if Aws::Endpoints::Matchers.valid_host_label?(Aws::Endpoints::Matchers.attr(arn, "region"), false)
+              if Aws::Endpoints::Matchers.string_equals?(Aws::Endpoints::Matchers.attr(arn, "service"), "kinesis")
+                if (arn_type = Aws::Endpoints::Matchers.attr(arn, "resourceId[0]")) && Aws::Endpoints::Matchers.not(Aws::Endpoints::Matchers.string_equals?(arn_type, ""))
+                  if Aws::Endpoints::Matchers.string_equals?(arn_type, "stream")
+                    if Aws::Endpoints::Matchers.string_equals?(Aws::Endpoints::Matchers.attr(partition_result, "name"), "#{arn['partition']}")
+                      if Aws::Endpoints::Matchers.set?(operation_type)
+                        if Aws::Endpoints::Matchers.boolean_equals?(use_fips, true) && Aws::Endpoints::Matchers.boolean_equals?(use_dual_stack, true)
+                          if Aws::Endpoints::Matchers.boolean_equals?(Aws::Endpoints::Matchers.attr(partition_result, "supportsFIPS"), true)
+                            if Aws::Endpoints::Matchers.boolean_equals?(Aws::Endpoints::Matchers.attr(partition_result, "supportsDualStack"), true)
+                              return Aws::Endpoints::Endpoint.new(url: "https://#{arn['accountId']}.#{operation_type}-kinesis-fips.#{region}.#{partition_result['dualStackDnsSuffix']}", headers: {}, properties: {})
+                            end
+                            raise ArgumentError, "DualStack is enabled, but this partition does not support DualStack."
+                          end
+                          raise ArgumentError, "FIPS is enabled, but this partition does not support FIPS."
+                        end
+                        if Aws::Endpoints::Matchers.boolean_equals?(use_fips, true)
+                          if Aws::Endpoints::Matchers.boolean_equals?(Aws::Endpoints::Matchers.attr(partition_result, "supportsFIPS"), true)
+                            return Aws::Endpoints::Endpoint.new(url: "https://#{arn['accountId']}.#{operation_type}-kinesis-fips.#{region}.#{partition_result['dnsSuffix']}", headers: {}, properties: {})
+                          end
+                          raise ArgumentError, "FIPS is enabled but this partition does not support FIPS"
+                        end
+                        if Aws::Endpoints::Matchers.boolean_equals?(use_dual_stack, true)
+                          if Aws::Endpoints::Matchers.boolean_equals?(Aws::Endpoints::Matchers.attr(partition_result, "supportsDualStack"), true)
+                            return Aws::Endpoints::Endpoint.new(url: "https://#{arn['accountId']}.#{operation_type}-kinesis.#{region}.#{partition_result['dualStackDnsSuffix']}", headers: {}, properties: {})
+                          end
+                          raise ArgumentError, "DualStack is enabled but this partition does not support DualStack"
+                        end
+                        return Aws::Endpoints::Endpoint.new(url: "https://#{arn['accountId']}.#{operation_type}-kinesis.#{region}.#{partition_result['dnsSuffix']}", headers: {}, properties: {})
+                      end
+                      raise ArgumentError, "Operation Type is not set. Please contact service team for resolution."
+                    end
+                    raise ArgumentError, "Partition: #{arn['partition']} from ARN doesn't match with partition name: #{partition_result['name']}."
+                  end
+                  raise ArgumentError, "Invalid ARN: Kinesis ARNs don't support `#{arn_type}` arn types."
+                end
+                raise ArgumentError, "Invalid ARN: No ARN type specified"
+              end
+              raise ArgumentError, "Invalid ARN: The ARN was not for the Kinesis service, found: #{arn['service']}."
+            end
+            raise ArgumentError, "Invalid ARN: Invalid region."
+          end
+          raise ArgumentError, "Invalid ARN: Invalid account id."
+        end
+        raise ArgumentError, "Invalid ARN: Failed to parse ARN."
+      end
+      if Aws::Endpoints::Matchers.set?(consumer_arn) && Aws::Endpoints::Matchers.not(Aws::Endpoints::Matchers.set?(endpoint)) && Aws::Endpoints::Matchers.set?(region) && (partition_result = Aws::Endpoints::Matchers.aws_partition(region)) && Aws::Endpoints::Matchers.not(Aws::Endpoints::Matchers.string_equals?(Aws::Endpoints::Matchers.attr(partition_result, "name"), "aws-iso")) && Aws::Endpoints::Matchers.not(Aws::Endpoints::Matchers.string_equals?(Aws::Endpoints::Matchers.attr(partition_result, "name"), "aws-iso-b"))
+        if (arn = Aws::Endpoints::Matchers.aws_parse_arn(consumer_arn))
+          if Aws::Endpoints::Matchers.valid_host_label?(Aws::Endpoints::Matchers.attr(arn, "accountId"), false)
+            if Aws::Endpoints::Matchers.valid_host_label?(Aws::Endpoints::Matchers.attr(arn, "region"), false)
+              if Aws::Endpoints::Matchers.string_equals?(Aws::Endpoints::Matchers.attr(arn, "service"), "kinesis")
+                if (arn_type = Aws::Endpoints::Matchers.attr(arn, "resourceId[0]")) && Aws::Endpoints::Matchers.not(Aws::Endpoints::Matchers.string_equals?(arn_type, ""))
+                  if Aws::Endpoints::Matchers.string_equals?(arn_type, "stream")
+                    if Aws::Endpoints::Matchers.string_equals?(Aws::Endpoints::Matchers.attr(partition_result, "name"), "#{arn['partition']}")
+                      if Aws::Endpoints::Matchers.set?(operation_type)
+                        if Aws::Endpoints::Matchers.boolean_equals?(use_fips, true) && Aws::Endpoints::Matchers.boolean_equals?(use_dual_stack, true)
+                          if Aws::Endpoints::Matchers.boolean_equals?(Aws::Endpoints::Matchers.attr(partition_result, "supportsFIPS"), true)
+                            if Aws::Endpoints::Matchers.boolean_equals?(Aws::Endpoints::Matchers.attr(partition_result, "supportsDualStack"), true)
+                              return Aws::Endpoints::Endpoint.new(url: "https://#{arn['accountId']}.#{operation_type}-kinesis-fips.#{region}.#{partition_result['dualStackDnsSuffix']}", headers: {}, properties: {})
+                            end
+                            raise ArgumentError, "DualStack is enabled, but this partition does not support DualStack."
+                          end
+                          raise ArgumentError, "FIPS is enabled, but this partition does not support FIPS."
+                        end
+                        if Aws::Endpoints::Matchers.boolean_equals?(use_fips, true)
+                          if Aws::Endpoints::Matchers.boolean_equals?(Aws::Endpoints::Matchers.attr(partition_result, "supportsFIPS"), true)
+                            return Aws::Endpoints::Endpoint.new(url: "https://#{arn['accountId']}.#{operation_type}-kinesis-fips.#{region}.#{partition_result['dnsSuffix']}", headers: {}, properties: {})
+                          end
+                          raise ArgumentError, "FIPS is enabled but this partition does not support FIPS"
+                        end
+                        if Aws::Endpoints::Matchers.boolean_equals?(use_dual_stack, true)
+                          if Aws::Endpoints::Matchers.boolean_equals?(Aws::Endpoints::Matchers.attr(partition_result, "supportsDualStack"), true)
+                            return Aws::Endpoints::Endpoint.new(url: "https://#{arn['accountId']}.#{operation_type}-kinesis.#{region}.#{partition_result['dualStackDnsSuffix']}", headers: {}, properties: {})
+                          end
+                          raise ArgumentError, "DualStack is enabled but this partition does not support DualStack"
+                        end
+                        return Aws::Endpoints::Endpoint.new(url: "https://#{arn['accountId']}.#{operation_type}-kinesis.#{region}.#{partition_result['dnsSuffix']}", headers: {}, properties: {})
+                      end
+                      raise ArgumentError, "Operation Type is not set. Please contact service team for resolution."
+                    end
+                    raise ArgumentError, "Partition: #{arn['partition']} from ARN doesn't match with partition name: #{partition_result['name']}."
+                  end
+                  raise ArgumentError, "Invalid ARN: Kinesis ARNs don't support `#{arn_type}` arn types."
+                end
+                raise ArgumentError, "Invalid ARN: No ARN type specified"
+              end
+              raise ArgumentError, "Invalid ARN: The ARN was not for the Kinesis service, found: #{arn['service']}."
+            end
+            raise ArgumentError, "Invalid ARN: Invalid region."
+          end
+          raise ArgumentError, "Invalid ARN: Invalid account id."
+        end
+        raise ArgumentError, "Invalid ARN: Failed to parse ARN."
+      end
+      if Aws::Endpoints::Matchers.set?(endpoint)
+        if Aws::Endpoints::Matchers.boolean_equals?(use_fips, true)
+          raise ArgumentError, "Invalid Configuration: FIPS and custom endpoint are not supported"
+        end
+        if Aws::Endpoints::Matchers.boolean_equals?(use_dual_stack, true)
+          raise ArgumentError, "Invalid Configuration: Dualstack and custom endpoint are not supported"
+        end
+        return Aws::Endpoints::Endpoint.new(url: endpoint, headers: {}, properties: {})
+      end
+      if Aws::Endpoints::Matchers.set?(region)
+        if (partition_result = Aws::Endpoints::Matchers.aws_partition(region))
+          if Aws::Endpoints::Matchers.boolean_equals?(use_fips, true) && Aws::Endpoints::Matchers.boolean_equals?(use_dual_stack, true)
+            if Aws::Endpoints::Matchers.boolean_equals?(true, Aws::Endpoints::Matchers.attr(partition_result, "supportsFIPS")) && Aws::Endpoints::Matchers.boolean_equals?(true, Aws::Endpoints::Matchers.attr(partition_result, "supportsDualStack"))
+              return Aws::Endpoints::Endpoint.new(url: "https://kinesis-fips.#{region}.#{partition_result['dualStackDnsSuffix']}", headers: {}, properties: {})
+            end
+            raise ArgumentError, "FIPS and DualStack are enabled, but this partition does not support one or both"
+          end
+          if Aws::Endpoints::Matchers.boolean_equals?(use_fips, true)
+            if Aws::Endpoints::Matchers.boolean_equals?(true, Aws::Endpoints::Matchers.attr(partition_result, "supportsFIPS"))
+              if Aws::Endpoints::Matchers.string_equals?("aws-us-gov", Aws::Endpoints::Matchers.attr(partition_result, "name"))
+                return Aws::Endpoints::Endpoint.new(url: "https://kinesis.#{region}.amazonaws.com", headers: {}, properties: {})
+              end
+              return Aws::Endpoints::Endpoint.new(url: "https://kinesis-fips.#{region}.#{partition_result['dnsSuffix']}", headers: {}, properties: {})
+            end
+            raise ArgumentError, "FIPS is enabled but this partition does not support FIPS"
+          end
+          if Aws::Endpoints::Matchers.boolean_equals?(use_dual_stack, true)
+            if Aws::Endpoints::Matchers.boolean_equals?(true, Aws::Endpoints::Matchers.attr(partition_result, "supportsDualStack"))
+              return Aws::Endpoints::Endpoint.new(url: "https://kinesis.#{region}.#{partition_result['dualStackDnsSuffix']}", headers: {}, properties: {})
+            end
+            raise ArgumentError, "DualStack is enabled but this partition does not support DualStack"
+          end
+          return Aws::Endpoints::Endpoint.new(url: "https://kinesis.#{region}.#{partition_result['dnsSuffix']}", headers: {}, properties: {})
+        end
+      end
+      raise ArgumentError, "Invalid Configuration: Missing Region"
+      raise ArgumentError, 'No endpoint could be resolved'
+
+    end
+  end
+end

data/lib/aws-sdk-kinesis/endpoints.rb

@@ -0,0 +1,509 @@
+# frozen_string_literal: true
+
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+
+module Aws::Kinesis
+  # @api private
+  module Endpoints
+
+    class AddTagsToStream
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class CreateStream
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: nil,
+          operation_type: nil,
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class DecreaseStreamRetentionPeriod
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class DeleteStream
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class DeregisterStreamConsumer
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: context.params[:consumer_arn],
+        )
+      end
+    end
+
+    class DescribeLimits
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: nil,
+          operation_type: nil,
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class DescribeStream
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class DescribeStreamConsumer
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: context.params[:consumer_arn],
+        )
+      end
+    end
+
+    class DescribeStreamSummary
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class DisableEnhancedMonitoring
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class EnableEnhancedMonitoring
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class GetRecords
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "data",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class GetShardIterator
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "data",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class IncreaseStreamRetentionPeriod
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class ListShards
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class ListStreamConsumers
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class ListStreams
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: nil,
+          operation_type: nil,
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class ListTagsForStream
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class MergeShards
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class PutRecord
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "data",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class PutRecords
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "data",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class RegisterStreamConsumer
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class RemoveTagsFromStream
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class SplitShard
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class StartStreamEncryption
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class StopStreamEncryption
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class SubscribeToShard
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: nil,
+          operation_type: "data",
+          consumer_arn: context.params[:consumer_arn],
+        )
+      end
+    end
+
+    class UpdateShardCount
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+    class UpdateStreamMode
+      def self.build(context)
+        unless context.config.regional_endpoint
+          endpoint = context.config.endpoint.to_s
+        end
+        Aws::Kinesis::EndpointParameters.new(
+          region: context.config.region,
+          use_dual_stack: context.config.use_dualstack_endpoint,
+          use_fips: context.config.use_fips_endpoint,
+          endpoint: endpoint,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+          consumer_arn: nil,
+        )
+      end
+    end
+
+  end
+end

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

@@ -27,6 +27,7 @@ module Aws::Kinesis
   # See {Seahorse::Client::RequestContext} for more information.
   #
   # ## Error Classes
+  # * {AccessDeniedException}
   # * {ExpiredIteratorException}
   # * {ExpiredNextTokenException}
   # * {InvalidArgumentException}
@@ -40,6 +41,21 @@ module Aws::Kinesis
 
     extend Aws::Errors::DynamicErrors
 
+    class AccessDeniedException < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [Aws::Kinesis::Types::AccessDeniedException] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+
+      # @return [String]
+      def message
+        @message || @data[:message]
+      end
+    end
+
     class ExpiredIteratorException < ServiceError
 
       # @param [Seahorse::Client::RequestContext] context