@37signals/basecamp 0.9.0 → 0.10.0

package/src/generated/services/message-types.ts

@@ -55,24 +55,29 @@ export class MessageTypesService extends BaseService {
 
   /**
    * List message types in a project
+   * @param bucketId - The bucket ID
    * @param options - Optional query parameters
    * @returns All MessageType across all pages, with .meta.totalCount
    *
    * @example
    * ```ts
-   * const result = await client.messageTypes.list();
+   * const result = await client.messageTypes.list(123);
    * ```
    */
-  async list(options?: ListMessageTypeOptions): Promise<ListResult<MessageType>> {
+  async list(bucketId: number, options?: ListMessageTypeOptions): Promise<ListResult<MessageType>> {
     return this.requestPaginated(
       {
         service: "MessageTypes",
         operation: "ListMessageTypes",
         resourceType: "message_type",
         isMutation: false,
+        projectId: bucketId,
       },
       () =>
-        this.client.GET("/categories.json", {
+        this.client.GET("/buckets/{bucketId}/categories.json", {
+          params: {
+            path: { bucketId },
+          },
         })
       , options
     );
@@ -80,16 +85,17 @@ export class MessageTypesService extends BaseService {
 
   /**
    * Create a new message type in a project
+   * @param bucketId - The bucket ID
    * @param req - Message_type creation parameters
    * @returns The MessageType
    * @throws {BasecampError} If required fields are missing or invalid
    *
    * @example
    * ```ts
-   * const result = await client.messageTypes.create({ name: "My example", icon: "example" });
+   * const result = await client.messageTypes.create(123, { name: "My example", icon: "example" });
    * ```
    */
-  async create(req: CreateMessageTypeRequest): Promise<MessageType> {
+  async create(bucketId: number, req: CreateMessageTypeRequest): Promise<MessageType> {
     if (!req.name) {
       throw Errors.validation("Name is required");
     }
@@ -102,9 +108,13 @@ export class MessageTypesService extends BaseService {
         operation: "CreateMessageType",
         resourceType: "message_type",
         isMutation: true,
+        projectId: bucketId,
       },
       () =>
-        this.client.POST("/categories.json", {
+        this.client.POST("/buckets/{bucketId}/categories.json", {
+          params: {
+            path: { bucketId },
+          },
           body: {
             name: req.name,
             icon: req.icon,
@@ -116,28 +126,30 @@ export class MessageTypesService extends BaseService {
 
   /**
    * Get a single message type by id
+   * @param bucketId - The bucket ID
    * @param typeId - The type ID
    * @returns The MessageType
    * @throws {BasecampError} If the resource is not found
    *
    * @example
    * ```ts
-   * const result = await client.messageTypes.get(123);
+   * const result = await client.messageTypes.get(123, 123);
    * ```
    */
-  async get(typeId: number): Promise<MessageType> {
+  async get(bucketId: number, typeId: number): Promise<MessageType> {
     const response = await this.request(
       {
         service: "MessageTypes",
         operation: "GetMessageType",
         resourceType: "message_type",
         isMutation: false,
+        projectId: bucketId,
         resourceId: typeId,
       },
       () =>
-        this.client.GET("/categories/{typeId}", {
+        this.client.GET("/buckets/{bucketId}/categories/{typeId}", {
           params: {
-            path: { typeId },
+            path: { bucketId, typeId },
           },
         })
     );
@@ -146,6 +158,7 @@ export class MessageTypesService extends BaseService {
 
   /**
    * Update an existing message type
+   * @param bucketId - The bucket ID
    * @param typeId - The type ID
    * @param req - Message_type update parameters
    * @returns The MessageType
@@ -153,22 +166,23 @@ export class MessageTypesService extends BaseService {
    *
    * @example
    * ```ts
-   * const result = await client.messageTypes.update(123, { });
+   * const result = await client.messageTypes.update(123, 123, { });
    * ```
    */
-  async update(typeId: number, req: UpdateMessageTypeRequest): Promise<MessageType> {
+  async update(bucketId: number, typeId: number, req: UpdateMessageTypeRequest): Promise<MessageType> {
     const response = await this.request(
       {
         service: "MessageTypes",
         operation: "UpdateMessageType",
         resourceType: "message_type",
         isMutation: true,
+        projectId: bucketId,
         resourceId: typeId,
       },
       () =>
-        this.client.PUT("/categories/{typeId}", {
+        this.client.PUT("/buckets/{bucketId}/categories/{typeId}", {
           params: {
-            path: { typeId },
+            path: { bucketId, typeId },
           },
           body: {
             name: req.name,
@@ -181,28 +195,30 @@ export class MessageTypesService extends BaseService {
 
   /**
    * Delete a message type
+   * @param bucketId - The bucket ID
    * @param typeId - The type ID
    * @returns void
    * @throws {BasecampError} If the request fails
    *
    * @example
    * ```ts
-   * await client.messageTypes.delete(123);
+   * await client.messageTypes.delete(123, 123);
    * ```
    */
-  async delete(typeId: number): Promise<void> {
+  async delete(bucketId: number, typeId: number): Promise<void> {
     await this.request(
       {
         service: "MessageTypes",
         operation: "DeleteMessageType",
         resourceType: "message_type",
         isMutation: true,
+        projectId: bucketId,
         resourceId: typeId,
       },
       () =>
-        this.client.DELETE("/categories/{typeId}", {
+        this.client.DELETE("/buckets/{bucketId}/categories/{typeId}", {
           params: {
-            path: { typeId },
+            path: { bucketId, typeId },
           },
         })
     );

package/src/generated/services/my-notifications.ts

@@ -6,12 +6,16 @@
 
 import { BaseService } from "../../services/base.js";
 import type { components } from "../schema.js";
+import { ListResult } from "../../pagination.js";
+import type { PaginationOptions } from "../../pagination.js";
 import { Errors } from "../../errors.js";
 
 // =============================================================================
 // Types
 // =============================================================================
 
+/** Notification entity from the Basecamp API. */
+export type Notification = components["schemas"]["Notification"];
 
 /**
  * Options for myNotifications.
@@ -19,6 +23,19 @@ import { Errors } from "../../errors.js";
 export interface MyNotificationsMyNotificationOptions {
   /** Page number for paginating through read items. Defaults to 1. */
   page?: number;
+  /** Set to true to cap `bubble_ups` at 2 current bubble-ups and omit the
+`scheduled_bubble_ups` key entirely. Defaults to false. Use the dedicated
+bubble-ups endpoint (GetBubbleUps) to page through all current and
+scheduled bubble-ups. */
+  limitBubbleUps?: boolean;
+}
+
+/**
+ * Options for bubbleUps.
+ */
+export interface BubbleUpsMyNotificationOptions extends PaginationOptions {
+  /** Page number. Defaults to 1. */
+  page?: number;
 }
 
 /**
@@ -60,13 +77,41 @@ export class MyNotificationsService extends BaseService {
       () =>
         this.client.GET("/my/readings.json", {
           params: {
-            query: { page: options?.page },
+            query: { page: options?.page, "limit_bubble_ups": options?.limitBubbleUps },
           },
         })
     );
     return response;
   }
 
+  /**
+   * Get the current user's current and scheduled bubble-ups (paginated, 50 per page).
+   * @param options - Optional query parameters
+   * @returns All Notification across all pages, with .meta.totalCount
+   *
+   * @example
+   * ```ts
+   * const result = await client.myNotifications.bubbleUps();
+   * ```
+   */
+  async bubbleUps(options?: BubbleUpsMyNotificationOptions): Promise<ListResult<Notification>> {
+    return this.requestPaginated(
+      {
+        service: "MyNotifications",
+        operation: "GetBubbleUps",
+        resourceType: "bubble_up",
+        isMutation: false,
+      },
+      () =>
+        this.client.GET("/my/readings/bubble_ups.json", {
+          params: {
+            query: { page: options?.page },
+          },
+        })
+      , options
+    );
+  }
+
   /**
    * Mark specified items as read
    * @param req - Resource request parameters

package/src/generated/services/recordings.ts

@@ -42,7 +42,7 @@ export class RecordingsService extends BaseService {
 
   /**
    * List recordings of a given type across projects
-   * @param type - Comment|Document|Kanban::Card|Kanban::Step|Message|Question::Answer|Schedule::Entry|Todo|Todolist|Upload|Vault
+   * @param type - Comment|Document|Door|Kanban::Card|Kanban::Step|Message|Question::Answer|Schedule::Entry|Todo|Todolist|Upload|Vault
    * @param options - Optional query parameters
    * @returns All Recording across all pages, with .meta.totalCount
    *
@@ -54,7 +54,7 @@ export class RecordingsService extends BaseService {
    * const filtered = await client.recordings.list("type", { bucket: [123] });
    * ```
    */
-  async list(type: "Comment" | "Document" | "Kanban::Card" | "Kanban::Step" | "Message" | "Question::Answer" | "Schedule::Entry" | "Todo" | "Todolist" | "Upload" | "Vault", options?: ListRecordingOptions): Promise<ListResult<Recording>> {
+  async list(type: "Comment" | "Document" | "Door" | "Kanban::Card" | "Kanban::Step" | "Message" | "Question::Answer" | "Schedule::Entry" | "Todo" | "Todolist" | "Upload" | "Vault", options?: ListRecordingOptions): Promise<ListResult<Recording>> {
     return this.requestPaginated(
       {
         service: "Recordings",

package/src/generated/services/schedules.ts

@@ -31,7 +31,15 @@ export interface UpdateEntryScheduleRequest {
   endsAt?: string;
   /** Rich text description (HTML) */
   description?: string;
-  /** Participant ids */
+  /** Replaces the entry's participants.
+
+Omitting this member preserves the current participants; sending an empty
+array clears them. That guarantee is BC3-side and recent: until
+basecamp/bc3#12425, `Schedules::EntriesController#update` called
+`replace_participants` unconditionally, so any update omitting the key —
+including the shape in BC3's own "Update a schedule entry" doc example —
+silently removed every participant and notified each one. The controller
+now guards on the request actually addressing participants. */
   participantIds?: number[];
   /** All day */
   allDay?: boolean;

package/src/generated/services/tools.ts

@@ -23,6 +23,8 @@ export interface CreateToolRequest {
   toolType: string;
   /** Title for the new tool. When omitted, Basecamp assigns the next available default title for the tool type. */
   title?: string;
+  /** Create the tool already visible to clients. Honored only for tool types that manage their own client visibility (Chat::Transcript, Kanban::Board), which otherwise start hidden; every other tool type ignores it and inherits the project default. */
+  visibleToClients?: boolean;
 }
 
 /**
@@ -83,6 +85,7 @@ export class ToolsService extends BaseService {
           body: {
             tool_type: req.toolType,
             title: req.title,
+            visible_to_clients: req.visibleToClients,
           },
         })
     );