basecamp-sdk 0.18.0 → 0.19.0

data/lib/basecamp/services/todolists_extensions.rb

@@ -180,9 +180,10 @@ module Basecamp
       # Ruby has no typed decoder between the GET and this read, unlike the Go,
       # Swift and Kotlin composites where a wrong-typed field fails at decode,
       # and flattening the shape did not add one: the generated method still
-      # returns <tt>http_get(...).json</tt> verbatim. The same shape is live in
-      # the shipped Todos composite; tracked in #576, with the generated
-      # validating layer that would retire this guard tracked in #578.
+      # returns <tt>http_get(...).json</tt> verbatim. The same shape in the
+      # shipped Todos composite is guarded by the MergeSafe checks #576 closed
+      # with; the generated validating layer that would retire this guard is
+      # tracked in #578.
       def writable_string(body, key, non_empty: false)
         raise_missing_field(key) unless body.key?(key)
 

data/lib/basecamp/text.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Basecamp
+  # Text trimming that matches the reference's, byte for byte.
+  #
+  # Ruby's <tt>String#strip</tt> is NOT that function, and the difference runs
+  # in both directions. Measured over all 256 single bytes and the whole of
+  # +unicode.IsSpace+:
+  #
+  # * <tt>strip</tt> removes a leading or trailing NUL and +strings.TrimSpace+
+  #   does not — <tt>unicode.IsSpace</tt> has no NUL in it. That is the
+  #   ACCEPTING direction wherever a trimmed value is compared against a table:
+  #   <tt>"Comment\\0"</tt> selected a real recording type here and was
+  #   +unknown_recording_type+ there.
+  # * <tt>strip</tt> on a BYTE string removes none of the nineteen multi-byte
+  #   spaces +IsSpace+ carries — U+0085, U+00A0, U+1680, U+2000..U+200A,
+  #   U+2028, U+2029, U+202F, U+205F, U+3000 — which the reference trims. That
+  #   direction merely refuses, but it is still a divergence.
+  #
+  # One byte of the 256 diverges in the first direction and nineteen characters
+  # in the second, so neither <tt>strip</tt> nor a plain ASCII trim is the
+  # reference's function; this walk is.
+  #
+  # It lives here rather than in either caller because both {Basecamp::Mentions}
+  # and the recording-summary composite need the same trim, and a second
+  # hand-written copy of a byte walk is how the two would come apart.
+  module Text
+    # Every member of +unicode.IsSpace+, as its UTF-8 bytes. Built from the
+    # literals rather than a range so the set is readable, and keyed by byte
+    # string so a lookup needs no decoding. No member is a prefix, a suffix or a
+    # substring of another, which is what lets the walk below take the first
+    # width that matches rather than the longest.
+    UTF8_SPACE_BYTES = ([ " ", "\t", "\n", "\v", "\f", "\r", "…", " ", " ",
+                          "
", "
", " ", " ", "　" ] +
+                        (0x2000..0x200A).map { |codepoint| codepoint.chr(Encoding::UTF_8) })
+                       .to_h { |character| [ character.b, true ] }.freeze
+
+    # The widest member, so the walk knows how far to look.
+    MAX_SPACE_WIDTH = UTF8_SPACE_BYTES.keys.map(&:bytesize).max
+
+    module_function
+
+    # The value with leading and trailing +unicode.IsSpace+ runs removed, as
+    # +strings.TrimSpace+ removes them.
+    #
+    # @param value [String]
+    # @return [String] the trimmed bytes
+    def trim_space(value)
+      bytes = value.b
+      first = space_run_end(bytes)
+      bytes.byteslice(first, space_run_start(bytes, first) - first)
+    end
+
+    # The offset just past the leading run of spaces.
+    def space_run_end(bytes)
+      offset = 0
+      while (width = space_width_at(bytes, offset, bytes.bytesize))
+        offset += width
+      end
+      offset
+    end
+
+    # The offset where the trailing run of spaces begins, never below +floor+ —
+    # so a value that is nothing but spaces trims to empty rather than
+    # underflowing past the leading run already consumed.
+    def space_run_start(bytes, floor)
+      offset = bytes.bytesize
+      while (width = space_width_behind(bytes, offset, floor))
+        offset -= width
+      end
+      offset
+    end
+
+    # The width of the space at +offset+, or nil when there is none.
+    def space_width_at(bytes, offset, ceiling)
+      (1..MAX_SPACE_WIDTH).each do |width|
+        next if offset + width > ceiling
+        return width if UTF8_SPACE_BYTES.key?(bytes.byteslice(offset, width))
+      end
+      nil
+    end
+
+    # The width of the space ending at +offset+, or nil when there is none.
+    def space_width_behind(bytes, offset, floor)
+      (1..MAX_SPACE_WIDTH).each do |width|
+        next if offset - width < floor
+        return width if UTF8_SPACE_BYTES.key?(bytes.byteslice(offset - width, width))
+      end
+      nil
+    end
+
+    private_class_method :space_run_end, :space_run_start, :space_width_at, :space_width_behind
+  end
+end

data/lib/basecamp/unresolved_recording_error.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Basecamp
+  # Raised when a chat line was found under none of the Campfires the caller can
+  # currently see in its bucket.
+  #
+  # It is distinct from a failed read — any non-404 answer from a candidate is
+  # raised as itself and stops the loop — and from
+  # {CampfireDiscoveryIncompleteError}, where candidates were left unsearched:
+  # here EVERY candidate answered 404.
+  #
+  # It is NOT distinct from lost visibility. BC3 answers 404 for a Campfire the
+  # caller may not see, too, so "unresolved" means "under no Campfire the caller
+  # can currently see". {#stale_campfire_ids} is what lets a consumer tell the
+  # two apart: candidates the cache held that the refreshed sources no longer
+  # list are Campfires the caller could see when the cache filled and cannot
+  # now. A consumer marks the record blocked and retries on its own schedule.
+  #
+  # +code+ is +not_found+: the recording could not be located. The CLASS is what
+  # keeps it distinct from a read's {NotFoundError} — this error carries no
+  # +http_status+, because no single HTTP answer produced it.
+  class UnresolvedRecordingError < RecordingSummaryError
+    KIND = "recording_unresolved"
+
+    # @return [Integer] the bucket the pointer named
+    attr_reader :bucket_id
+
+    # @return [Integer] the chat line's id
+    attr_reader :recording_id
+
+    # @return [Array<Integer>] the candidates tried, in order; empty when the
+    #   bucket has no visible Campfire at all
+    attr_reader :campfire_ids
+
+    # @return [Array<Integer>] candidates from the cache that the refreshed
+    #   sources no longer list. Set only when {#refreshed?}.
+    attr_reader :stale_campfire_ids
+
+    # @param bucket_id [Integer]
+    # @param recording_id [Integer]
+    # @param campfire_ids [Array<Integer>]
+    # @param refreshed [Boolean] whether the cached discovery sources were
+    #   re-read before concluding. False when every source had been read within
+    #   the last +CampfireIndex::MIN_REFRESH+, so a Campfire created in that
+    #   window was not seen: the conclusion stands on data up to that old, and a
+    #   retry after the floor sees the current sources.
+    # @param stale_campfire_ids [Array<Integer>]
+    def initialize(bucket_id:, recording_id:, campfire_ids:, refreshed:, stale_campfire_ids: [])
+      super(
+        kind: KIND,
+        code: ErrorCode::NOT_FOUND,
+        message: "chat line found under no visible campfire: line #{recording_id} in bucket #{bucket_id} " \
+                 "(tried #{campfire_ids.length} campfires)"
+      )
+      @bucket_id = bucket_id
+      @recording_id = recording_id
+      @campfire_ids = campfire_ids
+      @refreshed = refreshed
+      @stale_campfire_ids = stale_campfire_ids
+    end
+
+    # @return [Boolean] whether the cached discovery sources were re-read before
+    #   concluding
+    def refreshed?
+      @refreshed
+    end
+  end
+end

data/lib/basecamp/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Basecamp
-  VERSION = "0.18.0"
+  VERSION = "0.19.0"
   API_VERSION = "2026-09-02"
 end

data/lib/basecamp/webhooks/event.rb

@@ -5,7 +5,7 @@ module Basecamp
     # Structured wrapper around webhook event payloads.
     # Accepts any hash - does not reject unknown fields or event kinds.
     class Event
-      attr_reader :id, :kind, :details, :created_at, :recording, :creator, :copy, :raw
+      attr_reader :id, :kind, :details, :created_at, :recording, :creator, :performed_by, :copy, :raw
 
       def initialize(hash)
         @raw = hash
@@ -15,6 +15,9 @@ module Basecamp
         @created_at = hash["created_at"]
         @recording = hash["recording"] || {}
         @creator = hash["creator"] || {}
+        # The agent that carried out a delegated action (personable_type "Agent",
+        # or "Tombstone" once deleted); nil for actions performed directly.
+        @performed_by = hash["performed_by"]
         @copy = hash["copy"]
       end
 

data/lib/basecamp.rb

@@ -31,6 +31,17 @@ end
 loader.on_load("Basecamp::Services::SchedulesService") do |klass, _abspath|
   klass.prepend(Basecamp::Services::SchedulesExtensions)
 end
+# And for recordings: the generated class owns the status writes, and the
+# hand-written `summarize` projection — one typed read per recording type, plus
+# Campfire discovery for chat lines — is prepended over it.
+loader.on_load("Basecamp::Services::RecordingsService") do |klass, _abspath|
+  klass.prepend(Basecamp::Services::RecordingsExtensions)
+end
+# And for comments: the generated class owns `create`, and the mention-expanding
+# `create_with_mentions`/`expand_mentions` surface is prepended over it.
+loader.on_load("Basecamp::Services::CommentsService") do |klass, _abspath|
+  klass.prepend(Basecamp::Services::CommentsExtensions)
+end
 loader.setup
 
 # Load generated types if available
@@ -124,7 +135,7 @@ module Basecamp
     server_message = parse_error_message(body)
     message = server_message || "Request failed"
 
-    case status
+    err = case status
     when 400, 422
       field_errors = parse_field_errors(body)
       message = Security.truncate(compose_validation_message(server_message, field_errors) || "Request failed")
@@ -149,12 +160,19 @@ module Basecamp
       # transient server failure, and no retry can satisfy it.
       LimitExceededError.new(Security.truncate(message), hint: hint)
     when 500
-      ApiError.new("Server error (500)", http_status: 500, retryable: true, hint: hint)
+      ApiError.new("Server error (500)", http_status: 500, retryable: true, hint: hint, retry_after: retry_after)
     when 502, 503, 504
-      ApiError.new("Gateway error (#{status})", http_status: status, retryable: true, hint: hint)
+      ApiError.new("Gateway error (#{status})", http_status: status, retryable: true, hint: hint, retry_after: retry_after)
     else
-      ApiError.from_status(status, server_message, hint: hint)
+      ApiError.from_status(status, server_message, hint: hint, retry_after: retry_after)
     end
+
+    # Every status carries the parsed Retry-After (SPEC §6 "HTTP Status Mapping
+    # Algorithm"), including the arms whose error classes take no such
+    # argument — the same back-fill Http#handle_error applies, so this public
+    # mapper and the private one answer alike.
+    err.instance_variable_set(:@retry_after, retry_after) if retry_after && err.retry_after.nil?
+    err
   end
 
   # Extracts a filename from the last path segment of a URL.

data/scripts/generate-metadata.rb

@@ -3,6 +3,8 @@
 
 # Extracts x-basecamp-* extensions from OpenAPI spec into a runtime-accessible metadata file.
 # This allows the Ruby SDK to read operation metadata at runtime for retry, pagination, etc.
+# It also emits +personIdSites+, the per-operation table of response paths the
+# generated read path decodes a person id at (see {Basecamp::PersonIdSites}).
 #
 # Usage: ruby scripts/ruby/generate-metadata.rb > lib/basecamp/generated/metadata.json
 
@@ -39,10 +41,82 @@ class MetadataExtractor
       '$schema' => 'https://basecamp.com/schemas/sdk-metadata.json',
       'version' => '1.0.0',
       'generated' => Time.now.utc.iso8601,
-      'operations' => operations
+      'operations' => operations,
+      'personIdSites' => person_id_sites
     }
   end
 
+  # The Go-type marker that makes a schema's +id+ a flexible person id. Go
+  # generates +Person.Id+ as +types.FlexibleInt64+ from exactly this extension,
+  # and it is the only field that carries it, so the table is selected on the
+  # marker and never on a key name: +UpcomingSchedulePerson+,
+  # +MyAssignmentAssignee+, +OutOfOfficePerson+ and
+  # +TemplateLibraryConfirmationPerson+ sit under the same key names with a
+  # plain int64 id, where a string is a decode error in the reference.
+  FLEXIBLE_PERSON_ID = 'types.FlexibleInt64'
+
+  # {operationId => [path, ...]} for every operation whose 2xx JSON response
+  # reaches a schema whose +id+ is {FLEXIBLE_PERSON_ID}. A path is its
+  # components joined by "."; "[]" is an array element, and a path that ENDS
+  # in "[]" names an array of people. "$" is the body itself.
+  def person_id_sites
+    sites = {}
+    (@openapi['paths'] || {}).each_value do |path_item|
+      METHODS.each do |method|
+        operation = path_item[method]
+        next unless operation && operation['operationId']
+
+        paths = (operation['responses'] || {}).flat_map do |code, response|
+          next [] unless code.to_s.start_with?('2')
+
+          response = resolve_response(response)
+          (response['content'] || {}).values.flat_map do |media|
+            found = []
+            walk_person_sites(media['schema'] || {}, [], [], found)
+            found
+          end
+        end.uniq.sort
+        sites[operation['operationId']] = paths if paths.any?
+      end
+    end
+    sites.sort.to_h
+  end
+
+  def resolve_response(response)
+    return response unless response['$ref']
+
+    @openapi.dig('components', 'responses', response['$ref'].split('/').last)
+  end
+
+  # Walks $ref, allOf/oneOf/anyOf, items and properties. A schema already on
+  # the $ref stack is a cycle and is not re-entered. additionalProperties has
+  # no runtime path syntax, so a person reached through one fails generation
+  # rather than being silently left out of the table.
+  def walk_person_sites(schema, path, stack, found)
+    if (ref = schema['$ref'])
+      name = ref.split('/').last
+      return if stack.include?(name)
+
+      target = @openapi.dig('components', 'schemas', name)
+      found << (path.empty? ? '$' : path.join('.')) if target.dig('properties', 'id', 'x-go-type') == FLEXIBLE_PERSON_ID
+      walk_person_sites(target, path, stack + [ name ], found)
+      return
+    end
+
+    %w[allOf oneOf anyOf].each do |key|
+      (schema[key] || []).each { |sub| walk_person_sites(sub, path, stack, found) }
+    end
+    walk_person_sites(schema['items'] || {}, path + [ '[]' ], stack, found) if schema['type'] == 'array' || schema['items']
+    (schema['properties'] || {}).each { |key, sub| walk_person_sites(sub, path + [ key ], stack, found) }
+
+    extra = schema['additionalProperties']
+    return unless extra.is_a?(Hash)
+
+    nested = []
+    walk_person_sites(extra, path + [ '{}' ], stack, nested)
+    raise "person id site under additionalProperties at #{nested.first} has no runtime path syntax" if nested.any?
+  end
+
   private
 
   def extract_operation_metadata(operation)
@@ -62,7 +136,6 @@ class MetadataExtractor
     if (pagination = operation['x-basecamp-pagination'])
       metadata['pagination'] = {
         'style' => pagination['style'],
-        'pageParam' => pagination['pageParam'],
         'totalCountHeader' => pagination['totalCountHeader'],
         'maxPageSize' => pagination['maxPageSize']
       }.compact

data/scripts/generate-services.rb

@@ -56,6 +56,7 @@ class ServiceGenerator
         GetCardColumn UpdateCardColumn SetCardColumnColor
         EnableCardColumnOnHold DisableCardColumnOnHold
         CreateCardColumn MoveCardColumn
+        SubscribeToCardColumn UnsubscribeFromCardColumn
       ],
       'CardSteps' => %w[
         GetCardStep CreateCardStep UpdateCardStep SetCardStepCompletion
@@ -440,6 +441,14 @@ class ServiceGenerator
     # Extract body parameters from schema
     body_params = extract_body_params(body_schema_ref)
 
+    # Only "link" and "cursor" are implemented. Anything else -- a typo, or the
+    # "page" style the trait used to advertise -- must fail loudly: read as "not
+    # paginated" it would silently ship a method that never walks.
+    pagination_style = operation.dig('x-basecamp-pagination', 'style')
+    if operation['x-basecamp-pagination'] && !%w[ link cursor ].include?(pagination_style)
+      raise "#{operation_id}: unsupported pagination style #{pagination_style.inspect} (expected \"link\" or \"cursor\")"
+    end
+
     # Check response
     success_response = operation.dig('responses', '200') || operation.dig('responses', '201')
     response_schema = success_response&.dig('content', 'application/json', 'schema')
@@ -470,8 +479,18 @@ class ServiceGenerator
       returns_array: returns_array,
       returns_bare_array: returns_bare_array,
       is_mutation: http_method != 'GET',
-      has_pagination: !!operation['x-basecamp-pagination'],
-      pagination_key: operation.dig('x-basecamp-pagination', 'key')
+      # Auto-pagination is the "link" style alone: the generated method follows
+      # Link: rel="next" and flattens the walk into one array. The "cursor"
+      # style is declared for the catalogue and generates none -- each call
+      # returns one page carrying its own opaque position, and flattening would
+      # swallow every intermediate one.
+      has_pagination: pagination_style == 'link',
+      # Carried separately because has_pagination is false for cursor, and the
+      # bare-array gate below would otherwise walk it anyway.
+      cursor_pagination: pagination_style == 'cursor',
+      # Link-style only: the key drives envelope unwrapping, and a cursor
+      # operation must be typed as its envelope rather than the item under it.
+      pagination_key: (pagination_style == 'link' ? operation.dig('x-basecamp-pagination', 'key') : nil)
     }
   end
 
@@ -657,7 +676,10 @@ class ServiceGenerator
   def generate_method(op, service_name:)
     lines = []
 
-    is_paginated = (op[:returns_array] || op[:has_pagination]) && !op[:pagination_key]
+    # A cursor operation never walks, whatever its response shape: has_pagination
+    # is already false for it, but a bare-array response would otherwise send it
+    # down the Link-following path through returns_array.
+    is_paginated = !op[:cursor_pagination] && (op[:returns_array] || op[:has_pagination]) && !op[:pagination_key]
     is_wrapped_paginated = op[:has_pagination] && op[:pagination_key]
 
     # Method signature (paginated operations gain a trailing max_items: kwarg)
@@ -903,6 +925,11 @@ class ServiceGenerator
     # Only GETs are retry-governed in Ruby, and only Http#get accepts the
     # operation keyword — mutations go through single_request with no retry.
     operation_arg = http_method == 'get' ? ", operation: \"#{op[:operation_id]}\"" : ''
+    # Every verb names its operation to the body decode, which is a separate
+    # channel from the retry keyword above: the typed person-id decode
+    # (Basecamp::PersonIdSites) is keyed by operation id, and a mutation's
+    # response carries people exactly as a read's does.
+    json_call = ".json(operation: \"#{op[:operation_id]}\")"
 
     if op[:has_binary_body]
       # Binary upload - use raw body and set Content-Type header
@@ -914,18 +941,18 @@ class ServiceGenerator
         query_string = query_parts.join('&')
         # Modify path_expr to include query string
         path_expr_with_query = path_expr.sub(/"$/, "?#{query_string}\"")
-        lines << "        http_#{http_method}_raw(#{path_expr_with_query}, body: data, content_type: content_type).json"
+        lines << "        http_#{http_method}_raw(#{path_expr_with_query}, body: data, content_type: content_type)#{json_call}"
       else
-        lines << "        http_#{http_method}_raw(#{path_expr}, body: data, content_type: content_type).json"
+        lines << "        http_#{http_method}_raw(#{path_expr}, body: data, content_type: content_type)#{json_call}"
       end
     elsif op[:has_body]
       body_expr = build_body_expression(op)
-      lines << "        http_#{http_method}(#{path_expr}, body: #{body_expr}).json"
+      lines << "        http_#{http_method}(#{path_expr}, body: #{body_expr})#{json_call}"
     elsif op[:query_params].any?
       param_names = op[:query_params].map { |q| "#{to_snake_case(q[:name])}: #{to_snake_case(q[:name])}" }
-      lines << "        http_#{http_method}(#{path_expr}, params: compact_query_params(#{param_names.join(', ')})#{operation_arg}).json"
+      lines << "        http_#{http_method}(#{path_expr}, params: compact_query_params(#{param_names.join(', ')})#{operation_arg})#{json_call}"
     else
-      lines << "        http_#{http_method}(#{path_expr}#{operation_arg}).json"
+      lines << "        http_#{http_method}(#{path_expr}#{operation_arg})#{json_call}"
     end
 
     lines

data/scripts/generate-types.rb

@@ -47,6 +47,23 @@ def generate_helpers
         value.to_i
       end
 
+      # A PERSON's id: the one field in this model the reference decodes
+      # flexibly (x-go-type: types.FlexibleInt64), and the only one that may
+      # arrive as a JSON string.
+      #
+      # Read with Basecamp::Ids.person_from_wire, which is Go's
+      # strconv.ParseInt(s, 10, 64) and is already the rule at the other two
+      # person-id sites (the pre-decode normalizer in Basecamp::Http and the
+      # flexible reader itself). NOT parse_integer, whose to_i answers 0 for
+      # "basecamp" without recording the label, 8 for "010", and — since the
+      # normalizer now leaves an out-of-range id as a String for the reader to
+      # refuse — a bignum for "18446744073709551616x", which is not an id any
+      # API can hold. A refused id is nil here, the same nil a malformed value
+      # of any other type gets.
+      def parse_flexible_person_id(value)
+        Basecamp::Ids.person_from_wire(value)
+      end
+
       def parse_float(value)
         return nil if value.nil?
         value.to_f
@@ -203,6 +220,8 @@ if __FILE__ == $PROGRAM_NAME
       elsif prop_schema['type'] == 'array' && prop_schema.dig('items', '$ref')
                     ref_name = prop_schema['items']['$ref'].split('/').last
                     "parse_array(data[\"#{prop_name}\"], \"#{ref_name}\")"
+      elsif prop_schema['x-go-type']&.include?('FlexibleInt64')
+                    "parse_flexible_person_id(data[\"#{prop_name}\"])"
       elsif prop_schema['type'] == 'integer'
                     "parse_integer(data[\"#{prop_name}\"])"
       elsif prop_schema['type'] == 'number'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: basecamp-sdk
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Basecamp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-10 00:00:00.000000000 Z
+date: 2026-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -169,6 +169,9 @@ files:
 - lib/basecamp/auth_error.rb
 - lib/basecamp/auth_strategy.rb
 - lib/basecamp/bearer_auth.rb
+- lib/basecamp/bucket_mismatch_error.rb
+- lib/basecamp/campfire_discovery_incomplete_error.rb
+- lib/basecamp/campfire_index.rb
 - lib/basecamp/chain_hooks.rb
 - lib/basecamp/client.rb
 - lib/basecamp/config.rb
@@ -200,6 +203,7 @@ files:
 - lib/basecamp/generated/services/comments_service.rb
 - lib/basecamp/generated/services/documents_service.rb
 - lib/basecamp/generated/services/drafts_service.rb
+- lib/basecamp/generated/services/event_feed_service.rb
 - lib/basecamp/generated/services/events_service.rb
 - lib/basecamp/generated/services/everything_service.rb
 - lib/basecamp/generated/services/folders_service.rb
@@ -236,10 +240,12 @@ files:
 - lib/basecamp/generated/types.rb
 - lib/basecamp/hooks.rb
 - lib/basecamp/http.rb
+- lib/basecamp/ids.rb
 - lib/basecamp/limit_exceeded_error.rb
 - lib/basecamp/list_enumerator.rb
 - lib/basecamp/list_meta.rb
 - lib/basecamp/logger_hooks.rb
+- lib/basecamp/mentions.rb
 - lib/basecamp/network_error.rb
 - lib/basecamp/noop_hooks.rb
 - lib/basecamp/not_found_error.rb
@@ -264,19 +270,26 @@ files:
 - lib/basecamp/operation_info.rb
 - lib/basecamp/operation_result.rb
 - lib/basecamp/people_confirmation_required_error.rb
+- lib/basecamp/person_id_sites.rb
 - lib/basecamp/rate_limit_error.rb
+- lib/basecamp/recording_routing_error.rb
+- lib/basecamp/recording_summary_error.rb
 - lib/basecamp/request_info.rb
 - lib/basecamp/request_result.rb
 - lib/basecamp/security.rb
 - lib/basecamp/services/authorization_service.rb
 - lib/basecamp/services/cards_extensions.rb
+- lib/basecamp/services/comments_extensions.rb
 - lib/basecamp/services/documents_extensions.rb
 - lib/basecamp/services/merge_safe.rb
+- lib/basecamp/services/recordings_extensions.rb
 - lib/basecamp/services/schedules_extensions.rb
 - lib/basecamp/services/todolists_extensions.rb
 - lib/basecamp/services/todos_extensions.rb
 - lib/basecamp/static_token_provider.rb
+- lib/basecamp/text.rb
 - lib/basecamp/token_provider.rb
+- lib/basecamp/unresolved_recording_error.rb
 - lib/basecamp/usage_error.rb
 - lib/basecamp/validation_error.rb
 - lib/basecamp/version.rb