gapic-generator 0.52.0 → 0.53.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b45efa15311119a19ee117f8eaf8fa2af651151a80f8ed004373b232652f599f
-  data.tar.gz: 69203b61e070ca8a4a02e901299739754f1048aa935025fd9ac53af072a5aac7
+  metadata.gz: 3264cfe286069bf2e3bed64ae2246c0b8e48d97851809c99c5520e072fa38889
+  data.tar.gz: d9503be57f76aedd856a46159e138673fc83f2912fa51018d16e5cd1e8c71f90
 SHA512:
-  metadata.gz: 10fbd033561469722836fbbb60888097f91571179880221a033aff5e14be7e980c6a5e94e8383305a7422df16d7158ecf39f54a312c742ea642892927d7b248a
-  data.tar.gz: 5718898dd81be9b2b3eedf1dc188f61821f2d2d012daf12a82510ba1b09fd696c4594b6dbedee6c19b31ec64da5f15bca4c0ce4a98749c20e1f80aa64975aa8c
+  metadata.gz: d8109c1036d6b95c2bf2fe201de7e2cf26516e4d315c6d4ca3331b52f0d312d27884416bd6ce7db8209ae78c13ffab4120b444e229fc914d3d329ca801dd6837
+  data.tar.gz: 1ef6ae68e1fc76dfc19bbe947d7f4340918403494d57bd3d1ba40540b953921470a5090b7ed7f6d2fe80519066c28d92e8a0a3115acbf4d498fc43c8580debd9

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Release History for gapic-generator
 
+### 0.53.0 / 2026-09-30
+
+* Feature: update gapic-common for generated libraries to 1.4
+* Feature: resumable upload support in gapic-generator
+
 ### 0.52.0 / 2026-09-04
 
 * Fix: escape multi-line braces and backtick unknown doc tags in yard formatting

data/lib/gapic/generator/version.rb

@@ -16,6 +16,6 @@
 
 module Gapic
   module Generator
-    VERSION = "0.52.0"
+    VERSION = "0.53.0"
   end
 end

data/lib/gapic/generators/default_generator.rb

@@ -92,10 +92,16 @@ module Gapic
             # Rest-only `service.stub` file
             files << g("service/rest/service_stub",      "lib/#{service.rest.service_stub_file_path}",       service: service) if should_generate_rest
 
+            # Resumable upload stub, shared by both transports because uploads always travel over REST
+            files << g("service/resumable_upload_stub",  "lib/#{service.resumable_upload_stub_file_path}",   service: service) if service.resumable_upload?
+
             # Unit tests for `client.rb`
             files << g("service/test/client",            "test/#{service.test_client_file_path}",            service: service) if should_generate_grpc
             files << g("service/rest/test/client",       "test/#{service.rest.test_client_file_path}",       service: service) if should_generate_rest
 
+            # Unit tests for resumable upload RPCs, which the client tests above skip
+            files << g("service/test/resumable_upload",  "test/#{service.test_resumable_upload_file_path}",  service: service) if service.resumable_upload?
+
             # Unit tests for `paths.rb`
             files << g("service/test/client_paths",      "test/#{service.test_paths_file_path}",             service: service) if service.paths? && should_generate_grpc
 

data/lib/gapic/model/method/resumable_upload.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "gapic/model/model_error"
+
+module Gapic
+  module Model
+    module Method
+      ##
+      # Resumable upload method-level model.
+      #
+      # A resumable upload RPC does not send its payload in the initiation request. The request it
+      # describes only creates an upload session; the bytes travel afterwards, over REST, in chunks
+      # addressed to a URL the server hands back. Generated clients therefore return an upload handle
+      # from such a method rather than a response message.
+      #
+      # Until the upload annotation is published, the set of such RPCs is carried here as a table, and
+      # so is the URL prefix each one's initiation request is sent under. When the annotation lands,
+      # {.url_prefix_for} keeps the table and detection moves to `http.media_upload.enabled`.
+      #
+      # @!attribute [r] url_prefix
+      #   @return [String] The path prefix prepended to the transcoded initiation URL, without
+      #     surrounding slashes, e.g. `resumable/upload`.
+      #
+      class ResumableUpload
+        # @return [String]
+        attr_reader :url_prefix
+
+        ##
+        # @param url_prefix [String] The upload URL prefix for the matched RPC.
+        #
+        def initialize url_prefix
+          @url_prefix = url_prefix
+        end
+
+        ##
+        # Exact matches, keyed by the full gRPC name of the RPC.
+        #
+        EXACT_PREFIXES = {
+          "google.showcase.v1beta1.ResumableUploadService.UploadMedia" => "resumable/upload"
+        }.freeze
+
+        ##
+        # Version-family matches, for protos that are republished under a new version regularly.
+        # Anchored on the left at the package and on the right at the service and method, with the
+        # intervening segments (e.g. `.services.`) unconstrained.
+        #
+        VERSIONED_PREFIXES = [
+          {
+            left:   /\Agoogle\.ads\.googleads\.v[0-9_]+\./,
+            right:  ".YouTubeVideoUploadService.CreateYouTubeVideoUpload",
+            prefix: "resumable/upload"
+          }
+        ].freeze
+
+        class << self
+          ##
+          # Inspects a method and returns its resumable upload model, or `nil` if it does not perform
+          # resumable uploads.
+          #
+          # @param method [Gapic::Presenters::MethodPresenter]
+          #
+          # @raise [Gapic::Model::ModelError] if the method is a resumable upload RPC that the
+          #   generator cannot generate an upload surface for.
+          #
+          # @return [Gapic::Model::Method::ResumableUpload, nil]
+          #
+          def create method
+            prefix = url_prefix_for method.grpc_full_name
+            return nil if prefix.nil?
+            validate! method
+            new prefix
+          end
+
+          ##
+          # The upload URL prefix for an RPC, or `nil` if the RPC does not perform resumable uploads.
+          #
+          # @param full_name [String] The full gRPC name of the RPC,
+          #   e.g. `google.showcase.v1beta1.ResumableUploadService.UploadMedia`.
+          #
+          # @return [String, nil]
+          #
+          def url_prefix_for full_name
+            EXACT_PREFIXES[full_name] ||
+              VERSIONED_PREFIXES.find do |match|
+                match[:left].match?(full_name) && full_name.end_with?(match[:right])
+              end&.fetch(:prefix)
+          end
+
+          ##
+          # Verifies that an upload surface can be generated for the given method. A resumable upload
+          # is a single unary POST that carries a body, and anything else in the table is a
+          # misconfiguration that must fail the build rather than generate code that cannot work.
+          #
+          # @param method [Gapic::Presenters::MethodPresenter]
+          #
+          # @raise [Gapic::Model::ModelError]
+          #
+          # @return [void]
+          #
+          def validate! method
+            reason = unsupported_reason method
+            return if reason.nil?
+            raise ModelError, "The method #{method.grpc_full_name} performs resumable uploads, " \
+                              "which the generator supports only for #{reason}."
+          end
+
+          private
+
+          ##
+          # @param method [Gapic::Presenters::MethodPresenter]
+          # @return [String, nil] What the method would have had to be, or `nil` if it is supported.
+          #
+          def unsupported_reason method
+            return "non-streaming methods" if method.client_streaming? || method.server_streaming?
+            return "non-paginated methods" if method.paged?
+            return "methods that are not long-running operations" if method.lro? || method.nonstandard_lro?
+
+            binding = method.http_bindings.first
+            return "methods with an HTTP binding" if binding.nil?
+            return "methods bound to POST" unless binding.verb == :post
+            return "methods whose HTTP binding has a body" unless binding.body?
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gapic/presenters/gem_presenter.rb

@@ -260,7 +260,7 @@ module Gapic
 
       def dependencies
         @dependencies ||= begin
-          deps = { "gapic-common" => "~> 1.3" }
+          deps = { "gapic-common" => "~> 1.5" }
           deps["grpc-google-iam-v1"] = "~> 1.11" if iam_dependency?
           extra_deps = gem_config_dependencies
           deps.merge! mixins_model.dependencies if mixins_model.mixins?

data/lib/gapic/presenters/method_presenter.rb

@@ -17,6 +17,7 @@
 require "active_support/inflector"
 require "gapic/ruby_info"
 require "gapic/helpers/namespace_helper"
+require "gapic/model/method/resumable_upload"
 
 module Gapic
   module Presenters
@@ -71,6 +72,10 @@ module Gapic
         @lro = Gapic::Model::Method.parse_lro @method, @api
 
         @rest = MethodRestPresenter.new self, @api
+
+        # Built last: detection is cheap but its validation reads the LRO model, the HTTP bindings
+        # and the pagination check, all of which have to exist first.
+        @resumable_upload = Gapic::Model::Method::ResumableUpload.create self
       end
 
       ##
@@ -279,6 +284,36 @@ module Gapic
         service.nonstandard_lros.find { |model| model.service == @lro.service_full_name }
       end
 
+      ##
+      # Whether this method performs a resumable upload. Such a method returns an upload handle
+      # rather than a response, and its payload travels over REST in chunks after the request this
+      # method describes has created the upload session.
+      #
+      # @return [Boolean]
+      #
+      def resumable_upload?
+        !@resumable_upload.nil?
+      end
+
+      ##
+      # The path prefix prepended to this method's transcoded initiation URL, without surrounding
+      # slashes, e.g. `resumable/upload`. `nil` unless this method performs a resumable upload.
+      #
+      # @return [String, nil]
+      #
+      def upload_url_prefix
+        @resumable_upload&.url_prefix
+      end
+
+      ##
+      # The name of the constant the generated upload stub holds this method's URL prefix in.
+      #
+      # @return [String]
+      #
+      def upload_url_prefix_const_name
+        "#{name.upcase}_URL_PREFIX"
+      end
+
       def client_streaming?
         @method.client_streaming
       end

data/lib/gapic/presenters/service_presenter.rb

@@ -422,6 +422,15 @@ module Gapic
         service_file_path.sub ".rb", "_operations_test.rb"
       end
 
+      ##
+      # Path of the generated tests covering this service's resumable upload RPCs. Those RPCs are
+      # excluded from the ordinary client tests, which assume a call returns a response.
+      #
+      # @return [String]
+      def test_resumable_upload_file_path
+        service_file_path.sub ".rb", "_resumable_upload_test.rb"
+      end
+
       def stub_name
         "#{ActiveSupport::Inflector.underscore name}_stub"
       end
@@ -489,6 +498,62 @@ module Gapic
         ServicePresenter.new @gem_presenter, @api, lro.services.first, parent_service: self unless lro.nil?
       end
 
+      ##
+      # Whether any of this service's RPCs perform resumable uploads, and therefore whether an upload
+      # stub has to be generated for it and built by its clients.
+      #
+      # @return [Boolean]
+      def resumable_upload?
+        methods.any?(&:resumable_upload?)
+      end
+
+      ##
+      # Presenters for the RPCs of this service that perform resumable uploads.
+      #
+      # @return [Enumerable<Gapic::Presenters::MethodPresenter>]
+      def resumable_upload_methods
+        methods.select(&:resumable_upload?)
+      end
+
+      ##
+      # The class name of the generated upload stub. One per service, shared by both transports, and
+      # deliberately not nested under `Rest::`: the gRPC client builds it too, because the upload
+      # itself always travels over REST.
+      #
+      # @return [String]
+      def resumable_upload_stub_name
+        "ResumableUploadStub"
+      end
+
+      # @return [String]
+      def resumable_upload_stub_name_full
+        fix_namespace @api, "#{service_name_full}::#{resumable_upload_stub_name}"
+      end
+
+      # @return [String]
+      def resumable_upload_stub_require
+        ruby_file_path @api, resumable_upload_stub_name_full
+      end
+
+      # @return [String]
+      def resumable_upload_stub_file_path
+        "#{resumable_upload_stub_require}.rb"
+      end
+
+      # @return [String]
+      def resumable_upload_stub_file_name
+        resumable_upload_stub_file_path.split("/").last
+      end
+
+      ##
+      # An instance variable name used for the generated upload stub. The clients keep the stub here
+      # and expose no reader for it.
+      #
+      # @return [String]
+      def resumable_upload_stub_ivar
+        "@resumable_upload_stub"
+      end
+
       def config_channel_args
         { "grpc.service_config_disable_resolution" => 1 }
       end

data/lib/gapic/presenters/service_rest_presenter.rb

@@ -357,6 +357,18 @@ module Gapic
         main_service.methods.select(&:can_generate_rest?)
       end
 
+      ##
+      # Presenters for methods that the REST service stub carries an implementation for. An upload
+      # RPC has no ordinary REST path: the REST client delegates to the upload handle exactly as the
+      # gRPC client does, so a plain call method and transcoder here would be dead code that also
+      # happens to be wrong — a non-resumable POST of the whole payload.
+      #
+      # @return [Enumerable<Gapic::Presenters::MethodPresenter>]
+      #
+      def service_stub_methods
+        methods.reject(&:resumable_upload?)
+      end
+
       ##
       # Require string for the helpers file
       #

data/lib/gapic/presenters/snippet/response_handling_presenters.rb

@@ -80,6 +80,66 @@ module Gapic
         attr_reader :response_name
       end
 
+      ##
+      # Presentation information about resumable upload response handling.
+      #
+      # A resumable upload RPC returns a {::Gapic::ResumableUpload} handle rather than a
+      # response message, so the snippet names the call result `upload` and goes on to
+      # start the upload, which is what actually produces the response message.
+      #
+      class ResumableUploadResponseHandlingPresenter
+        include ResponseHandlingPresenterCommon
+
+        ##
+        # Create a resumable upload response handling presenter
+        #
+        # @param proto [Google::Cloud::Tools::SnippetGen::ConfigLanguage::V1::Snippet::SimpleResponseHandling]
+        #     The protobuf representation
+        # @param json [String]
+        #     The JSON representation
+        # @param response_type [String] The fully qualified response message class
+        # @param phase1 [Boolean] True if this is a phase 1 snippet without config
+        #
+        def initialize proto, _json, response_type:, phase1:
+          @response_name = phase1 ? "upload" : compute_response_name(proto, phase1)
+          @render_lines = phase1 ? upload_lines(response_type) : []
+          @render = @render_lines.join "\n"
+        end
+
+        ##
+        # The lines of rendered code
+        # @return [Array<String>]
+        #
+        attr_reader :render_lines
+
+        ##
+        # The rendered code as a single string, possibly with line breaks
+        # @return [String]
+        #
+        attr_reader :render
+
+        ##
+        # The name of the response variable, or nil for no response handling
+        # @return [String,nil]
+        #
+        attr_reader :response_name
+
+        private
+
+        def upload_lines response_type
+          [
+            "# The returned object is a handle for a resumable upload. Nothing has been",
+            "# uploaded yet, and the timeout and retry policy of the call above cover only",
+            "# the request that creates the upload session, not the upload as a whole.",
+            "stream = File.open \"input.bin\", \"rb\"",
+            "result = #{@response_name}.start stream: stream, content_type: \"application/octet-stream\"",
+            "",
+            "# The returned object is of type #{response_type}.",
+            "p result"
+          ]
+        end
+      end
+
       ##
       # Presentation information about LRO response handling
       #

data/lib/gapic/presenters/snippet_presenter.rb

@@ -63,6 +63,8 @@ module Gapic
           :paged
         elsif @method_presenter.lro?
           :lro
+        elsif @method_presenter.resumable_upload?
+          :resumable_upload
         else
           :simple
         end
@@ -244,13 +246,12 @@ module Gapic
           LroResponseHandlingPresenter.new call_proto&.lro_handling,
                                            call_json&.fetch("lroHandling", nil),
                                            phase1: phase1
+        when :resumable_upload
+          ResumableUploadResponseHandlingPresenter.new call_proto&.response_handling,
+                                                       call_json&.fetch("responseHandling", nil),
+                                                       response_type: return_type, phase1: phase1
         when :streaming
-          response_name = phase1 ? "output" : call_proto&.server_stream_name
-          response_name = nil if response_name == ""
-          StreamingResponseHandlingPresenter.new call_proto&.response_handling,
-                                                 call_json&.fetch("responseHandling", nil),
-                                                 response_name: response_name, base_response_type: base_response_type,
-                                                 phase1: phase1
+          build_streaming_response_handling_presenter call_proto, call_json, phase1
         else
           SimpleResponseHandlingPresenter.new call_proto&.response_handling,
                                               call_json&.fetch("responseHandling", nil),
@@ -258,6 +259,15 @@ module Gapic
         end
       end
 
+      def build_streaming_response_handling_presenter call_proto, call_json, phase1
+        response_name = phase1 ? "output" : call_proto&.server_stream_name
+        response_name = nil if response_name == ""
+        StreamingResponseHandlingPresenter.new call_proto&.response_handling,
+                                               call_json&.fetch("responseHandling", nil),
+                                               response_name: response_name, base_response_type: base_response_type,
+                                               phase1: phase1
+      end
+
       def build_client_call_presenter call_proto, call_json, request_name, response_name
         phase1 = !config?
         if response_kind == :paged

data/templates/default/lib/_service.text.erb

@@ -15,6 +15,9 @@ require "<%= service.credentials_require %>"
 <%- if service.paths? -%>
 require "<%= service.paths_require %>"
 <%- end -%>
+<%- if service.resumable_upload? -%>
+require "<%= service.resumable_upload_stub_require %>"
+<%- end -%>
 <%- if service.generate_grpc_clients? -%>
 <%- if service.lro? -%>
 require "<%= service.operations_require %>"

data/templates/default/lib/rest/_rest.text.erb

@@ -15,6 +15,9 @@ require "<%= service.credentials_require %>"
 <%- if service.paths? -%>
 require "<%= service.paths_require %>"
 <%- end -%>
+<%- if service.resumable_upload? -%>
+require "<%= service.resumable_upload_stub_require %>"
+<%- end -%>
 <%- if service.rest.lro? -%>
 require "<%= service.rest.operations_require %>"
 <%- end -%>

data/templates/default/service/client/_client.text.erb

@@ -20,6 +20,14 @@ require "securerandom"
 <%= indent service.doc_description(transport: :grpc), "# " %>
 #
 <%- end -%>
+<%- if service.resumable_upload? -%>
+<%- upload_names = service.resumable_upload_methods.map { |upload_method| "`#{upload_method.name}`" }.join ", " -%>
+<%- upload_many = service.resumable_upload_methods.length > 1 -%>
+# <%= upload_names %> <%= upload_many ? "perform resumable uploads: each returns" : "performs a resumable upload: it returns" %> a {::Gapic::ResumableUpload} handle
+# instead of a response, and the per-call `timeout` and retry policy cover only the request that
+# creates the upload session, not the upload itself.
+#
+<%- end -%>
 class <%= service.client_name %>
   # @private
   API_VERSION = "<%= service.api_version %>".freeze
@@ -140,6 +148,16 @@ class <%= service.client_name %>
       config.universe_domain = @config.universe_domain
     end
 
+    <%- end -%>
+    <%- if service.resumable_upload? -%>
+    <%= service.resumable_upload_stub_ivar %> = <%= service.resumable_upload_stub_name_full %>.new(
+      endpoint: @config.endpoint,
+      endpoint_template: DEFAULT_ENDPOINT_TEMPLATE,
+      universe_domain: @config.universe_domain,
+      credentials: credentials,
+      logger: @config.logger
+    )
+
     <%- end -%>
     @<%= service.stub_name %> = ::Gapic::ServiceStub.new(
       <%= service.proto_service_stub_name_full %>,

data/templates/default/service/client/_config.text.erb

@@ -190,6 +190,14 @@ class Configuration
   <%- method_service.methods.each do |method| -%>
     ##
     # RPC-specific configuration for `<%= method.name %>`
+  <%- if method.resumable_upload? -%>
+    #
+    # `<%= method.name %>` performs a resumable upload, so the `timeout` and `retry_policy`
+    # configured here cover the request that creates the upload session only, not the upload
+    # itself. The whole-upload budget is the `upload_timeout:` argument of
+    # {::Gapic::ResumableUpload#start} and {::Gapic::ResumableUpload#resume}.
+    #
+  <%- end -%>
     # @return [::Gapic::Config::Method]
     #
     attr_reader :<%= method.name %>

data/templates/default/service/client/method/_def.text.erb

@@ -9,15 +9,19 @@
 #
 <%= render partial: "service/client/method/docs/response", locals: { method: method } -%>
 #
+<%- unless method.resumable_upload? -%>
 <%= render partial: "service/client/method/docs/error", locals: { method: method } -%>
 #
+<%- end -%>
 <%= render partial: "service/client/method/docs/snippets", locals: { method: method } -%>
 <%= render partial: "service/client/method/docs/samples", locals: { method: method } -%>
-def <%= method.name %> request, options = nil
+def <%= method.name %> request<%= method.resumable_upload? ? " = {}" : "" %>, options = nil
 <%= indent render(partial: "service/client/method/def/request", locals: { method: method }), 2 %>
 
 <%= indent render(partial: "service/client/method/def/options_defaults", locals: { method: method }), 2 %>
 
 <%= indent render(partial: "service/client/method/def/response", locals: { method: method }), 2 %>
+<%- unless method.resumable_upload? -%>
 <%= render partial: "service/client/method/def/rescue", locals: { method: method } -%>
+<%- end -%>
 end

data/templates/default/service/client/method/def/_options_defaults.text.erb

@@ -8,7 +8,12 @@ metadata = @config.rpcs.<%= method.name %>.metadata.to_h
 # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
 metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
   lib_name: @config.lib_name, lib_version: @config.lib_version,
+<%- if method.resumable_upload? -%>
+  gapic_version: ::<%= method.service.gem.version_name_full %>,
+  transports_version_send: [:rest]
+<%- else -%>
   gapic_version: ::<%= method.service.gem.version_name_full %>
+<%- end -%>
 metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
 metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id
 <%- if method.routing_params? && !method.client_streaming? -%>

data/templates/default/service/client/method/def/_response.text.erb

@@ -1,5 +1,7 @@
 <%- assert_locals method -%>
-<%- if method.paged? -%>
+<%- if method.resumable_upload? -%>
+<%= render partial: "service/client/method/def/response_resumable_upload", locals: { method: method } -%>
+<%- elsif method.paged? -%>
 <%= render partial: "service/client/method/def/response_paged", locals: { method: method } -%>
 <%- elsif method.rest.nonstandard_lro? -%>
 <%= render partial: "service/client/method/def/response_nonstandard_lro", locals: { method: method } -%>

data/templates/default/service/client/method/def/_response_resumable_upload.text.erb

@@ -0,0 +1,13 @@
+<%- assert_locals method -%>
+<%- error_handler = render(partial: "service/client/method/def/upload_error_handler", locals: { method: method }).strip -%>
+::Gapic::ResumableUpload.new(
+  client_stub_proc:     -> { <%= method.service.resumable_upload_stub_ivar %>.client_stub },
+  initial_request_proc: lambda {
+    <%= method.service.resumable_upload_stub_name_full %>.<%= method.rest.transcoding_helper_name %> request
+  },
+  initial_headers:      options.metadata,
+  start_retry_policy:   ::Gapic::Rest::ResumableUpload.start_retry_policy_for(options),
+  response_type:        <%= method.return_type %>,
+  method_name:          "<%= method.name %>",
+  error_handler:        <%= error_handler %>
+)

data/templates/default/service/client/method/def/_upload_error_handler.text.erb

@@ -0,0 +1,2 @@
+<%- assert_locals method -%>
+nil

data/templates/default/service/client/method/docs/_request_normal.text.erb

@@ -1,4 +1,22 @@
 <%- assert_locals method -%>
+<%- if method.resumable_upload? -%>
+# @overload <%= method.name %>(request = {}, options = nil)
+#   Pass arguments to `<%= method.name %>` via a request object, either of type
+#   {<%= method.request_type %>} or an equivalent Hash.
+#
+#   @param request [<%= method.request_type %>, ::Hash]
+#     A request object representing the call parameters. Optional: it is ignored when the returned
+#     handle is resumed rather than started, because a resumed upload targets a session the server
+#     has already created.
+#   @param options [::Gapic::CallOptions, ::Hash]
+#     Overrides for the initiation request only. The `timeout`, `retry_policy` and `metadata` set
+#     here apply to the single request that creates the upload session, not to the upload as a
+#     whole: an upload still transferring bytes an hour later has long outlived this `timeout`.
+#     To bound the whole upload, pass `upload_timeout:` to {::Gapic::ResumableUpload#start} or
+#     {::Gapic::ResumableUpload#resume}. Chunk transfers are retried by the upload protocol itself,
+#     with the defaults documented on {::Gapic::ResumableUpload}; no call option reaches them.
+#     Optional.
+<%- else -%>
 # @overload <%= method.name %>(request, options = nil)
 #   Pass arguments to `<%= method.name %>` via a request object, either of type
 #   {<%= method.request_type %>} or an equivalent Hash.
@@ -8,6 +26,7 @@
 #     parameters, or to keep all the default parameter values, pass an empty Hash.
 #   @param options [::Gapic::CallOptions, ::Hash]
 #     Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
+<%- end -%>
 <%-if method.arguments.any?-%>
 #
 <%- arg_list = method.arguments.map { |arg| "#{arg.name}: nil"}.join ", " -%>

data/templates/default/service/client/method/docs/_response.text.erb

@@ -1,6 +1,14 @@
 <%- assert_locals method -%>
+<%- if method.resumable_upload? -%>
+# @return [::Gapic::ResumableUpload]
+#   A reusable upload handle. No request is sent and no byte is read from a stream until
+#   {::Gapic::ResumableUpload#start} or {::Gapic::ResumableUpload#resume} is called on it.
+#   Upload failures, including a failed initiation request, are raised by those methods,
+#   not by this one.
+<%- else -%>
 # @yield [response, operation] Access the result along with the RPC operation
 # @yieldparam response [<%= method.doc_response_type %>]
 # @yieldparam operation [::GRPC::ActiveCall::Operation]
 #
 # @return [<%= method.doc_response_type %>]
+<%- end -%>

data/templates/default/service/rest/client/_client.text.erb

@@ -21,6 +21,14 @@ require "securerandom"
 <%= indent service.doc_description(transport: :rest), "# " %>
 #
 <%- end -%>
+<%- if service.resumable_upload? -%>
+<%- upload_names = service.resumable_upload_methods.map { |upload_method| "`#{upload_method.name}`" }.join ", " -%>
+<%- upload_many = service.resumable_upload_methods.length > 1 -%>
+# <%= upload_names %> <%= upload_many ? "perform resumable uploads: each returns" : "performs a resumable upload: it returns" %> a {::Gapic::ResumableUpload} handle
+# instead of a response, and the per-call `timeout` and retry policy cover only the request that
+# creates the upload session, not the upload itself.
+#
+<%- end -%>
 class <%= service.rest.client_name %>
   # @private
   API_VERSION = "<%= service.api_version %>".freeze
@@ -141,6 +149,16 @@ class <%= service.rest.client_name %>
       <%- end -%>
     end
 
+    <%- end -%>
+    <%- if service.resumable_upload? -%>
+    <%= service.resumable_upload_stub_ivar %> = <%= service.resumable_upload_stub_name_full %>.new(
+      endpoint: @config.endpoint,
+      endpoint_template: DEFAULT_ENDPOINT_TEMPLATE,
+      universe_domain: @config.universe_domain,
+      credentials: credentials,
+      logger: @config.logger
+    )
+
     <%- end -%>
     @<%= service.stub_name %> = <%= service.rest.service_stub_name_full %>.new(
       endpoint: @config.endpoint,

data/templates/default/service/rest/client/_config.text.erb

@@ -162,6 +162,14 @@ class Configuration
   <%- method_service.rest.methods.each do |method| -%>
     ##
     # RPC-specific configuration for `<%= method.name %>`
+  <%- if method.resumable_upload? -%>
+    #
+    # `<%= method.name %>` performs a resumable upload, so the `timeout` and `retry_policy`
+    # configured here cover the request that creates the upload session only, not the upload
+    # itself. The whole-upload budget is the `upload_timeout:` argument of
+    # {::Gapic::ResumableUpload#start} and {::Gapic::ResumableUpload#resume}.
+    #
+  <%- end -%>
     # @return [::Gapic::Config::Method]
     #
     attr_reader :<%= method.name %>

data/templates/default/service/rest/client/method/_def.text.erb

@@ -7,10 +7,12 @@
 <%= render partial: "service/rest/client/method/docs/request", locals: { method: method } -%>
 <%= render partial: "service/rest/client/method/docs/result", locals: { method: method } -%>
 #
+<%- unless method.resumable_upload? -%>
 <%= render partial: "service/rest/client/method/docs/error", locals: { method: method } -%>
 #
+<%- end -%>
 <%= render partial: "service/rest/client/method/docs/snippets", locals: { method: method } -%>
-def <%= method.name %> request, options = nil
+def <%= method.name %> request<%= method.resumable_upload? ? " = {}" : "" %>, options = nil
 <%= indent render(partial: "service/client/method/def/request", locals: { method: method }), 2 %>
 
 <%= indent render(partial: "service/rest/client/method/def/options_defaults", locals: { method: method }), 2 %>
@@ -20,5 +22,7 @@ def <%= method.name %> request, options = nil
 <%- end -%>
 
 <%= indent render(partial: "service/rest/client/method/def/response", locals: { method: method }), 2 %>
+<%- unless method.resumable_upload? -%>
 <%= render partial: "service/rest/client/method/def/rescue", locals: { method: method } -%>
+<%- end -%>
 end

data/templates/default/service/rest/client/method/def/_response.text.erb

@@ -1,5 +1,7 @@
 <%- assert_locals method -%>
-<%- if method.rest.paged? -%>
+<%- if method.resumable_upload? -%>
+<%= render partial: "service/rest/client/method/def/response_resumable_upload", locals: { method: method } -%>
+<%- elsif method.rest.paged? -%>
 <%= render partial: "service/rest/client/method/def/response_paged", locals: { method: method } -%>
 <%- elsif method.rest.nonstandard_lro? -%>
 <%= render partial: "service/rest/client/method/def/response_nonstandard_lro", locals: { method: method } -%>

data/templates/default/service/rest/client/method/def/_response_resumable_upload.text.erb

@@ -0,0 +1,13 @@
+<%- assert_locals method -%>
+<%- error_handler = render(partial: "service/rest/client/method/def/upload_error_handler", locals: { method: method }).strip -%>
+::Gapic::ResumableUpload.new(
+  client_stub_proc:     -> { <%= method.service.resumable_upload_stub_ivar %>.client_stub },
+  initial_request_proc: lambda {
+    <%= method.service.resumable_upload_stub_name_full %>.<%= method.rest.transcoding_helper_name %> request
+  },
+  initial_headers:      options.metadata,
+  start_retry_policy:   ::Gapic::Rest::ResumableUpload.start_retry_policy_for(options),
+  response_type:        <%= method.return_type %>,
+  method_name:          "<%= method.name %>",
+  error_handler:        <%= error_handler %>
+)

data/templates/default/service/rest/client/method/def/_upload_error_handler.text.erb

@@ -0,0 +1,2 @@
+<%- assert_locals method -%>
+nil

data/templates/default/service/rest/client/method/docs/_request.text.erb

@@ -1,4 +1,22 @@
 <%- assert_locals method -%>
+<%- if method.resumable_upload? -%>
+# @overload <%= method.name %>(request = {}, options = nil)
+#   Pass arguments to `<%= method.name %>` via a request object, either of type
+#   {<%= method.request_type %>} or an equivalent Hash.
+#
+#   @param request [<%= method.request_type %>, ::Hash]
+#     A request object representing the call parameters. Optional: it is ignored when the returned
+#     handle is resumed rather than started, because a resumed upload targets a session the server
+#     has already created.
+#   @param options [::Gapic::CallOptions, ::Hash]
+#     Overrides for the initiation request only. The `timeout`, `retry_policy` and `metadata` set
+#     here apply to the single request that creates the upload session, not to the upload as a
+#     whole: an upload still transferring bytes an hour later has long outlived this `timeout`.
+#     To bound the whole upload, pass `upload_timeout:` to {::Gapic::ResumableUpload#start} or
+#     {::Gapic::ResumableUpload#resume}. Chunk transfers are retried by the upload protocol itself,
+#     with the defaults documented on {::Gapic::ResumableUpload}; no call option reaches them.
+#     Optional.
+<%- else -%>
 # @overload <%= method.name %>(request, options = nil)
 #   Pass arguments to `<%= method.name %>` via a request object, either of type
 #   {<%= method.request_type %>} or an equivalent Hash.
@@ -8,6 +26,7 @@
 #     parameters, or to keep all the default parameter values, pass an empty Hash.
 #   @param options [::Gapic::CallOptions, ::Hash]
 #     Overrides the default settings for this call, e.g, timeout, retries etc. Optional.
+<%- end -%>
 <%-if method.arguments.any?-%>
 #
 <%- arg_list = method.arguments.map { |arg| "#{arg.name}: nil"}.join ", " -%>

data/templates/default/service/rest/client/method/docs/_result.text.erb

@@ -1,5 +1,11 @@
 <%- assert_locals method -%>
-<%- if method.server_streaming? -%>
+<%- if method.resumable_upload? -%>
+# @return [::Gapic::ResumableUpload]
+#   A reusable upload handle. No request is sent and no byte is read from a stream until
+#   {::Gapic::ResumableUpload#start} or {::Gapic::ResumableUpload#resume} is called on it.
+#   Upload failures, including a failed initiation request, are raised by those methods,
+#   not by this one.
+<%- elsif method.server_streaming? -%>
 # @return [::Enumerable<<%= method.rest.doc_response_type %>>]
 <%- else -%>
 # @yield [result, operation] Access the result along with the TransportOperation object

data/templates/default/service/rest/service_stub/_service_stub.text.erb

@@ -52,11 +52,11 @@ class <%= service.rest.service_stub_name %>
     stub ? @client_stub.stub_logger : @client_stub.logger
   end
 
-  <%- service.rest.methods.each do |method| -%>
+  <%- service.rest.service_stub_methods.each do |method| -%>
   <%= indent_tail render(partial: "service/rest/service_stub/method/def", locals: { method: method, service_stub_name: service.rest.service_stub_name }), 2 %>
 
   <%- end %>
-  <%- service.rest.methods.each do |method| -%>
+  <%- service.rest.service_stub_methods.each do |method| -%>
   <%= indent_tail render(partial: "service/rest/service_stub/grpc_transcoding_method/def", locals: { method: method }), 2 %>
 
   <%- end %>

data/templates/default/service/rest/service_stub/grpc_transcoding_method/_bindings.text.erb

@@ -0,0 +1,15 @@
+<%- assert_locals method -%>
+<%- method.http_bindings.each do |http_binding| -%>
+.with_bindings(
+  uri_method: :<%= http_binding.verb %>,
+  uri_template: "<%= http_binding.uri_for_transcoding %>",
+<%- if http_binding.body? -%>
+  body: "<%= http_binding.body %>",
+<%- end -%>
+  matches: [
+<%- http_binding.routing_params_transcoder_matches_strings.each do |match_str| -%>
+    <%= match_str %>
+<%- end -%>
+  ]
+)
+<%- end -%>

data/templates/default/service/rest/service_stub/grpc_transcoding_method/_def.text.erb

@@ -19,19 +19,6 @@ def self.<%= method.rest.transcoding_helper_name %> request_pb<%= boverr_str %>
   <%- end %>
   <%- assignment = method.service.rest.is_main_mixin_service? ? "||=" : "=" -%>
   transcoder <%= assignment %> Gapic::Rest::GrpcTranscoder.new
-  <%- method.http_bindings.each do |http_binding| -%>
-                                            .with_bindings(
-                                              uri_method: :<%= http_binding.verb %>,
-                                              uri_template: "<%= http_binding.uri_for_transcoding %>",
-                                            <%- if http_binding.body? -%>
-                                              body: "<%= http_binding.body %>",
-                                            <%- end -%>
-                                              matches: [
-                                            <%- http_binding.routing_params_transcoder_matches_strings.each do |match_str| -%>
-                                                <%= match_str %>
-                                            <%- end -%>
-                                              ]
-                                            )
-  <%- end %>
+<%= indent render(partial: "service/rest/service_stub/grpc_transcoding_method/bindings", locals: { method: method }), 44 %>
   transcoder.transcode request_pb
 end

data/templates/default/service/rest/test/client.text.erb

@@ -9,7 +9,7 @@ require "<%= service.rest.service_require %>"
 class <%= service.rest.client_name_full %>Test < Minitest::Test
 <%= indent render(partial: "service/rest/test/method/setup"), 2 %>
 
-<% service.rest.methods.each do |method| %>
+<% service.rest.methods.reject(&:resumable_upload?).each do |method| %>
 <%= indent render(partial: "service/rest/test/method/#{method.kind}",
                   locals: { method: method }), 2 %>
 

data/templates/default/service/resumable_upload_stub/_resumable_upload_stub.text.erb

@@ -0,0 +1,64 @@
+<%- assert_locals service -%>
+##
+# Resumable upload stub for the <%= service.name %> service.
+#
+# Owns the REST client stub the uploads are performed through, the transcoders that build their
+# initiation requests, and the credentials error that a client unable to perform REST calls has to
+# raise when an upload is attempted.
+#
+# @private
+#
+class <%= service.resumable_upload_stub_name %>
+<%- service.resumable_upload_methods.each do |method| -%>
+  # @private
+  <%= method.upload_url_prefix_const_name %> = "<%= method.upload_url_prefix %>"
+
+<%- end -%>
+  # @private
+  def initialize endpoint:, endpoint_template:, universe_domain:, credentials:, logger:
+    # These require statements are intentionally placed here to initialize
+    # the REST modules only when it's required.
+    require "gapic/rest"
+
+    # Uploads travel over REST, and credentials cannot be recovered from a gRPC channel. Rather than
+    # raise while a client is being constructed, which would break every other method on it, the
+    # error is stored and raised when an upload is actually attempted.
+    if defined?(::GRPC::Core::Channel) &&
+       (credentials.is_a?(::GRPC::Core::Channel) || credentials.is_a?(::GRPC::Core::ChannelCredentials))
+      @credentials_error = ::ArgumentError.new(
+        "Resumable uploads are performed over REST and cannot use a gRPC channel as credentials, " \
+        "because credentials cannot be recovered from a channel. Construct the client with Google " \
+        "OAuth credentials (a keyfile path, a Hash, or a Google::Auth::Credentials instance) to use " \
+        "resumable upload methods."
+      )
+      return
+    end
+
+    @client_stub = ::Gapic::Rest::ClientStub.new endpoint: endpoint,
+                                                 endpoint_template: endpoint_template,
+                                                 universe_domain: universe_domain,
+                                                 credentials: credentials,
+                                                 numeric_enums: false,
+                                                 service_name: self.class,
+                                                 raise_faraday_errors: false,
+                                                 logger: logger
+  end
+
+  ##
+  # @private
+  #
+  # The REST client stub the uploads are performed through.
+  #
+  # @return [::Gapic::Rest::ClientStub]
+  #
+  # @raise [::ArgumentError] if this client cannot perform REST calls.
+  #
+  def client_stub
+    raise @credentials_error if @credentials_error
+    @client_stub
+  end
+<%- service.resumable_upload_methods.each do |method| -%>
+
+  <%= indent_tail render(partial: "service/resumable_upload_stub/transcoding_method", locals: { method: method, service: service }), 2 %>
+<%- end -%>
+end

data/templates/default/service/resumable_upload_stub/_transcoding_method.text.erb

@@ -0,0 +1,22 @@
+<%- assert_locals method, service -%>
+##
+# @private
+#
+# GRPC transcoding helper method for the <%= method.name %> resumable upload initiation request.
+#
+# The upload itself is not transcoded: only the request that creates the upload session is, and the
+# verb is discarded because initiation is always a POST. Query string parameters are folded into the
+# URL, since the upload sends the initiation request with no separate parameters.
+#
+# @param request_pb [<%= method.request_type %>]
+#   A request object representing the call parameters. Required.
+# @return [Array(String, [String, nil])]
+#   Uri, Body
+def self.<%= method.rest.transcoding_helper_name %> request_pb
+  transcoder = ::Gapic::Rest::GrpcTranscoder.new
+<%= indent render(partial: "service/rest/service_stub/grpc_transcoding_method/bindings", locals: { method: method }), 46 %>
+  _verb, uri, query_string_params, body = transcoder.transcode request_pb
+  uri = "/#{<%= method.upload_url_prefix_const_name %>}#{uri}"
+  uri = "#{uri}?#{query_string_params.join '&'}" if query_string_params.any?
+  [uri, body]
+end

data/templates/default/service/resumable_upload_stub.text.erb

@@ -0,0 +1,6 @@
+<%- assert_locals service -%>
+<%= render partial: "service/resumable_upload_stub/resumable_upload_stub",
+           layout: "layouts/ruby",
+           locals: { service: service,
+                     namespace: service.service_name_full }
+%>

data/templates/default/service/test/client.text.erb

@@ -10,7 +10,7 @@ require "<%= service.service_require %>"
 class <%= service.client_name_full %>Test < Minitest::Test
 <%= indent render(partial: "service/test/method/setup"), 2 %>
 
-<% service.methods.each do |method| %>
+<% service.methods.reject(&:resumable_upload?).each do |method| %>
 <%= indent render(partial: "service/test/method/#{method.kind}",
                   locals: { method: method }), 2 %>
 

data/templates/default/service/test/resumable_upload.text.erb

@@ -0,0 +1,132 @@
+<%- assert_locals service -%>
+<%= render partial: "shared/header" %>
+require "helper"
+
+require "gapic/rest"
+<%- if service.generate_grpc_clients? -%>
+require "gapic/grpc/service_stub"
+<%- end -%>
+
+require "<%= service.proto_service_require %>"
+<%- if service.generate_grpc_clients? -%>
+require "<%= service.service_require %>"
+<%- end -%>
+<%- if service.generate_rest_clients? -%>
+require "<%= service.rest.service_require %>"
+<%- end -%>
+
+class <%= service.service_name_full %>::ResumableUploadTest < Minitest::Test
+  ##
+  # Stands in for the transport stub a client builds in its constructor. An upload method sends
+  # nothing, so this only has to satisfy the constructor.
+  #
+  class ClientStub
+    def endpoint
+      "endpoint.example.com"
+    end
+
+    def universe_domain
+      "example.com"
+    end
+
+    def stub_logger
+      nil
+    end
+
+    def logger
+      nil
+    end
+  end
+<%- service.resumable_upload_methods.each do |method| -%>
+<%- fields = method.fields_with_first_oneof -%>
+<%- prefix_const = "#{service.resumable_upload_stub_name_full}::#{method.upload_url_prefix_const_name}" -%>
+
+  def test_transcode_<%= method.name %>_request
+    request = <%= method.request_type %>.new
+
+    # The transcoder is stubbed so the test pins the upload-specific post-processing (prefix,
+    # query-string folding, [uri, body] shape) independently of the method's path template.
+    transcoder = Gapic::Rest::GrpcTranscoder.new
+    transcoder.stub :transcode, [:post, "/transcoded/path", ["foo=bar", "baz=qux"], "{\"body\":true}"] do
+      Gapic::Rest::GrpcTranscoder.stub :new, transcoder do
+        uri, body = <%= service.resumable_upload_stub_name_full %>.<%= method.rest.transcoding_helper_name %> request
+
+        assert_equal "/#{<%= prefix_const %>}/transcoded/path?foo=bar&baz=qux", uri
+        assert_equal "{\"body\":true}", body
+      end
+    end
+  end
+<%- if service.generate_grpc_clients? -%>
+
+  def test_<%= method.name %>
+    <%- fields.each do |field| -%>
+    <%= field.value_name %> = <%= field.default_value %>
+    <%- end -%>
+
+    client = nil
+    Gapic::ServiceStub.stub :new, ClientStub.new do
+      client = <%= service.client_name_full %>.new do |config|
+        config.credentials = :this_channel_is_insecure
+      end
+    end
+
+    upload = client.<%= method.name %> <%= method.request_type %>.new(<%= fields.map(&:as_kwarg).join ", " %>)
+
+    # The call builds a handle and sends nothing. The upload only begins on #start or #resume.
+    assert_kind_of ::Gapic::ResumableUpload, upload
+    assert_nil upload.resume_handle
+    refute upload.resumable?
+    refute upload.running?
+  end
+
+  def test_<%= method.name %>_channel_credentials
+    <%- fields.each do |field| -%>
+    <%= field.value_name %> = <%= field.default_value %>
+    <%- end -%>
+    grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
+
+    client = nil
+    Gapic::ServiceStub.stub :new, ClientStub.new do
+      client = <%= service.client_name_full %>.new do |config|
+        config.credentials = grpc_channel
+      end
+    end
+
+    upload = client.<%= method.name %> <%= method.request_type %>.new(<%= fields.map(&:as_kwarg).join ", " %>)
+
+    assert_kind_of ::Gapic::ResumableUpload, upload
+
+    # Uploads travel over REST and cannot use a channel as credentials. The error surfaces here,
+    # rather than at construction, and before the stream is touched.
+    stream = StringIO.new "resumable upload test payload"
+    assert_raises ::ArgumentError do
+      upload.start stream: stream, content_type: "application/octet-stream"
+    end
+    assert_equal 0, stream.pos
+  end
+<%- end -%>
+<%- if service.generate_rest_clients? -%>
+
+  def test_<%= method.name %>_rest
+    <%- fields.each do |field| -%>
+    <%= field.value_name %> = <%= field.default_value %>
+    <%- end -%>
+
+    client = nil
+    Gapic::Rest::ClientStub.stub :new, ClientStub.new do
+      client = <%= service.rest.client_name_full %>.new do |config|
+        config.credentials = :dummy_value
+      end
+    end
+
+    upload = client.<%= method.name %> <%= method.request_type %>.new(<%= fields.map(&:as_kwarg).join ", " %>)
+
+    # The call builds a handle and sends nothing. The upload only begins on #start or #resume.
+    assert_kind_of ::Gapic::ResumableUpload, upload
+    assert_nil upload.resume_handle
+    refute upload.resumable?
+    refute upload.running?
+  end
+<%- end -%>
+<%- end -%>
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gapic-generator
 version: !ruby/object:Gem::Version
-  version: 0.52.0
+  version: 0.53.0
 platform: ruby
 authors:
 - Ernest Landrito
@@ -150,6 +150,7 @@ files:
 - lib/gapic/model/api_metadata.rb
 - lib/gapic/model/method/http_annotation.rb
 - lib/gapic/model/method/lro.rb
+- lib/gapic/model/method/resumable_upload.rb
 - lib/gapic/model/method/routing.rb
 - lib/gapic/model/mixins.rb
 - lib/gapic/model/model_error.rb
@@ -267,7 +268,9 @@ files:
 - templates/default/service/client/method/def/_response_normal.text.erb
 - templates/default/service/client/method/def/_response_normal_lro.text.erb
 - templates/default/service/client/method/def/_response_paged.text.erb
+- templates/default/service/client/method/def/_response_resumable_upload.text.erb
 - templates/default/service/client/method/def/_routing_params.text.erb
+- templates/default/service/client/method/def/_upload_error_handler.text.erb
 - templates/default/service/client/method/docs/_error.text.erb
 - templates/default/service/client/method/docs/_request.text.erb
 - templates/default/service/client/method/docs/_request_field.text.erb
@@ -306,7 +309,9 @@ files:
 - templates/default/service/rest/client/method/def/_response_normal.text.erb
 - templates/default/service/rest/client/method/def/_response_normal_lro.text.erb
 - templates/default/service/rest/client/method/def/_response_paged.text.erb
+- templates/default/service/rest/client/method/def/_response_resumable_upload.text.erb
 - templates/default/service/rest/client/method/def/_response_server_streaming.text.erb
+- templates/default/service/rest/client/method/def/_upload_error_handler.text.erb
 - templates/default/service/rest/client/method/docs/_error.text.erb
 - templates/default/service/rest/client/method/docs/_request.text.erb
 - templates/default/service/rest/client/method/docs/_result.text.erb
@@ -316,6 +321,7 @@ files:
 - templates/default/service/rest/operations.text.erb
 - templates/default/service/rest/service_stub.text.erb
 - templates/default/service/rest/service_stub/_service_stub.text.erb
+- templates/default/service/rest/service_stub/grpc_transcoding_method/_bindings.text.erb
 - templates/default/service/rest/service_stub/grpc_transcoding_method/_def.text.erb
 - templates/default/service/rest/service_stub/grpc_transcoding_method/def/_query_string_param.text.erb
 - templates/default/service/rest/service_stub/method/_def.text.erb
@@ -327,6 +333,9 @@ files:
 - templates/default/service/rest/test/method/_normal.text.erb
 - templates/default/service/rest/test/method/_server.text.erb
 - templates/default/service/rest/test/method/_setup.text.erb
+- templates/default/service/resumable_upload_stub.text.erb
+- templates/default/service/resumable_upload_stub/_resumable_upload_stub.text.erb
+- templates/default/service/resumable_upload_stub/_transcoding_method.text.erb
 - templates/default/service/test/_resource.text.erb
 - templates/default/service/test/client.text.erb
 - templates/default/service/test/client_operations.text.erb
@@ -338,6 +347,7 @@ files:
 - templates/default/service/test/method/_normal.text.erb
 - templates/default/service/test/method/_server.text.erb
 - templates/default/service/test/method/_setup.text.erb
+- templates/default/service/test/resumable_upload.text.erb
 - templates/default/service/test/smoke.text.erb
 - templates/default/shared/_header.text.erb
 - templates/default/shared/_license.text.erb