basecamp-sdk 0.11.0 → 0.13.0

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

@@ -57,37 +57,52 @@ module Basecamp
         raise
       end
 
-      # Wraps a lazy Enumerator so operation hooks fire around actual iteration,
-      # not at enumerator creation time. Hooks fire when the consumer begins
-      # iterating (.each, .to_a, .first, etc.) and end fires via ensure when
-      # iteration completes, errors, or is cut short by break/take.
+      # Wraps a paginated operation with hooks, preserving the pagination
+      # metadata carried by the inner ListEnumerator.
+      # Fires on_operation_start eagerly (paginate fetches page 1 inside the
+      # yield, so the start hook must precede it); on_operation_end fires via
+      # ensure when the first traversal completes, errors, or is cut short by
+      # break/take — exactly once, so re-enumerating never emits an
+      # on_operation_end without a matching start.
       def wrap_paginated(service:, operation:, is_mutation: false, project_id: nil, resource_id: nil)
         info = OperationInfo.new(
           service: service, operation: operation,
           is_mutation: is_mutation, project_id: project_id, resource_id: resource_id
         )
-        enum = yield
-
         hooks = @hooks
-        Enumerator.new do |yielder|
-          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        safe_hook { hooks.on_operation_start(info) }
+
+        begin
+          enum = yield  # paginate fetches page 1 here
+        rescue => e
+          duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+          safe_hook { hooks.on_operation_end(info, OperationResult.new(duration_ms: duration, error: e)) }
+          raise
+        end
+
+        ended = false
+        ListEnumerator.new(enum.meta) do |yielder|
           error = nil
           begin
-            safe_hook { hooks.on_operation_start(info) }
             enum.each { |item| yielder.yield(item) }
           rescue => e
             error = e
             raise
           ensure
-            duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
-            safe_hook { hooks.on_operation_end(info, OperationResult.new(duration_ms: duration, error: error)) }
+            unless ended
+              ended = true
+              duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+              safe_hook { hooks.on_operation_end(info, OperationResult.new(duration_ms: duration, error: error)) }
+            end
           end
         end
       end
 
       # Wraps a wrapped-paginated operation with hooks.
-      # Fires on_operation_start eagerly (before page 1 fetch),
-      # on_operation_end when the events Enumerator completes/errors/breaks.
+      # Fires on_operation_start eagerly (before page 1 fetch), and
+      # on_operation_end exactly once, when the first traversal of the events
+      # Enumerator completes/errors/breaks.
       def wrap_paginated_wrapped(key:, service:, operation:, is_mutation: false, project_id: nil, resource_id: nil)
         info = OperationInfo.new(
           service: service, operation: operation,
@@ -106,7 +121,8 @@ module Basecamp
         end
 
         inner_enum = result[key]
-        wrapped_enum = Enumerator.new do |yielder|
+        ended = false
+        wrapped_enum = ListEnumerator.new(inner_enum.meta) do |yielder|
           error = nil
           begin
             inner_enum.each { |item| yielder.yield(item) }
@@ -114,8 +130,13 @@ module Basecamp
             error = e
             raise
           ensure
-            duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
-            safe_hook { hooks.on_operation_end(info, OperationResult.new(duration_ms: duration, error: error)) }
+            # Exactly once: on_operation_start fired once at call time, so
+            # re-enumerating must not emit unmatched on_operation_end events.
+            unless ended
+              ended = true
+              duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+              safe_hook { hooks.on_operation_end(info, OperationResult.new(duration_ms: duration, error: error)) }
+            end
           end
         end
 

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Basecamp
+  module Services
+    # Service for Bookmarks operations
+    #
+    # @generated from OpenAPI spec
+    class BookmarksService < BaseService
+
+      # List the current user's bookmarks, most recently bookmarked first (paginated).
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list_my_bookmarks(page: nil, max_items: nil)
+        wrap_paginated(service: "bookmarks", operation: "list_my_bookmarks", is_mutation: false) do
+          params = compact_query_params(page: page)
+          paginate("/my/bookmarks.json", params: params, operation: "ListMyBookmarks", max_items: max_items)
+        end
+      end
+
+      # Report whether the current user has bookmarked the recording.
+      # @param recording_id [Integer] recording id ID
+      # @return [Hash] response data
+      def get_bookmark(recording_id:)
+        with_operation(service: "bookmarks", operation: "get_bookmark", is_mutation: false, resource_id: recording_id) do
+          http_get("/recordings/#{recording_id}/bookmark.json", operation: "GetBookmark").json
+        end
+      end
+
+      # Bookmark a recording for the current user.
+      # @param recording_id [Integer] recording id ID
+      # @return [Hash] response data
+      def create_bookmark(recording_id:)
+        with_operation(service: "bookmarks", operation: "create_bookmark", is_mutation: true, resource_id: recording_id) do
+          http_post("/recordings/#{recording_id}/bookmark.json").json
+        end
+      end
+
+      # Remove the current user's bookmark from a recording (returns 204 No Content).
+      # @param recording_id [Integer] recording id ID
+      # @return [void]
+      def delete_bookmark(recording_id:)
+        with_operation(service: "bookmarks", operation: "delete_bookmark", is_mutation: true, resource_id: recording_id) do
+          http_delete("/recordings/#{recording_id}/bookmark.json")
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -28,10 +28,13 @@ module Basecamp
 
       # List boosts on a recording
       # @param recording_id [Integer] recording id ID
-      # @return [Enumerator<Hash>] paginated results
-      def list_recording_boosts(recording_id:)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list_recording_boosts(recording_id:, page: nil, max_items: nil)
         wrap_paginated(service: "boosts", operation: "list_recording_boosts", is_mutation: false, resource_id: recording_id) do
-          paginate("/recordings/#{recording_id}/boosts.json", operation: "ListRecordingBoosts")
+          params = compact_query_params(page: page)
+          paginate("/recordings/#{recording_id}/boosts.json", params: params, operation: "ListRecordingBoosts", max_items: max_items)
         end
       end
 
@@ -48,10 +51,13 @@ module Basecamp
       # List boosts on a specific event within a recording
       # @param recording_id [Integer] recording id ID
       # @param event_id [Integer] event id ID
-      # @return [Enumerator<Hash>] paginated results
-      def list_event_boosts(recording_id:, event_id:)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list_event_boosts(recording_id:, event_id:, page: nil, max_items: nil)
         wrap_paginated(service: "boosts", operation: "list_event_boosts", is_mutation: false, resource_id: event_id) do
-          paginate("/recordings/#{recording_id}/events/#{event_id}/boosts.json", operation: "ListEventBoosts")
+          params = compact_query_params(page: page)
+          paginate("/recordings/#{recording_id}/events/#{event_id}/boosts.json", params: params, operation: "ListEventBoosts", max_items: max_items)
         end
       end
 

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Basecamp
+  module Services
+    # Service for Calendars operations
+    #
+    # @generated from OpenAPI spec
+    class CalendarsService < BaseService
+
+      # Get a calendar by its bucket id. A Calendar is a top-level BC5 bucketable
+      # @param calendar_id [Integer] calendar id ID
+      # @return [Hash] response data
+      def get_calendar(calendar_id:)
+        with_operation(service: "calendars", operation: "get_calendar", is_mutation: false, resource_id: calendar_id) do
+          http_get("/calendars/#{calendar_id}", operation: "GetCalendar").json
+        end
+      end
+
+      # Update a calendar's display color. An unknown color returns 422 with a JSON
+      # @param calendar_id [Integer] calendar id ID
+      # @param calendar [Hash] calendar
+      # @return [Hash] response data
+      def update_calendar(calendar_id:, calendar:)
+        with_operation(service: "calendars", operation: "update_calendar", is_mutation: true, resource_id: calendar_id) do
+          http_put("/calendars/#{calendar_id}", body: compact_params(calendar: calendar)).json
+        end
+      end
+    end
+  end
+end

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

@@ -9,85 +9,96 @@ module Basecamp
     # @generated from OpenAPI spec
     class CampfiresService < BaseService
 
-      # List all campfires across the account
-      # @return [Enumerator<Hash>] paginated results
-      def list()
-        wrap_paginated(service: "campfires", operation: "list", is_mutation: false) do
-          paginate("/chats.json", operation: "ListCampfires")
-        end
-      end
-
-      # Get a campfire by ID
-      # @param campfire_id [Integer] campfire id ID
-      # @return [Hash] response data
-      def get(campfire_id:)
-        with_operation(service: "campfires", operation: "get", is_mutation: false, resource_id: campfire_id) do
-          http_get("/chats/#{campfire_id}", operation: "GetCampfire").json
-        end
-      end
-
       # List all chatbots for a campfire
+      # @param bucket_id [Integer] bucket id ID
       # @param campfire_id [Integer] campfire id ID
-      # @return [Enumerator<Hash>] paginated results
-      def list_chatbots(campfire_id:)
-        wrap_paginated(service: "campfires", operation: "list_chatbots", is_mutation: false, resource_id: campfire_id) do
-          paginate("/chats/#{campfire_id}/integrations.json", operation: "ListChatbots")
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list_chatbots(bucket_id:, campfire_id:, max_items: nil)
+        wrap_paginated(service: "campfires", operation: "list_chatbots", is_mutation: false, project_id: bucket_id, resource_id: campfire_id) do
+          paginate("/buckets/#{bucket_id}/chats/#{campfire_id}/integrations.json", operation: "ListChatbots", max_items: max_items)
         end
       end
 
       # Create a new chatbot for a campfire
+      # @param bucket_id [Integer] bucket id ID
       # @param campfire_id [Integer] campfire id ID
       # @param service_name [String] service name
       # @param command_url [String, nil] command url
       # @return [Hash] response data
-      def create_chatbot(campfire_id:, service_name:, command_url: nil)
-        with_operation(service: "campfires", operation: "create_chatbot", is_mutation: true, resource_id: campfire_id) do
-          http_post("/chats/#{campfire_id}/integrations.json", body: compact_params(service_name: service_name, command_url: command_url)).json
+      def create_chatbot(bucket_id:, campfire_id:, service_name:, command_url: nil)
+        with_operation(service: "campfires", operation: "create_chatbot", is_mutation: true, project_id: bucket_id, resource_id: campfire_id) do
+          http_post("/buckets/#{bucket_id}/chats/#{campfire_id}/integrations.json", body: compact_params(service_name: service_name, command_url: command_url)).json
         end
       end
 
       # Get a chatbot by ID
+      # @param bucket_id [Integer] bucket id ID
       # @param campfire_id [Integer] campfire id ID
       # @param chatbot_id [Integer] chatbot id ID
       # @return [Hash] response data
-      def get_chatbot(campfire_id:, chatbot_id:)
-        with_operation(service: "campfires", operation: "get_chatbot", is_mutation: false, resource_id: chatbot_id) do
-          http_get("/chats/#{campfire_id}/integrations/#{chatbot_id}", operation: "GetChatbot").json
+      def get_chatbot(bucket_id:, campfire_id:, chatbot_id:)
+        with_operation(service: "campfires", operation: "get_chatbot", is_mutation: false, project_id: bucket_id, resource_id: chatbot_id) do
+          http_get("/buckets/#{bucket_id}/chats/#{campfire_id}/integrations/#{chatbot_id}", operation: "GetChatbot").json
         end
       end
 
       # Update an existing chatbot
+      # @param bucket_id [Integer] bucket id ID
       # @param campfire_id [Integer] campfire id ID
       # @param chatbot_id [Integer] chatbot id ID
       # @param service_name [String] service name
       # @param command_url [String, nil] command url
       # @return [Hash] response data
-      def update_chatbot(campfire_id:, chatbot_id:, service_name:, command_url: nil)
-        with_operation(service: "campfires", operation: "update_chatbot", is_mutation: true, resource_id: chatbot_id) do
-          http_put("/chats/#{campfire_id}/integrations/#{chatbot_id}", body: compact_params(service_name: service_name, command_url: command_url)).json
+      def update_chatbot(bucket_id:, campfire_id:, chatbot_id:, service_name:, command_url: nil)
+        with_operation(service: "campfires", operation: "update_chatbot", is_mutation: true, project_id: bucket_id, resource_id: chatbot_id) do
+          http_put("/buckets/#{bucket_id}/chats/#{campfire_id}/integrations/#{chatbot_id}", body: compact_params(service_name: service_name, command_url: command_url)).json
         end
       end
 
       # Delete a chatbot
+      # @param bucket_id [Integer] bucket id ID
       # @param campfire_id [Integer] campfire id ID
       # @param chatbot_id [Integer] chatbot id ID
       # @return [void]
-      def delete_chatbot(campfire_id:, chatbot_id:)
-        with_operation(service: "campfires", operation: "delete_chatbot", is_mutation: true, resource_id: chatbot_id) do
-          http_delete("/chats/#{campfire_id}/integrations/#{chatbot_id}")
+      def delete_chatbot(bucket_id:, campfire_id:, chatbot_id:)
+        with_operation(service: "campfires", operation: "delete_chatbot", is_mutation: true, project_id: bucket_id, resource_id: chatbot_id) do
+          http_delete("/buckets/#{bucket_id}/chats/#{campfire_id}/integrations/#{chatbot_id}")
           nil
         end
       end
 
+      # List all campfires across the account
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list(page: nil, max_items: nil)
+        wrap_paginated(service: "campfires", operation: "list", is_mutation: false) do
+          params = compact_query_params(page: page)
+          paginate("/chats.json", params: params, operation: "ListCampfires", max_items: max_items)
+        end
+      end
+
+      # Get a campfire by ID
+      # @param campfire_id [Integer] campfire id ID
+      # @return [Hash] response data
+      def get(campfire_id:)
+        with_operation(service: "campfires", operation: "get", is_mutation: false, resource_id: campfire_id) do
+          http_get("/chats/#{campfire_id}", operation: "GetCampfire").json
+        end
+      end
+
       # List all lines (messages) in a campfire
       # @param campfire_id [Integer] campfire id ID
       # @param sort [String, nil] created_at|updated_at
       # @param direction [String, nil] asc|desc
-      # @return [Enumerator<Hash>] paginated results
-      def list_lines(campfire_id:, sort: nil, direction: nil)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list_lines(campfire_id:, sort: nil, direction: nil, page: nil, max_items: nil)
         wrap_paginated(service: "campfires", operation: "list_lines", is_mutation: false, resource_id: campfire_id) do
-          params = compact_query_params(sort: sort, direction: direction)
-          paginate("/chats/#{campfire_id}/lines.json", params: params, operation: "ListCampfireLines")
+          params = compact_query_params(sort: sort, direction: direction, page: page)
+          paginate("/chats/#{campfire_id}/lines.json", params: params, operation: "ListCampfireLines", max_items: max_items)
         end
       end
 
@@ -139,11 +150,13 @@ module Basecamp
       # @param campfire_id [Integer] campfire id ID
       # @param sort [String, nil] created_at|updated_at
       # @param direction [String, nil] asc|desc
-      # @return [Enumerator<Hash>] paginated results
-      def list_uploads(campfire_id:, sort: nil, direction: nil)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list_uploads(campfire_id:, sort: nil, direction: nil, page: nil, max_items: nil)
         wrap_paginated(service: "campfires", operation: "list_uploads", is_mutation: false, resource_id: campfire_id) do
-          params = compact_query_params(sort: sort, direction: direction)
-          paginate("/chats/#{campfire_id}/uploads.json", params: params, operation: "ListCampfireUploads")
+          params = compact_query_params(sort: sort, direction: direction, page: page)
+          paginate("/chats/#{campfire_id}/uploads.json", params: params, operation: "ListCampfireUploads", max_items: max_items)
         end
       end
 

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

@@ -43,10 +43,13 @@ module Basecamp
 
       # List cards in a column
       # @param column_id [Integer] column id ID
-      # @return [Enumerator<Hash>] paginated results
-      def list(column_id:)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list(column_id:, page: nil, max_items: nil)
         wrap_paginated(service: "cards", operation: "list", is_mutation: false, resource_id: column_id) do
-          paginate("/card_tables/lists/#{column_id}/cards.json", operation: "ListCards")
+          params = compact_query_params(page: page)
+          paginate("/card_tables/lists/#{column_id}/cards.json", params: params, operation: "ListCards", max_items: max_items)
         end
       end
 

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

@@ -8,10 +8,13 @@ module Basecamp
     class CheckinsService < BaseService
 
       # Get pending check-in reminders for the current user
-      # @return [Enumerator<Hash>] paginated results
-      def reminders()
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def reminders(page: nil, max_items: nil)
         wrap_paginated(service: "checkins", operation: "reminders", is_mutation: false) do
-          paginate("/my/question_reminders.json", operation: "GetQuestionReminders")
+          params = compact_query_params(page: page)
+          paginate("/my/question_reminders.json", params: params, operation: "GetQuestionReminders", max_items: max_items)
         end
       end
 
@@ -47,10 +50,13 @@ module Basecamp
 
       # List all questions in a questionnaire
       # @param questionnaire_id [Integer] questionnaire id ID
-      # @return [Enumerator<Hash>] paginated results
-      def list_questions(questionnaire_id:)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list_questions(questionnaire_id:, page: nil, max_items: nil)
         wrap_paginated(service: "checkins", operation: "list_questions", is_mutation: false, resource_id: questionnaire_id) do
-          paginate("/questionnaires/#{questionnaire_id}/questions.json", operation: "ListQuestions")
+          params = compact_query_params(page: page)
+          paginate("/questionnaires/#{questionnaire_id}/questions.json", params: params, operation: "ListQuestions", max_items: max_items)
         end
       end
 
@@ -89,10 +95,13 @@ module Basecamp
 
       # List all answers for a question
       # @param question_id [Integer] question id ID
-      # @return [Enumerator<Hash>] paginated results
-      def list_answers(question_id:)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list_answers(question_id:, page: nil, max_items: nil)
         wrap_paginated(service: "checkins", operation: "list_answers", is_mutation: false, resource_id: question_id) do
-          paginate("/questions/#{question_id}/answers.json", operation: "ListAnswers")
+          params = compact_query_params(page: page)
+          paginate("/questions/#{question_id}/answers.json", params: params, operation: "ListAnswers", max_items: max_items)
         end
       end
 
@@ -109,20 +118,24 @@ module Basecamp
 
       # List all people who have answered a question (answerers)
       # @param question_id [Integer] question id ID
-      # @return [Enumerator<Hash>] paginated results
-      def answerers(question_id:)
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def answerers(question_id:, max_items: nil)
         wrap_paginated(service: "checkins", operation: "answerers", is_mutation: false, resource_id: question_id) do
-          paginate("/questions/#{question_id}/answers/by.json", operation: "ListQuestionAnswerers")
+          paginate("/questions/#{question_id}/answers/by.json", operation: "ListQuestionAnswerers", max_items: max_items)
         end
       end
 
       # Get all answers from a specific person for a question
       # @param question_id [Integer] question id ID
       # @param person_id [Integer] person id ID
-      # @return [Enumerator<Hash>] paginated results
-      def by_person(question_id:, person_id:)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def by_person(question_id:, person_id:, page: nil, max_items: nil)
         wrap_paginated(service: "checkins", operation: "by_person", is_mutation: false, resource_id: person_id) do
-          paginate("/questions/#{question_id}/answers/by/#{person_id}", operation: "GetAnswersByPerson")
+          params = compact_query_params(page: page)
+          paginate("/questions/#{question_id}/answers/by/#{person_id}", params: params, operation: "GetAnswersByPerson", max_items: max_items)
         end
       end
 

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

@@ -8,13 +8,16 @@ module Basecamp
     class ClientApprovalsService < BaseService
 
       # List all client approvals in a project
+      # @param bucket_id [Integer] bucket id ID
       # @param sort [String, nil] created_at|updated_at
       # @param direction [String, nil] asc|desc
-      # @return [Enumerator<Hash>] paginated results
-      def list(sort: nil, direction: nil)
-        wrap_paginated(service: "clientapprovals", operation: "list", is_mutation: false) do
-          params = compact_query_params(sort: sort, direction: direction)
-          paginate("/client/approvals.json", params: params, operation: "ListClientApprovals")
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list(bucket_id:, sort: nil, direction: nil, page: nil, max_items: nil)
+        wrap_paginated(service: "clientapprovals", operation: "list", is_mutation: false, project_id: bucket_id) do
+          params = compact_query_params(sort: sort, direction: direction, page: page)
+          paginate("/buckets/#{bucket_id}/client/approvals.json", params: params, operation: "ListClientApprovals", max_items: max_items)
         end
       end
 

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

@@ -8,13 +8,16 @@ module Basecamp
     class ClientCorrespondencesService < BaseService
 
       # List all client correspondences in a project
+      # @param bucket_id [Integer] bucket id ID
       # @param sort [String, nil] created_at|updated_at
       # @param direction [String, nil] asc|desc
-      # @return [Enumerator<Hash>] paginated results
-      def list(sort: nil, direction: nil)
-        wrap_paginated(service: "clientcorrespondences", operation: "list", is_mutation: false) do
-          params = compact_query_params(sort: sort, direction: direction)
-          paginate("/client/correspondences.json", params: params, operation: "ListClientCorrespondences")
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list(bucket_id:, sort: nil, direction: nil, page: nil, max_items: nil)
+        wrap_paginated(service: "clientcorrespondences", operation: "list", is_mutation: false, project_id: bucket_id) do
+          params = compact_query_params(sort: sort, direction: direction, page: page)
+          paginate("/buckets/#{bucket_id}/client/correspondences.json", params: params, operation: "ListClientCorrespondences", max_items: max_items)
         end
       end
 

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

@@ -8,21 +8,26 @@ module Basecamp
     class ClientRepliesService < BaseService
 
       # List all client replies for a recording (correspondence or approval)
+      # @param bucket_id [Integer] bucket id ID
       # @param recording_id [Integer] recording id ID
-      # @return [Enumerator<Hash>] paginated results
-      def list(recording_id:)
-        wrap_paginated(service: "clientreplies", operation: "list", is_mutation: false, resource_id: recording_id) do
-          paginate("/client/recordings/#{recording_id}/replies.json", operation: "ListClientReplies")
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list(bucket_id:, recording_id:, page: nil, max_items: nil)
+        wrap_paginated(service: "clientreplies", operation: "list", is_mutation: false, project_id: bucket_id, resource_id: recording_id) do
+          params = compact_query_params(page: page)
+          paginate("/buckets/#{bucket_id}/client/recordings/#{recording_id}/replies.json", params: params, operation: "ListClientReplies", max_items: max_items)
         end
       end
 
       # Get a single client reply by id
+      # @param bucket_id [Integer] bucket id ID
       # @param recording_id [Integer] recording id ID
       # @param reply_id [Integer] reply id ID
       # @return [Hash] response data
-      def get(recording_id:, reply_id:)
-        with_operation(service: "clientreplies", operation: "get", is_mutation: false, resource_id: reply_id) do
-          http_get("/client/recordings/#{recording_id}/replies/#{reply_id}", operation: "GetClientReply").json
+      def get(bucket_id:, recording_id:, reply_id:)
+        with_operation(service: "clientreplies", operation: "get", is_mutation: false, project_id: bucket_id, resource_id: reply_id) do
+          http_get("/buckets/#{bucket_id}/client/recordings/#{recording_id}/replies/#{reply_id}", operation: "GetClientReply").json
         end
       end
     end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Basecamp
+  module Services
+    # Service for CloudFiles operations
+    #
+    # @generated from OpenAPI spec
+    class CloudFilesService < BaseService
+
+      # Create a new cloud file in a vault.
+      # @param bucket_id [Integer] bucket id ID
+      # @param vault_id [Integer] vault id ID
+      # @param url [String] url
+      # @param service [String] Short identifier for the external service — "dropbox", "google_doc",
+      #   "figma", "other", … Derived from the CloudFile::Service subclass name, so it
+      #   is always present. `other` accepts any well-formed HTTPS URL.
+      # @param title [String, nil] title
+      # @param description [String, nil] description
+      # @param subscriptions [Array, nil] subscriptions
+      # @param visible_to_clients [Boolean, nil] Whether the cloud file is visible to the project's clients. Applies only
+      #   when creating directly in the tool's vault — an item created inside a
+      #   folder inherits the folder's visibility and ignores this. A client caller
+      #   always creates client-visible records regardless of what is sent.
+      # @return [Hash] response data
+      def create_cloud_file(bucket_id:, vault_id:, url:, service:, title: nil, description: nil, subscriptions: nil, visible_to_clients: nil)
+        with_operation(service: "cloudfiles", operation: "create_cloud_file", is_mutation: true, project_id: bucket_id, resource_id: vault_id) do
+          http_post("/buckets/#{bucket_id}/vaults/#{vault_id}/cloud_files.json", body: compact_params(url: url, service: service, title: title, description: description, subscriptions: subscriptions, visible_to_clients: visible_to_clients)).json
+        end
+      end
+
+      # Get a single cloud file by id
+      # @param cloud_file_id [Integer] cloud file id ID
+      # @return [Hash] response data
+      def get_cloud_file(cloud_file_id:)
+        with_operation(service: "cloudfiles", operation: "get_cloud_file", is_mutation: false, resource_id: cloud_file_id) do
+          http_get("/cloud_files/#{cloud_file_id}", operation: "GetCloudFile").json
+        end
+      end
+
+      # Replace a cloud file with a new complete representation.
+      # @param cloud_file_id [Integer] cloud file id ID
+      # @param url [String] url
+      # @param service [String] Short identifier for the external service — "dropbox", "google_doc",
+      #   "figma", "other", … Derived from the CloudFile::Service subclass name, so it
+      #   is always present. `other` accepts any well-formed HTTPS URL.
+      # @param title [String, nil] title
+      # @param description [String, nil] description
+      # @param subscriptions [Array, nil] subscriptions
+      # @return [Hash] response data
+      def update_cloud_file(cloud_file_id:, url:, service:, title: nil, description: nil, subscriptions: nil)
+        with_operation(service: "cloudfiles", operation: "update_cloud_file", is_mutation: true, resource_id: cloud_file_id) do
+          http_put("/cloud_files/#{cloud_file_id}", body: compact_params(url: url, service: service, title: title, description: description, subscriptions: subscriptions)).json
+        end
+      end
+    end
+  end
+end

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

@@ -28,10 +28,13 @@ module Basecamp
 
       # List comments on a recording
       # @param recording_id [Integer] recording id ID
-      # @return [Enumerator<Hash>] paginated results
-      def list(recording_id:)
+      # @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.
+      # @param max_items [Integer, nil] cap on items yielded across pages; nil or non-positive means no cap
+      # @return [ListEnumerator<Hash>] lazily paginated results (#meta carries pagination metadata)
+      def list(recording_id:, page: nil, max_items: nil)
         wrap_paginated(service: "comments", operation: "list", is_mutation: false, resource_id: recording_id) do
-          paginate("/recordings/#{recording_id}/comments.json", operation: "ListComments")
+          params = compact_query_params(page: page)
+          paginate("/recordings/#{recording_id}/comments.json", params: params, operation: "ListComments", max_items: max_items)
         end
       end