basecamp-sdk 0.14.0 → 0.16.0

data/lib/basecamp/oauth/exchange.rb

@@ -2,16 +2,53 @@
 
 require "faraday"
 require "json"
+require "timeout"
 require "uri"
 
 module Basecamp
   module Oauth
     # Handles OAuth 2 token exchange and refresh operations.
+    #
+    # Both operations POST credentials — the authorization code and client
+    # secret, or the refresh token — to a token endpoint the caller names,
+    # which may be one that discovery's metadata chose. The POST therefore
+    # rides the same hardened transport discipline as the device flow
+    # (SPEC §16 "Token-Endpoint Transport Policy"): redirects are refused
+    # rather than followed, the whole request is wall-clock bounded, and the
+    # body reads under the shared streaming cap.
     class Exchange
-      # @param http_client [Faraday::Connection, nil] HTTP client (uses default if nil)
-      # @param timeout [Integer] Request timeout in seconds (default: 30)
-      def initialize(http_client: nil, timeout: 30)
-        @http_client = http_client || build_default_client(timeout)
+      # The redirect statuses a token endpoint response is refused for
+      # (SPEC §16 "Token-Endpoint Transport Policy") — the same set the signed
+      # download hop refuses (SPEC §14). 304 is deliberately absent: it is a
+      # cache validator, not a redirect-with-Location, and stays on the
+      # generic non-success path.
+      REDIRECT_STATUSES = [ 301, 302, 303, 307, 308 ].freeze
+
+      # Default per-request timeout in seconds — the shared credential-POST
+      # default every SDK's token and device POSTs converge on (SPEC §16).
+      DEFAULT_TIMEOUT = 30
+
+      # Cap on a token response body (1 MiB), matching the device flow's and
+      # the other SDKs' token-response bound.
+      MAX_BODY_BYTES = 1 * 1024 * 1024
+
+      # @param http_client [Faraday::Connection, nil] HTTP client. Nil selects
+      #   the headers-first default transport ({Fetcher.stream_http}); an
+      #   injected connection is refused unless its stack is verifiably
+      #   redirect-free (adapter-only), and keeps the injected-client fidelity
+      #   tier: status classification only after the (bounded) read completes,
+      #   deadline enforced wall-clock around the call.
+      # @param timeout [Numeric] Request timeout in seconds (default: 30).
+      #   Invalid values and values beyond the shared 3600 s ceiling fall back
+      #   to the default rather than disabling the bound.
+      def initialize(http_client: nil, timeout: DEFAULT_TIMEOUT)
+        # An injected connection is the caller's transport, but redirect
+        # suppression is not negotiable on a credential POST: refuse a stack
+        # that could follow (or rewrite) before any request is issued — the
+        # same guard discovery, resource, and the device flow apply.
+        Fetcher.ensure_redirects_suppressed!(http_client) if http_client
+        @http_client = http_client
+        @timeout = Fetcher.normalize_timeout(timeout, default: DEFAULT_TIMEOUT)
       end
 
       # Exchanges an authorization code for access and refresh tokens.
@@ -80,14 +117,6 @@ module Basecamp
 
       private
 
-      def build_default_client(timeout)
-        Faraday.new do |conn|
-          conn.options.timeout = timeout
-          conn.options.open_timeout = timeout
-          conn.adapter Faraday.default_adapter
-        end
-      end
-
       def validate_exchange_request!(request)
         raise OauthError.new("validation", "Token endpoint is required") if request.token_endpoint.to_s.empty?
         raise OauthError.new("validation", "Authorization code is required") if request.code.to_s.empty?
@@ -145,30 +174,128 @@ module Basecamp
       def do_token_request(token_endpoint, params)
         Basecamp::Security.require_https_unless_localhost!(token_endpoint, "token endpoint")
 
-        response = @http_client.post(token_endpoint) do |req|
-          req.headers["Content-Type"] = "application/x-www-form-urlencoded"
-          req.headers["Accept"] = "application/json"
-          req.body = URI.encode_www_form(params)
+        status, body = post_form(
+          token_endpoint, params,
+          skip_status: ->(s) { REDIRECT_STATUSES.include?(s) }
+        )
+
+        # A refused redirect is a typed verdict classified by status alone —
+        # its body (skipped above) is never a token, and the credential POST
+        # is never re-issued toward Location (SPEC §16).
+        if REDIRECT_STATUSES.include?(status)
+          raise OauthError.new(
+            "api_error",
+            "redirect #{status} on the token endpoint is not followed",
+            http_status: status
+          )
         end
 
-        parse_token_response(response)
+        parse_token_response(status, body)
       rescue Faraday::TimeoutError
         raise OauthError.new("network", "Token request timed out", retryable: true)
       rescue Faraday::Error => e
         raise OauthError.new("network", "Token request failed: #{e.message}", retryable: true)
       end
 
-      def parse_token_response(response)
-        Basecamp::Security.check_body_size!(response.body, Basecamp::Security::MAX_ERROR_BODY_BYTES, "Token")
+      # POSTs the token form and returns +[status, body]+, reading under the
+      # same bounded/streaming cap as discovery and the device flow.
+      #
+      # With no injected client the POST runs on the headers-first
+      # {Fetcher.stream_http} primitive: +skip_status+ classifies a redirect
+      # by status at HEADER time (its body is never read, even one that
+      # stalls forever), redirects are structurally never followed, and a
+      # watchdog bounds the whole request — a stalled or byte-dripped header
+      # phase included — at the timeout. An INJECTED Faraday connection keeps
+      # the Faraday path below.
+      def post_form(url, params, skip_status:)
+        if @http_client.nil?
+          Fetcher.stream_http(
+            :post, url,
+            headers: { "Content-Type" => "application/x-www-form-urlencoded", "Accept" => "application/json" },
+            form: params, timeout: @timeout, max_body_bytes: MAX_BODY_BYTES, skip_status: skip_status
+          )
+        else
+          post_form_injected(url, params, skip_status)
+        end
+      rescue Fetcher::SkipBody => e
+        # The body was intentionally not drained (a redirect's body is never a
+        # token) — classify by status upstream.
+        [ e.status, "" ]
+      rescue Fetcher::BodyTooLarge
+        raise OauthError.new("api_error", "Token response exceeds size cap")
+      rescue Fetcher::ReadDeadlineExceeded
+        # A slow-drip read is a transport timeout, not an api_error — surface
+        # as the Faraday timeout the caller's rescue classifies.
+        raise Faraday::TimeoutError, "Token request read exceeded the timeout deadline"
+      end
+
+      # Injected-client (Faraday) lane — the injected-client fidelity tier
+      # (SPEC §16): the same invariants as the default transport (suppressed
+      # redirects, bounded body, whole-request wall clock), with buffered
+      # classification. +req.options.timeout+ below bounds only each socket
+      # read and resets on every +on_data+ chunk, so a slow-drip peer could
+      # otherwise hold the credential POST open past the timeout while
+      # staying under the cap — the monotonic deadline bounds the WHOLE
+      # request, and +Timeout.timeout+ enforces it through a stalled or
+      # dripped HEADER phase, where +on_data+ (a body callback) never runs.
+      def post_form_injected(url, params, skip_status)
+        deadline = Fetcher.monotonic_now + @timeout
+        chunks, on_data = Fetcher.bounded_reader(MAX_BODY_BYTES, deadline: deadline, skip_status: skip_status)
+        # The window is the REMAINING budget, not a fresh timeout: time spent
+        # before dispatch already counts against the deadline, so the request
+        # can never run past it.
+        remaining = deadline - Fetcher.monotonic_now
+        raise Faraday::TimeoutError, "request budget exhausted before dispatch" if remaining <= 0
+
+        response = Timeout.timeout(remaining, Faraday::TimeoutError) do
+          @http_client.post(url) do |req|
+            req.headers["Content-Type"] = "application/x-www-form-urlencoded"
+            req.headers["Accept"] = "application/json"
+            req.body = URI.encode_www_form(params)
+            req.options.timeout = @timeout
+            req.options.open_timeout = @timeout
+            req.options.on_data = on_data
+          end
+        end
+
+        # Status-first backstop on the completed response: the +on_data+
+        # SkipBody fast-path only fires when the adapter streams AND passes
+        # +env+ (Faraday >= 2.5). A buffered adapter that ignores +on_data+,
+        # an older Faraday (2.0–2.4) that omits +env+, or a header-only
+        # response reaches here with the redirect body un-skipped — re-apply
+        # +skip_status+ to the final status so a redirect is classified by
+        # status for every client shape, never buffered into a size-cap error.
+        # A definitive completed status outranks the deadline re-check below;
+        # everything else completing past the deadline is refused as the same
+        # transport-shaped timeout (Timeout.timeout's interrupt can land late).
+        if skip_status.call(response.status)
+          [ response.status, "" ]
+        elsif Fetcher.monotonic_now > deadline
+          raise Faraday::TimeoutError, "response completed after the deadline"
+        else
+          body =
+            if chunks.empty?
+              raw = response.body.to_s
+              raise Fetcher::BodyTooLarge if raw.bytesize > MAX_BODY_BYTES
+
+              raw
+            else
+              chunks.join
+            end
+
+          [ response.status, body.dup.force_encoding(Encoding::UTF_8) ]
+        end
+      end
 
-        data = JSON.parse(response.body)
+      def parse_token_response(status, body)
+        data = JSON.parse(body)
 
-        handle_error_response(response.status, data) unless response.success?
+        handle_error_response(status, data) unless (200..299).cover?(status)
 
         unless data["access_token"].is_a?(String) && !data["access_token"].empty?
           raise OauthError.new(
             "api_error", "Token response missing or non-string access_token",
-            http_status: response.status
+            http_status: status
           )
         end
 
@@ -179,7 +306,7 @@ module Basecamp
           raise OauthError.new(
             "api_error",
             "Token response resource must be a non-empty string when present",
-            http_status: response.status
+            http_status: status
           )
         end
 
@@ -191,7 +318,7 @@ module Basecamp
           raise OauthError.new(
             "api_error",
             "Token response token_type must be a non-empty string when present",
-            http_status: response.status
+            http_status: status
           )
         end
 
@@ -213,7 +340,7 @@ module Basecamp
         raise OauthError.new(
           "api_error",
           "Failed to parse token response",
-          http_status: response.status
+          http_status: status
         ), cause: nil
       end
 

data/lib/basecamp/oauth/fetcher.rb

@@ -239,7 +239,7 @@ module Basecamp
 
         raise OauthError.new(
           "validation",
-          "Injected OAuth discovery client must carry only an adapter (no middleware); " \
+          "Injected OAuth client must carry only an adapter (no middleware); " \
           "found #{offending.klass.name}. Redirects are suppressed for SSRF safety, so a " \
           "connection whose middleware stack cannot be verified redirect-free is refused"
         )

data/lib/basecamp/oauth_token_provider.rb

@@ -16,6 +16,22 @@ module Basecamp
     # Token endpoint for Basecamp OAuth
     TOKEN_URL = "https://launchpad.37signals.com/authorization/token"
 
+    # The redirect statuses a token endpoint response is refused for
+    # (SPEC §16 "Token-Endpoint Transport Policy") — the refresh POST carries
+    # the refresh token and client secret, and a redirect must surface as a
+    # typed fault rather than re-issue those credentials toward Location.
+    # 304 stays on the generic non-success path (a cache validator, not a
+    # redirect-with-Location).
+    REDIRECT_STATUSES = [ 301, 302, 303, 307, 308 ].freeze
+
+    # Whole-request bound in seconds for the refresh POST — the shared
+    # credential-POST default (SPEC §16). Enforced as socket timeouts AND a
+    # monotonic wall-clock deadline by the transport below.
+    REFRESH_TIMEOUT = 30
+
+    # Cap on a refresh response body (1 MiB), matching the exchange path.
+    MAX_RESPONSE_BYTES = 1 * 1024 * 1024
+
     # @return [String, nil] the current refresh token
     attr_reader :refresh_token
 
@@ -77,30 +93,51 @@ module Basecamp
         perform_refresh if expired? && refreshable?
       end
 
+      # The refresh POST runs on the headers-first {Oauth::Fetcher.stream_http}
+      # primitive — the same transport as the exchange and device paths — so it
+      # gets the full SPEC §16 discipline rather than a bare Faraday.post:
+      # redirects structurally never followed and classified at header time,
+      # socket timeouts plus a monotonic whole-request watchdog (a slow-drip
+      # peer cannot hold the refresh open past REFRESH_TIMEOUT), and a bounded
+      # streaming body read.
       def perform_refresh
         require "faraday"
         require "json"
-        require "uri"
-
-        response = Faraday.post(TOKEN_URL) do |req|
-          req.headers["Content-Type"] = "application/x-www-form-urlencoded"
-          req.body = URI.encode_www_form(
-            type: "refresh",
-            refresh_token: @refresh_token,
-            client_id: @client_id,
-            client_secret: @client_secret
-          )
-        end
 
-        raise AuthError.new("Token refresh failed: #{response.status}") unless response.success?
+        status, body = Oauth::Fetcher.stream_http(
+          :post, TOKEN_URL,
+          headers: { "Content-Type" => "application/x-www-form-urlencoded" },
+          form: {
+            "type" => "refresh",
+            "refresh_token" => @refresh_token,
+            "client_id" => @client_id,
+            "client_secret" => @client_secret
+          },
+          timeout: REFRESH_TIMEOUT,
+          max_body_bytes: MAX_RESPONSE_BYTES,
+          skip_status: ->(s) { REDIRECT_STATUSES.include?(s) }
+        )
+
+        # A refused redirect is a typed api fault carrying the real status —
+        # not the generic AuthError below, which would imply the credentials
+        # were judged and rejected when no such judgement happened.
+        if REDIRECT_STATUSES.include?(status)
+          raise ApiError.new("redirect #{status} on the token endpoint is not followed", http_status: status)
+        end
+        raise AuthError.new("Token refresh failed: #{status}") unless (200..299).cover?(status)
 
-        data = JSON.parse(response.body)
+        data = JSON.parse(body)
         @access_token = data["access_token"]
         @expires_at = Time.now + data["expires_in"].to_i if data["expires_in"]
 
         @on_refresh&.call(@access_token, @refresh_token, @expires_at)
 
         true
+      rescue Oauth::Fetcher::BodyTooLarge
+        raise ApiError.new("Token refresh response exceeds size cap")
+      rescue Oauth::Fetcher::ReadDeadlineExceeded => e
+        # A slow-drip read past the deadline is a transport timeout.
+        raise NetworkError.new("Token refresh network error", cause: e)
       rescue Faraday::Error => e
         raise NetworkError.new("Token refresh network error", cause: e)
       end

data/lib/basecamp/people_confirmation_required_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Basecamp
+  # Raised when a template copy requires confirmation before granting project access.
+  class PeopleConfirmationRequiredError < ValidationError
+    # @return [Array<Basecamp::Types::TemplateLibraryConfirmationPerson>]
+    attr_reader :people
+
+    def initialize(message, people:, hint: nil, http_status: 422, field_errors: nil)
+      super(message, hint: hint, http_status: http_status, field_errors: field_errors)
+      @people = people
+    end
+  end
+end

data/lib/basecamp/rate_limit_error.rb

@@ -3,8 +3,10 @@
 module Basecamp
   # Raised when rate limited (429).
   class RateLimitError < Error
-    def initialize(retry_after: nil, cause: nil)
-      hint = retry_after ? "Try again in #{retry_after} seconds" : "Please slow down requests"
+    def initialize(retry_after: nil, hint: nil, cause: nil)
+      # A concrete Retry-After beats a body-derived hint; the class default
+      # fills in when neither is present.
+      hint = retry_after ? "Try again in #{retry_after} seconds" : (hint || "Please slow down requests")
       super(
         code: ErrorCode::RATE_LIMIT,
         message: "Rate limit exceeded",

data/lib/basecamp/security.rb

@@ -32,6 +32,26 @@ module Basecamp
       raise UsageError.new("Invalid #{label}: #{url}")
     end
 
+    # Renders a URL for hooks as origin+path only (SPEC section 9): no
+    # userinfo, query or fragment. The download flow's hop-1 URL can carry a
+    # signed credential in its query; the wire request keeps the whole URL. A
+    # URL with no complete origin renders as the fixed token, never as any of
+    # its own text.
+    # @param url [String]
+    # @return [String]
+    def self.display_url(url)
+      uri = URI.parse(url)
+      return "unparsable" if uri.scheme.nil? || uri.host.nil? || uri.host.empty?
+
+      uri.password = nil
+      uri.user = nil
+      uri.query = nil
+      uri.fragment = nil
+      uri.to_s
+    rescue URI::Error
+      "unparsable"
+    end
+
     def self.same_origin?(a, b)
       ua = URI.parse(a)
       ub = URI.parse(b)
@@ -39,13 +59,19 @@ module Basecamp
 
       ua.scheme.downcase == ub.scheme.downcase &&
         normalize_host(ua) == normalize_host(ub)
-    rescue URI::InvalidURIError
+    rescue URI::Error
+      # URI::Error, not just InvalidURIError: URI.parse("mailto:") raises
+      # URI::InvalidComponentError (URI::MailTo demands an opaque part), and a
+      # scheme-only URL must be refused, not a crash.
       false
     end
 
     def self.resolve_url(base, target)
       URI.join(base, target).to_s
-    rescue URI::InvalidURIError
+    rescue URI::Error
+      # URI::Error, not just InvalidURIError: URI.join raises
+      # URI::InvalidComponentError on a scheme-only target ("mailto:"),
+      # reachable from a poisoned Link header or Location redirect.
       target
     end
 

data/lib/basecamp/services/authorization_service.rb

@@ -10,9 +10,11 @@ module Basecamp
     # document (+app/views/api/authorizations/show.json.jbuilder+), which is not
     # Launchpad's: it carries +identity.id+ and nothing else of the identity, no
     # +product+ or +app_href+ on accounts, an RFC 8707 +resource+ indicator
-    # instead, a top-level +scope+ for BC3-issued tokens, and +expires_at+ as
-    # integer epoch seconds rather than ISO-8601. Only +identity.id+,
-    # +accounts[].id+, +accounts[].name+ and +accounts[].href+ are common to both.
+    # instead, and a top-level +scope+ for BC3-issued tokens. Only +identity.id+,
+    # +accounts[].id+, +accounts[].name+, +accounts[].href+ and +expires_at+ are
+    # common to both; +expires_at+ is an ISO-8601 string from either issuer
+    # (integer epoch seconds from bc3 before bc3 #12646 — passed through
+    # verbatim either way).
     #
     # @example Get authorization info
     #   auth = client.authorization.get

data/lib/basecamp/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Basecamp
-  VERSION = "0.14.0"
-  API_VERSION = "2026-08-05"
+  VERSION = "0.16.0"
+  API_VERSION = "2026-09-02"
 end

data/lib/basecamp.rb

@@ -117,31 +117,43 @@ module Basecamp
   # @param retry_after [Integer, nil] Retry-After header value
   # @return [Error]
   def self.error_from_response(status, body = nil, retry_after: nil)
-    message = parse_error_message(body) || "Request failed"
+    # SPEC §6 step 3: a body's error_description becomes the hint. Step 5:
+    # with no body message, the else arm falls back (via from_status) to the
+    # fixed code-bearing phrase, never a reason phrase.
+    hint = parse_error_hint(body)
+    server_message = parse_error_message(body)
+    message = server_message || "Request failed"
 
     case status
     when 400, 422
       field_errors = parse_field_errors(body)
-      message = Security.truncate(compose_validation_message(parse_error_message(body), field_errors) || "Request failed")
-      ValidationError.new(message, http_status: status, field_errors: field_errors)
+      message = Security.truncate(compose_validation_message(server_message, field_errors) || "Request failed")
+      people = status == 422 ? parse_template_library_confirmation_people(body) : nil
+      if people
+        PeopleConfirmationRequiredError.new(
+          message, people: people, hint: hint, http_status: status, field_errors: field_errors
+        )
+      else
+        ValidationError.new(message, hint: hint, http_status: status, field_errors: field_errors)
+      end
     when 401
-      AuthError.new(message)
+      AuthError.new(message, hint: hint)
     when 403
-      ForbiddenError.new(message)
+      ForbiddenError.new(message, hint: hint)
     when 404
-      NotFoundError.new(message: message)
+      NotFoundError.new(message: message, hint: hint)
     when 429
-      RateLimitError.new(retry_after: retry_after)
+      RateLimitError.new(retry_after: retry_after, hint: hint)
     when 507
       # Decided before the 5xx arms: a 507 is an account limit, not a
       # transient server failure, and no retry can satisfy it.
-      LimitExceededError.new(Security.truncate(message))
+      LimitExceededError.new(Security.truncate(message), hint: hint)
     when 500
-      ApiError.new("Server error (500)", http_status: 500, retryable: true)
+      ApiError.new("Server error (500)", http_status: 500, retryable: true, hint: hint)
     when 502, 503, 504
-      ApiError.new("Gateway error (#{status})", http_status: status, retryable: true)
+      ApiError.new("Gateway error (#{status})", http_status: status, retryable: true, hint: hint)
     else
-      ApiError.from_status(status, message)
+      ApiError.from_status(status, server_message, hint: hint)
     end
   end
 
@@ -180,6 +192,46 @@ module Basecamp
     nil
   end
 
+  # Parses the SPEC section 6 step-3 hint from a response body: the
+  # "error_description" key, used only when its value is a non-empty String,
+  # truncated like the message.
+  # @param body [String, nil]
+  # @return [String, nil]
+  def self.parse_error_hint(body)
+    return nil if body.nil? || body.empty?
+
+    Security.check_body_size!(body, Security::MAX_ERROR_BODY_BYTES, "Error")
+
+    data = JSON.parse(body)
+    hint = data.is_a?(Hash) ? data["error_description"] : nil
+    hint.is_a?(String) && !hint.empty? ? Security.truncate(hint) : nil
+  rescue JSON::ParserError, ApiError
+    nil
+  end
+
+  # Extracts the people whose destination-project access requires confirmation.
+  # @param body [String, nil]
+  # @return [Array<Basecamp::Types::TemplateLibraryConfirmationPerson>, nil]
+  def self.parse_template_library_confirmation_people(body)
+    return nil if body.nil? || body.empty?
+
+    Security.check_body_size!(body, Security::MAX_ERROR_BODY_BYTES, "Error")
+    data = JSON.parse(body)
+    people = data.is_a?(Hash) ? data["people"] : nil
+    return nil unless people.is_a?(Array) && !people.empty?
+
+    valid = people.all? do |person|
+      person.is_a?(Hash) && person["id"].is_a?(Integer) && person["id"].positive? &&
+        person["name"].is_a?(String) && !person["name"].empty? &&
+        person["avatar_url"].is_a?(String) && !person["avatar_url"].empty?
+    end
+    return nil unless valid
+
+    people.map { |person| Types::TemplateLibraryConfirmationPerson.new(person) }
+  rescue JSON::ParserError, ApiError
+    nil
+  end
+
   # Extracts the field-keyed validation errors map from a response body — the
   # Rails RecordInvalid rendering {"errors" => {"field" => ["msg", ...]}}.
   # Entries whose value is not an array are skipped, non-string elements are

data/scripts/generate-services.rb

@@ -73,7 +73,7 @@ class ServiceGenerator
     },
     'Automation' => {
       'Tools' => %w[GetTool UpdateTool DeleteTool CreateTool EnableTool DisableTool RepositionTool],
-      'Recordings' => %w[ArchiveRecording UnarchiveRecording TrashRecording ListRecordings],
+      'Recordings' => %w[ArchiveRecording UnarchiveRecording TrashRecording ListRecordings SpotlightRecording UnspotlightRecording],
       'Webhooks' => %w[ListWebhooks CreateWebhook GetWebhook UpdateWebhook DeleteWebhook],
       'Events' => %w[ListEvents],
       'Lineup' => %w[CreateLineupMarker UpdateLineupMarker DeleteLineupMarker],
@@ -81,6 +81,7 @@ class ServiceGenerator
       'Templates' => %w[
         ListTemplates CreateTemplate GetTemplate UpdateTemplate
         DeleteTemplate CreateProjectFromTemplate GetProjectConstruction
+        GetTemplateLibrary CreateTemplateLibraryCopy GetTemplateLibraryCopy
       ],
       'Checkins' => %w[
         GetQuestionnaire ListQuestions CreateQuestion GetQuestion
@@ -139,6 +140,8 @@ class ServiceGenerator
 
   # Method name overrides
   METHOD_NAME_OVERRIDES = {
+    'SpotlightRecording' => 'spotlight',
+    'UnspotlightRecording' => 'unspotlight',
     'GetMyProfile' => 'my_profile',
     'GetTodolistOrGroup' => 'get',
     # The plain `update` name belongs to the merge-safe composite; the raw
@@ -175,6 +178,9 @@ class ServiceGenerator
     'Search' => 'search',
     'CreateProjectFromTemplate' => 'create_project',
     'GetProjectConstruction' => 'get_construction',
+    'GetTemplateLibrary' => 'get_library',
+    'CreateTemplateLibraryCopy' => 'create_library_copy',
+    'GetTemplateLibraryCopy' => 'get_library_copy',
     'GetRecordingTimesheet' => 'for_recording',
     'GetProjectTimesheet' => 'for_project',
     'GetTimesheetReport' => 'report',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: basecamp-sdk
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Basecamp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-12 00:00:00.000000000 Z
+date: 2026-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -184,6 +184,7 @@ files:
 - lib/basecamp/generated/services/base_service.rb
 - lib/basecamp/generated/services/bookmarks_service.rb
 - lib/basecamp/generated/services/boosts_service.rb
+- lib/basecamp/generated/services/bubble_ups_service.rb
 - lib/basecamp/generated/services/calendars_service.rb
 - lib/basecamp/generated/services/campfires_service.rb
 - lib/basecamp/generated/services/card_columns_service.rb
@@ -262,6 +263,7 @@ files:
 - lib/basecamp/oauth_token_provider.rb
 - lib/basecamp/operation_info.rb
 - lib/basecamp/operation_result.rb
+- lib/basecamp/people_confirmation_required_error.rb
 - lib/basecamp/rate_limit_error.rb
 - lib/basecamp/request_info.rb
 - lib/basecamp/request_result.rb