aws-sdk-core 2.9.36 → 2.11.632

data/lib/aws-sdk-core/pi.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:PI, {
+  api: "#{Aws::API_DIR}/pi/2018-02-27/api-2.json",
+  docs: "#{Aws::API_DIR}/pi/2018-02-27/docs-2.json",
+  examples: "#{Aws::API_DIR}/pi/2018-02-27/examples-1.json",
+  paginators: "#{Aws::API_DIR}/pi/2018-02-27/paginators-1.json",
+})

data/lib/aws-sdk-core/pinpointemail.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:PinpointEmail, {
+  api: "#{Aws::API_DIR}/pinpoint-email/2018-07-26/api-2.json",
+  docs: "#{Aws::API_DIR}/pinpoint-email/2018-07-26/docs-2.json",
+  examples: "#{Aws::API_DIR}/pinpoint-email/2018-07-26/examples-1.json",
+  paginators: "#{Aws::API_DIR}/pinpoint-email/2018-07-26/paginators-1.json",
+})

data/lib/aws-sdk-core/pinpointsmsvoice.rb

@@ -0,0 +1,4 @@
+Aws.add_service(:PinpointSMSVoice, {
+  api: "#{Aws::API_DIR}/sms-voice/2018-09-05/api-2.json",
+  docs: "#{Aws::API_DIR}/sms-voice/2018-09-05/docs-2.json",
+})

data/lib/aws-sdk-core/plugins/endpoint_discovery.rb

@@ -0,0 +1,167 @@
+module Aws
+  module Plugins
+
+    # Enables Endpoint Discovery per service when supported
+    #
+    # @seahorse.client.option [Boolean] :endpoint_discovery When
+    #     set to `true`, endpoint discovery will be enabled for
+    #     operations when available. Defaults to `false`.
+    #
+    # @seahorse.client.option [Integer] :endpoint_cache_max_entries
+    #   Used for the maximum size limit of the LRU cache storing endpoints data
+    #   for endpoint discovery enabled operations. Defaults to 1000.
+    #
+    # @seahorse.client.option [Integer] :endpoint_cache_max_threads
+    #   Used for the maximum threads in use for polling endpoints to be cached,
+    #   defaults to 10.
+    #
+    # @seahorse.client.option [Integer] :endpoint_cache_poll_interval
+    #   When :endpoint_discovery and :active_endpoint_cache is enabled,
+    #   Use this option to config the time interval in seconds for making
+    #   requests fetching endpoints information. Defaults to 60 sec.
+    #
+    # @seahorse.client.option [Boolean] :active_endpoint_cache
+    #   When set to `true`, a thread polling for endpoints will be running in
+    #   the background every 60 secs (default). Defaults to `false`.
+    class EndpointDiscovery < Seahorse::Client::Plugin
+
+      option(:endpoint_discovery, false) do |cfg|
+        resolve_endpoint_discovery(cfg)
+      end
+
+      option(:endpoint_cache_max_entries, 1000)
+
+      option(:endpoint_cache_max_threads, 10)
+
+      option(:endpoint_cache_poll_interval, 60)
+
+      option(:endpoint_cache) do |cfg|
+        Aws::EndpointCache.new(
+          max_entries: cfg.endpoint_cache_max_entries,
+          max_threads: cfg.endpoint_cache_max_threads
+        )
+      end
+
+      option(:active_endpoint_cache, false)
+
+      def add_handlers(handlers, config)
+        handlers.add(Handler, priority: 90) if config.regional_endpoint
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          if context.operation.endpoint_operation
+            context.http_request.headers['x-amz-api-version'] = context.config.api.version
+            _apply_endpoint_discovery_user_agent(context)
+          elsif discovery_cfg = context.operation.endpoint_discovery
+            endpoint = _discover_endpoint(
+              context,
+              str_2_bool(discovery_cfg["required"])
+            )
+            context.http_request.endpoint = _valid_uri(endpoint.address) if endpoint
+            if endpoint || context.config.endpoint_discovery
+              _apply_endpoint_discovery_user_agent(context)
+            end
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def _valid_uri(address)
+          # returned address can be missing scheme
+          if address.start_with?('http')
+            URI.parse(address)
+          else
+            URI.parse("https://" + address)
+          end
+        end
+
+        def _apply_endpoint_discovery_user_agent(ctx)
+          if ctx.config.user_agent_suffix.nil?
+            ctx.config.user_agent_suffix = "endpoint-discovery"
+          elsif !ctx.config.user_agent_suffix.include? "endpoint-discovery"
+            ctx.config.user_agent_suffix += "endpoint-discovery"
+          end
+        end
+
+        def _discover_endpoint(ctx, required)
+          cache = ctx.config.endpoint_cache 
+          key = cache.extract_key(ctx)
+
+          if required
+            # required for the operation
+            unless cache.key?(key)
+              cache.update(key, ctx)
+            end
+            endpoint = cache[key]
+            # hard fail if endpoint is not discovered
+            raise Aws::Errors::EndpointDiscoveryError.new unless endpoint
+            endpoint
+          elsif ctx.config.endpoint_discovery
+            # not required for the operation
+            # but enabled
+            if cache.key?(key)
+              cache[key]
+            elsif ctx.config.active_endpoint_cache
+              # enabled active cache pull
+              interval = ctx.config.endpoint_cache_poll_interval
+              if key.include?('_')
+                # identifier related, kill the previous polling thread by key
+                # because endpoint req params might be changed
+                cache.delete_polling_thread(key)
+              end
+
+              # start a thread for polling endpoints when non-exist
+              unless cache.threads_key?(key)
+                thread = Thread.new do
+                  while !cache.key?(key) do
+                    cache.update(key, ctx)
+                    sleep(interval)
+                  end
+                end
+                cache.update_polling_pool(key, thread)
+              end
+
+              cache[key]
+            else
+              # disabled active cache pull
+              # attempt, buit fail soft
+              cache.update(key, ctx)
+              cache[key]
+            end
+          end
+        end
+
+        def str_2_bool(str)
+          case str.to_s
+          when "true" then true
+          when "false" then false
+          else
+            nil
+          end
+        end
+
+      end
+
+      private
+
+      def self.resolve_endpoint_discovery(cfg)
+        env = ENV['AWS_ENABLE_ENDPOINT_DISCOVERY']
+        shared_cfg = Aws.shared_config.endpoint_discovery(profile: cfg.profile)
+        self.str_2_bool(env) || self.str_2_bool(shared_cfg)
+      end
+
+      def self.str_2_bool(str)
+        case str.to_s
+        when "true" then true
+        when "false" then false
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/endpoint_pattern.rb

@@ -0,0 +1,62 @@
+module Aws
+  module Plugins
+
+    # Disable host prefix per operation when available
+    #
+    # @seahorse.client.option [Boolean] :disable_host_prefix_injection
+    #   Set to true to disable SDK automatically adding host prefix
+    #   to default service endpoint when available.
+    #
+    class EndpointPattern < Seahorse::Client::Plugin
+
+      option(:disable_host_prefix_injection, false)
+
+      def add_handlers(handlers, config)
+        if config.regional_endpoint && !config.disable_host_prefix_injection
+          handlers.add(Handler, priority: 90)
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          endpoint_trait = context.operation.endpoint_pattern
+          if endpoint_trait && !endpoint_trait.empty?
+            _apply_endpoint_trait(context, endpoint_trait)
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        def _apply_endpoint_trait(context, trait)
+          # currently only support host pattern
+          ori_host = context.http_request.endpoint.host
+          if pattern = trait['hostPrefix']
+            host_prefix = pattern.gsub(/\{.+?\}/) do |label|
+              label = label.delete("{}")
+              _replace_label_value(
+                ori_host, label, context.operation.input, context.params)
+            end
+            context.http_request.endpoint.host = host_prefix + context.http_request.endpoint.host
+          end
+        end
+
+        def _replace_label_value(ori, label, input_ref, params)
+          name = nil
+          input_ref.shape.members.each do |m_name, ref|
+            if ref['hostLabel'] && ref['hostLabelName'] == label
+              name = m_name
+            end
+          end
+          if name.nil? || params[name].nil?
+            raise Errors::MissingEndpointHostLabelValue.new(name)
+          end
+          params[name]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/regional_endpoint.rb

@@ -20,10 +20,15 @@ module Aws
         resolve_region(cfg)
       end
 
+      option(:regional_endpoint, false)
+
       option(:endpoint) do |cfg|
         endpoint_prefix = cfg.api.metadata['endpointPrefix']
         if cfg.region && endpoint_prefix
-          EndpointProvider.resolve(cfg.region, endpoint_prefix)
+          if cfg.respond_to?(:sts_regional_endpoints)
+            sts_regional = cfg.sts_regional_endpoints
+          end
+          EndpointProvider.resolve(cfg.region, endpoint_prefix, sts_regional)
         end
       end
 

data/lib/aws-sdk-core/plugins/retry_errors.rb

@@ -71,6 +71,25 @@ module Aws
           (500..599).include?(@http_status_code)
         end
 
+        def endpoint_discovery?(context)
+          return false unless context.operation.endpoint_discovery
+
+          if @http_status_code == 421 ||
+            extract_name(@error) == 'InvalidEndpointException'
+            @error = Errors::EndpointDiscoveryError.new
+          end
+
+          # When endpoint discovery error occurs
+          # evict the endpoint from cache
+          if @error.is_a?(Errors::EndpointDiscoveryError)
+            key = context.config.endpoint_cache.extract_key(context)
+            context.config.endpoint_cache.delete(key)
+            true
+          else
+            false
+          end
+        end
+
         private
 
         def extract_name(error)
@@ -135,7 +154,8 @@ module Aws
           error.throttling_error? or
           error.checksum? or
           error.networking? or
-          error.server?
+          error.server? or
+          error.endpoint_discovery?(context)
         end
 
         def refreshable_credentials?(context)

data/lib/aws-sdk-core/plugins/s3_control_dns.rb

@@ -0,0 +1,25 @@
+module Aws
+  module Plugins
+    class S3ControlDns < Seahorse::Client::Plugin
+      def add_handlers(handlers, config)
+        handlers.add(Handler, step: :build, priority: 1)
+      end
+
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          if context.operation.endpoint_pattern.nil?
+            move_account_id_to_subdomain(context)
+          end
+          @handler.call(context)
+        end
+
+        private
+        def move_account_id_to_subdomain(context)
+          account_id = context.params[:account_id]
+          endpoint = context.http_request.endpoint
+          endpoint.host = "#{account_id}.#{endpoint.host}"
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/s3_control_dualstack.rb

@@ -0,0 +1,48 @@
+module Aws
+  module Plugins
+    # @api private
+    class S3ControlDualstack < Seahorse::Client::Plugin
+      option(:use_dualstack_endpoint, false)
+
+        def add_handlers(handlers, config)
+          handlers.add(OptionHandler, step: :initialize)
+          handlers.add(DualstackHandler, step: :build, priority: 2)
+        end
+
+        # @api private
+        class OptionHandler < Seahorse::Client::Handler
+          def call(context)
+            dualstack = context.params.delete(:use_dualstack_endpoint)
+            dualstack = context.config.use_dualstack_endpoint if dualstack.nil?
+            context[:use_dualstack_endpoint] = dualstack
+            @handler.call(context)
+          end
+        end
+
+        # @api private
+        class DualstackHandler < Seahorse::Client::Handler
+          def call(context)
+            apply_dualstack_endpoint(context) if use_dualstack_endpoint?(context)
+            @handler.call(context)
+          end
+
+          private
+          def apply_dualstack_endpoint(context)
+            bucket_name = context.params[:bucket]
+            region = context.config.region
+            dns_suffix = EndpointProvider.dns_suffix_for(region)
+            host = "s3-control.dualstack.#{region}.#{dns_suffix}"
+            endpoint = URI.parse(context.http_request.endpoint.to_s)
+            endpoint.scheme = context.http_request.endpoint.scheme
+            endpoint.port = context.http_request.endpoint.port
+            endpoint.host = host
+            context.http_request.endpoint = endpoint.to_s
+          end
+
+          def use_dualstack_endpoint?(context)
+            context[:use_dualstack_endpoint]
+          end
+        end
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/s3_control_signer.rb

@@ -0,0 +1,53 @@
+require 'set'
+
+module Aws
+  module Plugins
+    # This plugin is an implementation detail and may be modified.
+    # @api private
+    class S3ControlSigner < Seahorse::Client::Plugin
+
+      class SigningHandler < RequestSigner::Handler
+
+        def call(context)
+          require_credentials(context)
+          version = context.config.signature_version
+          apply_v4_signature(context)
+          @handler.call(context)
+        end
+
+        private
+
+        def apply_v4_signature(context)
+          Signers::V4.new(
+            context.config.credentials, 's3',
+            context[:cached_sigv4_region] || context.config.sigv4_region,
+          ).sign(context.http_request)
+        end
+
+        def apply_s3_legacy_signature(context)
+          Signers::S3.sign(context)
+        end
+
+      end
+
+      # Abstract base class for the other two handlers
+      class Handler < Seahorse::Client::Handler
+
+        private
+
+        def new_hostname(context, region)
+          bucket = context.params[:bucket]
+          if region == 'us-east-1'
+            "#{bucket}.s3.amazonaws.com"
+          else
+            bucket + '.' + URI.parse(EndpointProvider.resolve(region, 's3')).host
+          end
+        end
+
+      end
+
+      # sign the request
+      handler(SigningHandler, step: :sign)
+    end
+  end
+end

data/lib/aws-sdk-core/plugins/s3_iad_regional_endpoint.rb

@@ -0,0 +1,58 @@
+module Aws
+  module Plugins
+
+    class S3IADRegionalEndpoint < Seahorse::Client::Plugin
+
+      option(:s3_us_east_1_regional_endpoint,
+        default: 'legacy',
+        doc_type: String,
+        docstring: <<-DOCS) do |cfg|
+Passing in `regional` to enable regional endpoint for S3's `us-east-1`
+region. Defaults to `legacy` mode using global endpoint.
+        DOCS
+        resolve_iad_regional_endpoint(cfg)
+      end
+
+      def add_handlers(handlers, config)
+        if config.region == 'us-east-1'
+          handlers.add(Handler)
+        end
+      end
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          # keep legacy global endpoint pattern by default
+          if context.config.s3_us_east_1_regional_endpoint == 'legacy'
+            context.http_request.endpoint.host = S3IADRegionalEndpoint.legacy_host(
+              context.http_request.endpoint.host)
+          end
+          @handler.call(context)
+        end
+
+      end
+
+      def self.legacy_host(host)
+        host.sub(".us-east-1", '')
+      end
+
+      private
+
+      def self.resolve_iad_regional_endpoint(cfg)
+        mode = ENV['AWS_S3_US_EAST_1_REGIONAL_ENDPOINT'] ||
+          Aws.shared_config.s3_us_east_1_regional_endpoint(profile: cfg.profile) ||
+          'legacy'
+        mode.downcase!
+        unless %w(legacy regional).include?(mode)
+          raise ArgumentError, "expected :s3_us_east_1_regional_endpoint or"\
+            " ENV['AWS_S3_US_EAST_1_REGIONAL_ENDPOINT'] to be `legacy` or"\
+            " `regional`."
+        end
+        mode
+      end
+
+    end
+
+  end
+end

data/lib/aws-sdk-core/plugins/sqs_md5s.rb

@@ -56,7 +56,9 @@ module Aws
 
         def validate_single_message(body, attributes, response)
           validate_body(body, response)
-          validate_attributes(attributes, response) unless attributes.nil?
+          unless attributes.nil? || attributes.empty?
+            validate_attributes(attributes, response)
+          end
         end
 
         def validate_body(body, response)

data/lib/aws-sdk-core/plugins/sts_regional_endpoints.rb

@@ -0,0 +1,30 @@
+module Aws
+  module Plugins
+
+    class STSRegionalEndpoints < Seahorse::Client::Plugin
+
+      option(:sts_regional_endpoints,
+        default: 'regional',
+        doc_type: String,
+        docstring: <<-DOCS) do |cfg|
+Passing in 'regional' to enable regional endpoint for STS for all supported
+regions (except 'aws-global'). Using 'legacy' mode will force all legacy 
+regions to resolve to the STS global endpoint.
+      DOCS
+        resolve_sts_regional_endpoints(cfg)
+      end
+
+      private
+                                                                       
+      def self.resolve_sts_regional_endpoints(cfg)
+        env_mode = ENV['AWS_STS_REGIONAL_ENDPOINTS']
+        env_mode = nil if env_mode == ''
+        cfg_mode = Aws.shared_config.sts_regional_endpoints(
+          profile: cfg.profile)
+        env_mode || cfg_mode || 'regional'
+      end
+
+    end
+
+  end
+end

data/lib/aws-sdk-core/pricing.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:Pricing, {
+  api: "#{Aws::API_DIR}/pricing/2017-10-15/api-2.json",
+  docs: "#{Aws::API_DIR}/pricing/2017-10-15/docs-2.json",
+  examples: "#{Aws::API_DIR}/pricing/2017-10-15/examples-1.json",
+  paginators: "#{Aws::API_DIR}/pricing/2017-10-15/paginators-1.json",
+})

data/lib/aws-sdk-core/qldb.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:QLDB, {
+  api: "#{Aws::API_DIR}/qldb/2019-01-02/api-2.json",
+  docs: "#{Aws::API_DIR}/qldb/2019-01-02/docs-2.json",
+  examples: "#{Aws::API_DIR}/qldb/2019-01-02/examples-1.json",
+  paginators: "#{Aws::API_DIR}/qldb/2019-01-02/paginators-1.json",
+})

data/lib/aws-sdk-core/qldbsession.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:QLDBSession, {
+  api: "#{Aws::API_DIR}/qldb-session/2019-07-11/api-2.json",
+  docs: "#{Aws::API_DIR}/qldb-session/2019-07-11/docs-2.json",
+  examples: "#{Aws::API_DIR}/qldb-session/2019-07-11/examples-1.json",
+  paginators: "#{Aws::API_DIR}/qldb-session/2019-07-11/paginators-1.json",
+})

data/lib/aws-sdk-core/quicksight.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:QuickSight, {
+  api: "#{Aws::API_DIR}/quicksight/2018-04-01/api-2.json",
+  docs: "#{Aws::API_DIR}/quicksight/2018-04-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/quicksight/2018-04-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/quicksight/2018-04-01/paginators-1.json",
+})

data/lib/aws-sdk-core/ram.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:RAM, {
+  api: "#{Aws::API_DIR}/ram/2018-01-04/api-2.json",
+  docs: "#{Aws::API_DIR}/ram/2018-01-04/docs-2.json",
+  examples: "#{Aws::API_DIR}/ram/2018-01-04/examples-1.json",
+  paginators: "#{Aws::API_DIR}/ram/2018-01-04/paginators-1.json",
+})

data/lib/aws-sdk-core/rdsdataservice.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:RDSDataService, {
+  api: "#{Aws::API_DIR}/rds-data/2018-08-01/api-2.json",
+  docs: "#{Aws::API_DIR}/rds-data/2018-08-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/rds-data/2018-08-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/rds-data/2018-08-01/paginators-1.json",
+})

data/lib/aws-sdk-core/redshiftdataapiservice.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:RedshiftDataAPIService, {
+  api: "#{Aws::API_DIR}/redshift-data/2019-12-20/api-2.json",
+  docs: "#{Aws::API_DIR}/redshift-data/2019-12-20/docs-2.json",
+  examples: "#{Aws::API_DIR}/redshift-data/2019-12-20/examples-1.json",
+  paginators: "#{Aws::API_DIR}/redshift-data/2019-12-20/paginators-1.json",
+})

data/lib/aws-sdk-core/rekognition.rb

@@ -3,4 +3,5 @@ Aws.add_service(:Rekognition, {
   docs: "#{Aws::API_DIR}/rekognition/2016-06-27/docs-2.json",
   examples: "#{Aws::API_DIR}/rekognition/2016-06-27/examples-1.json",
   paginators: "#{Aws::API_DIR}/rekognition/2016-06-27/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/rekognition/2016-06-27/waiters-2.json",
 })

data/lib/aws-sdk-core/resourcegroups.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:ResourceGroups, {
+  api: "#{Aws::API_DIR}/resource-groups/2017-11-27/api-2.json",
+  docs: "#{Aws::API_DIR}/resource-groups/2017-11-27/docs-2.json",
+  examples: "#{Aws::API_DIR}/resource-groups/2017-11-27/examples-1.json",
+  paginators: "#{Aws::API_DIR}/resource-groups/2017-11-27/paginators-1.json",
+})

data/lib/aws-sdk-core/robomaker.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:RoboMaker, {
+  api: "#{Aws::API_DIR}/robomaker/2018-06-29/api-2.json",
+  docs: "#{Aws::API_DIR}/robomaker/2018-06-29/docs-2.json",
+  examples: "#{Aws::API_DIR}/robomaker/2018-06-29/examples-1.json",
+  paginators: "#{Aws::API_DIR}/robomaker/2018-06-29/paginators-1.json",
+})

data/lib/aws-sdk-core/route53resolver.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:Route53Resolver, {
+  api: "#{Aws::API_DIR}/route53resolver/2018-04-01/api-2.json",
+  docs: "#{Aws::API_DIR}/route53resolver/2018-04-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/route53resolver/2018-04-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/route53resolver/2018-04-01/paginators-1.json",
+})

data/lib/aws-sdk-core/s3control.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:S3Control, {
+  api: "#{Aws::API_DIR}/s3control/2018-08-20/api-2.json",
+  docs: "#{Aws::API_DIR}/s3control/2018-08-20/docs-2.json",
+  examples: "#{Aws::API_DIR}/s3control/2018-08-20/examples-1.json",
+  paginators: "#{Aws::API_DIR}/s3control/2018-08-20/paginators-1.json",
+})

data/lib/aws-sdk-core/s3outposts.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:S3Outposts, {
+  api: "#{Aws::API_DIR}/s3outposts/2017-07-25/api-2.json",
+  docs: "#{Aws::API_DIR}/s3outposts/2017-07-25/docs-2.json",
+  examples: "#{Aws::API_DIR}/s3outposts/2017-07-25/examples-1.json",
+  paginators: "#{Aws::API_DIR}/s3outposts/2017-07-25/paginators-1.json",
+})

data/lib/aws-sdk-core/sagemaker.rb

@@ -0,0 +1,7 @@
+Aws.add_service(:SageMaker, {
+  api: "#{Aws::API_DIR}/sagemaker/2017-07-24/api-2.json",
+  docs: "#{Aws::API_DIR}/sagemaker/2017-07-24/docs-2.json",
+  examples: "#{Aws::API_DIR}/sagemaker/2017-07-24/examples-1.json",
+  paginators: "#{Aws::API_DIR}/sagemaker/2017-07-24/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/sagemaker/2017-07-24/waiters-2.json",
+})

data/lib/aws-sdk-core/sagemakerruntime.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:SageMakerRuntime, {
+  api: "#{Aws::API_DIR}/runtime.sagemaker/2017-05-13/api-2.json",
+  docs: "#{Aws::API_DIR}/runtime.sagemaker/2017-05-13/docs-2.json",
+  examples: "#{Aws::API_DIR}/runtime.sagemaker/2017-05-13/examples-1.json",
+  paginators: "#{Aws::API_DIR}/runtime.sagemaker/2017-05-13/paginators-1.json",
+})

data/lib/aws-sdk-core/savingsplans.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:SavingsPlans, {
+  api: "#{Aws::API_DIR}/savingsplans/2019-06-28/api-2.json",
+  docs: "#{Aws::API_DIR}/savingsplans/2019-06-28/docs-2.json",
+  examples: "#{Aws::API_DIR}/savingsplans/2019-06-28/examples-1.json",
+  paginators: "#{Aws::API_DIR}/savingsplans/2019-06-28/paginators-1.json",
+})

data/lib/aws-sdk-core/schemas.rb

@@ -0,0 +1,6 @@
+Aws.add_service(:Schemas, {
+  api: "#{Aws::API_DIR}/schemas/2019-12-02/api-2.json",
+  docs: "#{Aws::API_DIR}/schemas/2019-12-02/docs-2.json",
+  paginators: "#{Aws::API_DIR}/schemas/2019-12-02/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/schemas/2019-12-02/waiters-2.json",
+})