basecamp-sdk 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6c1f02712a441b2b7772199b8029904b0c254be6c9b687a94a8d957f7d8a066
-  data.tar.gz: f0750c8e75561aaa908630440f0b2c4276a54abb653418361cc4363883497d9a
+  metadata.gz: 67cf91504a5aadff973463d83b4a4de98aa4ad35e2dd7d0d4e5f4f26021e8423
+  data.tar.gz: 88eacbb6628831a01e6a9cb56503618377ffec4a85ad85d5a514b025ff53dd2a
 SHA512:
-  metadata.gz: a7d6ecde9f18d17b9baadc7b827b6d396c0f6e63ab304d93800ee2e35f3803af9d668965b5d5885a408d926e780700f7fe0320d68375924a6647cce2462eee20
-  data.tar.gz: a445a4123c2ebf596026035d347dbe99883b207a650003d2651f0dbc77eed9c0f4634703555e17af674aca87e015fdbe17f38a40e9370deff1b73a42cec6d042
+  metadata.gz: 8cede9f49e112c50b65d7c7c4901f442cba400211bfe4676a9af95a95ac4ca5da1a1477c529f72456745a0f8423b766162c151135b89a2c52ce1abbacb9eb17f
+  data.tar.gz: 695198c7697799719f0d66657463ed8ad76739bcd3bbe11877ad0a16d1fdd6b20602e2d6efa623c9d6e05a2b78ef5528e346ebec5975dd1697e5379e96b1e640

data/lib/basecamp/api_error.rb

@@ -17,11 +17,12 @@ module Basecamp
     # Creates an ApiError from an HTTP status code.
     # @param status [Integer] HTTP status code
     # @param message [String, nil] optional error message
+    # @param hint [String, nil] optional hint (SPEC section 6 step 3)
     # @return [ApiError]
-    def self.from_status(status, message = nil)
+    def self.from_status(status, message = nil, hint: nil)
       message ||= "Request failed (HTTP #{status})"
       retryable = status >= 500 && status < 600
-      new(message, http_status: status, retryable: retryable)
+      new(message, http_status: status, hint: hint, retryable: retryable)
     end
   end
 end

data/lib/basecamp/client.rb

@@ -507,6 +507,11 @@ module Basecamp
       service(:bookmarks) { Services::BookmarksService.new(self) }
     end
 
+    # @return [Services::BubbleUpsService]
+    def bubble_ups
+      service(:bubble_ups) { Services::BubbleUpsService.new(self) }
+    end
+
     # @return [Services::FoldersService]
     def folders
       service(:folders) { Services::FoldersService.new(self) }
@@ -635,7 +640,16 @@ module Basecamp
         nil
       end
       unless uri.is_a?(URI::HTTP) && uri.host && !uri.host.empty?
-        raise ApiError.new("redirect to undialable download URL: #{Security.truncate(url)}")
+        # SPEC §9: the signed URL is a credential — render its origin alone,
+        # projected from the parse, or the fixed token when no complete origin
+        # exists. Truncating the whole URL kept a short query intact.
+        origin = if uri&.scheme && uri&.host && !uri.host.empty?
+          port = uri.port && uri.port != uri.default_port ? ":#{uri.port}" : ""
+          "#{uri.scheme}://#{uri.host}#{port}"
+        else
+          "unparsable"
+        end
+        raise ApiError.new("redirect to undialable download URL: #{origin}")
       end
 
       http_client = Net::HTTP.new(uri.host, uri.port)
@@ -652,8 +666,12 @@ module Basecamp
         # Redirect Policy"). Stated here so a move to a following client
         # (Faraday, Net::HTTP.get_response's callers) has to argue with it.
         response = http_client.request(request)
-      rescue StandardError => e
-        raise NetworkError.new("Download failed: #{e.message}", cause: e)
+      rescue StandardError
+        # SPEC §9: the transport error renders the signed URL, so neither its
+        # message nor the exception itself survives. cause: nil at the raise
+        # site — MRI sets the built-in cause at raise time past the class's
+        # stored cause: keyword (same pattern as oauth/exchange.rb).
+        raise NetworkError.new("Download failed"), cause: nil
       end
 
       # The exact set hop 1 dispatches on, not Net::HTTPRedirection — that

data/lib/basecamp/generated/metadata.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://basecamp.com/schemas/sdk-metadata.json",
   "version": "1.0.0",
-  "generated": "2026-08-12T19:58:36Z",
+  "generated": "2026-09-03T02:27:35Z",
   "operations": {
     "GetAccount": {
       "retry": {
@@ -1576,6 +1576,17 @@
         "maxPageSize": 50
       }
     },
+    "ListRecentProjects": {
+      "retry": {
+        "maxAttempts": 3,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      }
+    },
     "MarkAsRead": {
       "retry": {
         "maxAttempts": 2,
@@ -1806,6 +1817,20 @@
         "natural": true
       }
     },
+    "RecordProjectVisit": {
+      "retry": {
+        "maxAttempts": 3,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      },
+      "idempotent": {
+        "natural": true
+      }
+    },
     "UnarchiveProject": {
       "retry": {
         "maxAttempts": 3,
@@ -2144,6 +2169,34 @@
         ]
       }
     },
+    "CreateBubbleUp": {
+      "retry": {
+        "maxAttempts": 3,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      },
+      "idempotent": {
+        "natural": true
+      }
+    },
+    "DeleteBubbleUp": {
+      "retry": {
+        "maxAttempts": 3,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      },
+      "idempotent": {
+        "natural": true
+      }
+    },
     "SetClientVisibility": {
       "retry": {
         "maxAttempts": 3,
@@ -2228,6 +2281,34 @@
         ]
       }
     },
+    "SpotlightRecording": {
+      "retry": {
+        "maxAttempts": 3,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      },
+      "idempotent": {
+        "natural": true
+      }
+    },
+    "UnspotlightRecording": {
+      "retry": {
+        "maxAttempts": 3,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      },
+      "idempotent": {
+        "natural": true
+      }
+    },
     "UnarchiveRecording": {
       "retry": {
         "maxAttempts": 3,
@@ -2668,6 +2749,39 @@
         "natural": true
       }
     },
+    "GetTemplateLibrary": {
+      "retry": {
+        "maxAttempts": 3,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      }
+    },
+    "CreateTemplateLibraryCopy": {
+      "retry": {
+        "maxAttempts": 2,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      }
+    },
+    "GetTemplateLibraryCopy": {
+      "retry": {
+        "maxAttempts": 3,
+        "baseDelayMs": 1000,
+        "backoff": "exponential",
+        "retryOn": [
+          429,
+          503
+        ]
+      }
+    },
     "ListTemplates": {
       "retry": {
         "maxAttempts": 3,

data/lib/basecamp/generated/services/bubble_ups_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Basecamp
+  module Services
+    # Service for BubbleUps operations
+    #
+    # @generated from OpenAPI spec
+    class BubbleUpsService < BaseService
+
+      # Bubble up a recording for the current user, resurfacing it in the current
+      # @param recording_id [Integer] recording id ID
+      # @param at [String, nil] Timing for the bubble-up. `"now"` bubbles up immediately; a scheduling
+      #   keyword (`"today"`, `"tomorrow"`, `"weekend"`, `"next_week"`) or an ISO8601
+      #   date (e.g. `"2026-09-10"`) schedules it to resurface later. bc3 requires a
+      #   value — omitting `at` errors server-side (`Date.iso8601(nil)`) — so send
+      #   `"now"` for the immediate case.
+      # @return [void]
+      def create_bubble_up(recording_id:, at: nil)
+        with_operation(service: "bubbleups", operation: "create_bubble_up", is_mutation: true, resource_id: recording_id) do
+          http_post("/recordings/#{recording_id}/bubble_up.json", body: compact_params(at: at))
+          nil
+        end
+      end
+
+      # Remove the current user's bubble-up from a recording (returns 204 No Content).
+      # @param recording_id [Integer] recording id ID
+      # @return [void]
+      def delete_bubble_up(recording_id:)
+        with_operation(service: "bubbleups", operation: "delete_bubble_up", is_mutation: true, resource_id: recording_id) do
+          http_delete("/recordings/#{recording_id}/bubble_up.json")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/basecamp/generated/services/projects_service.rb

@@ -7,6 +7,14 @@ module Basecamp
     # @generated from OpenAPI spec
     class ProjectsService < BaseService
 
+      # List the projects the current user has most recently visited, most recent visit first.
+      # @return [Array<Hash>] response data
+      def list_recent_projects()
+        with_operation(service: "projects", operation: "list_recent_projects", is_mutation: false) do
+          http_get("/my/recent_projects.json", operation: "ListRecentProjects").json
+        end
+      end
+
       # List projects (active by default; optionally archived/trashed)
       # @param status [String, nil] active|archived|trashed
       # @param page [Integer, nil] Page number for paginating through results. Defaults to 1. A positive value selects exactly that page, not a starting offset; see SPEC section 8.
@@ -61,6 +69,16 @@ module Basecamp
         end
       end
 
+      # Record that the current user visited a project, moving it to the front of ListRecentProjects (returns 204 No Content).
+      # @param project_id [Integer] project id ID
+      # @return [void]
+      def record_project_visit(project_id:)
+        with_operation(service: "projects", operation: "record_project_visit", is_mutation: true, project_id: project_id) do
+          http_post("/projects/#{project_id}/recent_visit.json")
+          nil
+        end
+      end
+
       # Restore a project to active status from trash as well as from the archive (returns 204 No Content).
       # @param project_id [Integer] project id ID
       # @return [void]

data/lib/basecamp/generated/services/recordings_service.rb

@@ -23,6 +23,25 @@ module Basecamp
         end
       end
 
+      # Put a recording's card in the spotlight area on its project or template home page.
+      # @param recording_id [Integer] recording id ID
+      # @return [Hash] response data
+      def spotlight(recording_id:)
+        with_operation(service: "recordings", operation: "spotlight", is_mutation: true, resource_id: recording_id) do
+          http_post("/recordings/#{recording_id}/spotlight.json").json
+        end
+      end
+
+      # Remove a recording from the spotlight area.
+      # @param recording_id [Integer] recording id ID
+      # @return [void]
+      def unspotlight(recording_id:)
+        with_operation(service: "recordings", operation: "unspotlight", is_mutation: true, resource_id: recording_id) do
+          http_delete("/recordings/#{recording_id}/spotlight.json")
+          nil
+        end
+      end
+
       # Unarchive a recording (restore to active status)
       # @param recording_id [Integer] recording id ID
       # @return [void]

data/lib/basecamp/generated/services/templates_service.rb

@@ -7,6 +7,34 @@ module Basecamp
     # @generated from OpenAPI spec
     class TemplatesService < BaseService
 
+      # Get the account's to-do list template library
+      # @return [Hash] response data
+      def get_library()
+        with_operation(service: "templates", operation: "get_library", is_mutation: false) do
+          http_get("/template_library.json", operation: "GetTemplateLibrary").json
+        end
+      end
+
+      # Start copying a to-do list template into a project
+      # @param template_recording_id [Integer] template recording id
+      # @param destination_parent_id [Integer] destination parent id
+      # @param adding_people_confirmed [Boolean, nil] Confirm granting destination-project access to people referenced by the template.
+      # @return [Hash] response data
+      def create_library_copy(template_recording_id:, destination_parent_id:, adding_people_confirmed: nil)
+        with_operation(service: "templates", operation: "create_library_copy", is_mutation: true) do
+          http_post("/template_library/copies.json", body: compact_params(template_recording_id: template_recording_id, destination_parent_id: destination_parent_id, adding_people_confirmed: adding_people_confirmed)).json
+        end
+      end
+
+      # Get the current status of a to-do list template copy
+      # @param copy_id [Integer] copy id ID
+      # @return [Hash] response data
+      def get_library_copy(copy_id:)
+        with_operation(service: "templates", operation: "get_library_copy", is_mutation: false, resource_id: copy_id) do
+          http_get("/template_library/copies/#{copy_id}", operation: "GetTemplateLibraryCopy").json
+        end
+      end
+
       # List all templates visible to the current user
       # @param status [String, nil] active|archived|trashed
       # @param page [Integer, nil] Page number for paginating through results. Defaults to 1. A positive value selects exactly that page, not a starting offset; see SPEC section 8.

data/lib/basecamp/generated/types.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Auto-generated from OpenAPI spec. Do not edit manually.
-# Generated: 2026-08-12T19:58:36Z
+# Generated: 2026-09-03T02:27:36Z
 
 require "json"
 require "time"
@@ -3169,7 +3169,7 @@ module Basecamp
       include TypeHelpers
       # @!attribute [rw] clientside
       #   @deprecated This shape is deprecated since 2024-01: Use Client Visibility feature instead
-      attr_accessor :app_url, :created_at, :id, :name, :status, :updated_at, :url, :bookmark_url, :bookmarked, :client_company, :clients_enabled, :clientside, :description, :dock, :end_date, :purpose, :start_date
+      attr_accessor :app_url, :created_at, :id, :name, :status, :updated_at, :url, :bookmark_url, :bookmarked, :client_company, :clients_enabled, :clientside, :description, :dock, :end_date, :purpose, :star_url, :starred, :start_date
 
       # @return [Array<Symbol>]
       def self.required_fields
@@ -3193,6 +3193,8 @@ module Basecamp
         @dock = parse_array(data["dock"], "DockItem")
         @end_date = data["end_date"]
         @purpose = data["purpose"]
+        @star_url = data["star_url"]
+        @starred = parse_boolean(data["starred"])
         @start_date = data["start_date"]
       end
 
@@ -3214,6 +3216,8 @@ module Basecamp
           "dock" => @dock,
           "end_date" => @end_date,
           "purpose" => @purpose,
+          "star_url" => @star_url,
+          "starred" => @starred,
           "start_date" => @start_date,
         }.compact
       end
@@ -4289,6 +4293,99 @@ module Basecamp
       end
     end
 
+    # TemplateLibrary
+    class TemplateLibrary
+      include TypeHelpers
+      attr_accessor :bucket, :todolists, :todoset
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[bucket todolists todoset].freeze
+      end
+
+      def initialize(data = {})
+        @bucket = parse_type(data["bucket"], "RecordingBucket")
+        @todolists = parse_array(data["todolists"], "Todolist")
+        @todoset = parse_type(data["todoset"], "RecordingParent")
+      end
+
+      def to_h
+        {
+          "bucket" => @bucket,
+          "todolists" => @todolists,
+          "todoset" => @todoset,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
+    # TemplateLibraryConfirmationPerson
+    class TemplateLibraryConfirmationPerson
+      include TypeHelpers
+      attr_accessor :avatar_url, :id, :name
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[avatar_url id name].freeze
+      end
+
+      def initialize(data = {})
+        @avatar_url = data["avatar_url"]
+        @id = parse_integer(data["id"])
+        @name = data["name"]
+      end
+
+      def to_h
+        {
+          "avatar_url" => @avatar_url,
+          "id" => @id,
+          "name" => @name,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
+    # TemplateLibraryCopy
+    class TemplateLibraryCopy
+      include TypeHelpers
+      attr_accessor :destination_parent_id, :id, :source_recording_id, :status, :url, :destination_todolist
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[destination_parent_id id source_recording_id status url].freeze
+      end
+
+      def initialize(data = {})
+        @destination_parent_id = parse_integer(data["destination_parent_id"])
+        @id = parse_integer(data["id"])
+        @source_recording_id = parse_integer(data["source_recording_id"])
+        @status = data["status"]
+        @url = data["url"]
+        @destination_todolist = parse_type(data["destination_todolist"], "Todolist")
+      end
+
+      def to_h
+        {
+          "destination_parent_id" => @destination_parent_id,
+          "id" => @id,
+          "source_recording_id" => @source_recording_id,
+          "status" => @status,
+          "url" => @url,
+          "destination_todolist" => @destination_todolist,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
     # TimelineAttachment
     class TimelineAttachment
       include TypeHelpers

data/lib/basecamp/http.rb

@@ -176,7 +176,11 @@ module Basecamp
     # @param url [String] absolute URL
     # @return [Response]
     def get_download(url)
-      request_with_retry(:get, url, retry_on: DOWNLOAD_RETRY_ON, accept: nil)
+      # download: true projects this flow's hooks and transport errors (SPEC
+      # §9): the caller's URL can smuggle a signed query through the rewrite
+      # into hop 1, and a transport error renders the URL it failed on. The
+      # wire request keeps the query; only the renderings are projected.
+      request_with_retry(:get, url, retry_on: DOWNLOAD_RETRY_ON, accept: nil, download: true)
     end
 
     # Fetches all pages of a paginated resource.
@@ -396,7 +400,7 @@ module Basecamp
     end
 
     def request_with_retry(method, url, params: {}, allow_cross_origin: false, operation: nil, retry_on: nil,
-      accept: "application/json")
+      accept: "application/json", download: false)
       op_retry = operation && Http.operation_retry(operation)
       # The cap is floored at one attempt on every path: whether a request
       # reaches the wire at all must not depend on whether the operation
@@ -422,7 +426,7 @@ module Basecamp
 
         begin
           return single_request(method, url, params: params, body: nil, attempt: attempt,
-            allow_cross_origin: allow_cross_origin, accept: accept, refresh_replay: false)
+            allow_cross_origin: allow_cross_origin, accept: accept, refresh_replay: false, download: download)
         rescue Basecamp::AuthError => e
           # SPEC §4: the refresh replay is a request on the wire, so it spends
           # an attempt from THIS budget rather than an uncounted one inside
@@ -474,8 +478,9 @@ module Basecamp
 
           delay = calculate_delay(attempt, error.retry_after)
 
-          @hooks.on_retry(RequestInfo.new(method: method.to_s.upcase, url: url, attempt: attempt), attempt + 1, error,
-                          delay)
+          hook_url = download ? Security.display_url(url) : url
+          @hooks.on_retry(RequestInfo.new(method: method.to_s.upcase, url: hook_url, attempt: attempt),
+                          attempt + 1, error, delay)
           sleep(delay)
         end
       end
@@ -511,14 +516,19 @@ module Basecamp
     end
 
     def single_request(method, url, params:, body:, attempt:, retry_count: 0, allow_cross_origin: false,
-      accept: "application/json", refresh_replay: true)
+      accept: "application/json", refresh_replay: true, download: false)
       assert_credential_origin!(url, allow_cross_origin)
-      info = RequestInfo.new(method: method.to_s.upcase, url: url, attempt: attempt)
+      # download: the SPEC §9 projection for a URL whose query can carry a
+      # credential (download hop 1) — hooks see origin+path, and a transport
+      # error is severed below; the wire request keeps url.
+      info = RequestInfo.new(method: method.to_s.upcase, url: download ? Security.display_url(url) : url,
+                             attempt: attempt)
       @hooks.on_request_start(info)
 
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-      begin
+      severed = nil
+      result = begin
         response = @faraday.run_request(method, url, body, request_headers(accept: accept)) do |req|
           req.params.merge!(params) if params.any?
         end
@@ -551,17 +561,29 @@ module Basecamp
             && @token_refreshed
           @token_refreshed = false
           return single_request(method, url, params: params, body: body, attempt: attempt, retry_count: retry_count + 1,
-            allow_cross_origin: allow_cross_origin, accept: accept, refresh_replay: refresh_replay)
+            allow_cross_origin: allow_cross_origin, accept: accept, refresh_replay: refresh_replay, download: download)
         end
 
-        raise error
+        # On a download, a status error is raised below the rescue too: the
+        # Faraday exception retains the request (SPEC §9), and raising here
+        # would make it MRI's implicit cause.
+        raise error unless download
+
+        severed = error
       rescue Faraday::Error => e
         duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-        error = Basecamp::NetworkError.new("Connection failed", cause: e)
-        result = RequestResult.new(duration: duration, error: error)
-        @hooks.on_request_end(info, result)
-        raise error
+        # SPEC §9: on a download hop 1 the Faraday error can render the URL it
+        # failed on, so it is neither the cause nor the hint, and it is raised
+        # below — outside this rescue, with cause: nil — so MRI's implicit
+        # cause is severed too. Every other request keeps its diagnostic.
+        error = download ? Basecamp::NetworkError.new : Basecamp::NetworkError.new("Connection failed", cause: e)
+        @hooks.on_request_end(info, RequestResult.new(duration: duration, error: error))
+        raise error unless download
+
+        severed = error
       end
+
+      severed ? raise(severed, cause: nil) : result
     end
 
     # accept: nil is the binary-download carve-out (SPEC §14): hop 1 sends
@@ -624,38 +646,48 @@ module Basecamp
 
       retry_after = parse_retry_after(headers["Retry-After"] || headers["retry-after"])
       request_id = headers["X-Request-Id"] || headers["x-request-id"]
+      # SPEC §6 step 3: a body's error_description becomes the hint. Class
+      # defaults (AuthError, ForbiddenError) still apply when the body has none.
+      hint = Basecamp.parse_error_hint(body)
 
       err = case status
       when 401
         # Try token refresh; flag for caller to retry
         @token_refreshed = refresh_on_401 && @token_provider&.refreshable? && @token_provider.refresh
-        Basecamp::AuthError.new("Authentication failed")
+        Basecamp::AuthError.new("Authentication failed", hint: hint)
       when 403
-        Basecamp::ForbiddenError.new("Access denied")
+        Basecamp::ForbiddenError.new("Access denied", hint: hint)
       when 404
         message = Security.truncate(Basecamp.parse_error_message(body) || "Not found")
-        Basecamp::NotFoundError.new(message: message)
+        Basecamp::NotFoundError.new(message: message, hint: hint)
       when 429
-        Basecamp::RateLimitError.new(retry_after: retry_after)
+        Basecamp::RateLimitError.new(retry_after: retry_after, hint: hint)
       when 400, 422
         field_errors = Basecamp.parse_field_errors(body)
         message = Security.truncate(
           Basecamp.compose_validation_message(Basecamp.parse_error_message(body), field_errors) || "Validation failed"
         )
-        Basecamp::ValidationError.new(message, http_status: status, field_errors: field_errors)
+        people = status == 422 ? Basecamp.parse_template_library_confirmation_people(body) : nil
+        if people
+          Basecamp::PeopleConfirmationRequiredError.new(
+            message, people: people, hint: hint, http_status: status, field_errors: field_errors
+          )
+        else
+          Basecamp::ValidationError.new(message, hint: hint, http_status: status, field_errors: field_errors)
+        end
       when 507
         # A 5xx status carrying a client fact: the account is out of storage, or
         # at its webhook ceiling. Retrying cannot satisfy it, so this is decided
         # before the 5xx arms below.
         message = Security.truncate(Basecamp.parse_error_message(body) || "Account limit reached")
-        Basecamp::LimitExceededError.new(message)
+        Basecamp::LimitExceededError.new(message, hint: hint)
       when 500
-        Basecamp::ApiError.new("Server error (500)", http_status: 500, retryable: true)
+        Basecamp::ApiError.new("Server error (500)", http_status: 500, retryable: true, hint: hint)
       when 502, 503, 504
-        Basecamp::ApiError.new("Gateway error (#{status})", http_status: status, retryable: true)
+        Basecamp::ApiError.new("Gateway error (#{status})", http_status: status, retryable: true, hint: hint)
       else
         message = Security.truncate(Basecamp.parse_error_message(body) || "Request failed (HTTP #{status})")
-        Basecamp::ApiError.from_status(status || 0, message)
+        Basecamp::ApiError.from_status(status || 0, message, hint: hint)
       end
 
       err.instance_variable_set(:@request_id, request_id) if request_id

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)

data/lib/basecamp/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Basecamp
-  VERSION = "0.15.0"
-  API_VERSION = "2026-08-11"
+  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.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Basecamp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-22 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