basecamp-client 1.0.1

package/dist/index.mjs

@@ -0,0 +1,3180 @@
+// src/buildClient.ts
+import { initClient as tsRestInitClient } from "@ts-rest/core";
+
+// src/contract/index.ts
+import { z as z59 } from "zod";
+
+// src/contract/c.ts
+import { initContract } from "@ts-rest/core";
+var c = initContract();
+
+// src/contract/resources/communications/message-boards.ts
+import { z as z3 } from "zod";
+
+// src/contract/schemas/common.ts
+import { z } from "zod";
+var BasecampIdSchema = z.number().int().nonnegative();
+var BasecampIdParamSchema = z.coerce.number().int().nonnegative();
+var IsoDateTimeSchema = z.string().datetime({ offset: true });
+var IsoDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be formatted as YYYY-MM-DD");
+var RecordingStatusSchema = z.enum(["active", "trashed"]).or(z.string());
+var HtmlStringSchema = z.string().min(0);
+var BucketRefSchema = z.object({
+  id: BasecampIdSchema,
+  name: z.string(),
+  type: z.string()
+});
+var RecordingRefSchema = z.object({
+  id: BasecampIdSchema,
+  title: z.string(),
+  type: z.string(),
+  url: z.string().url(),
+  app_url: z.string().url()
+});
+var PersonSummarySchema = z.object({
+  id: BasecampIdSchema,
+  attachable_sgid: z.string().min(1),
+  name: z.string(),
+  email_address: z.string().email().nullable(),
+  personable_type: z.string(),
+  title: z.string().nullable(),
+  bio: z.string().nullable(),
+  location: z.string().nullable(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  admin: z.boolean(),
+  owner: z.boolean(),
+  client: z.boolean(),
+  employee: z.boolean(),
+  time_zone: z.string(),
+  avatar_url: z.string().url(),
+  company: z.object({
+    id: BasecampIdSchema,
+    name: z.string()
+  }).optional(),
+  can_manage_projects: z.boolean(),
+  can_manage_people: z.boolean()
+});
+
+// src/contract/schemas/communications/message-boards.ts
+import { z as z2 } from "zod";
+var MessageBoardRecordingCoreSchema = z2.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z2.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z2.string(),
+  inherits_status: z2.boolean(),
+  type: z2.string(),
+  url: z2.string().url(),
+  app_url: z2.string().url(),
+  bookmark_url: z2.string().url().optional(),
+  position: z2.number().int().nonnegative().optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var MessageBoardSchema = MessageBoardRecordingCoreSchema.extend({
+  messages_count: z2.number().int().nonnegative(),
+  messages_url: z2.string().url(),
+  app_messages_url: z2.string().url()
+});
+var MessageBoardsResponseSchema = z2.array(MessageBoardSchema);
+
+// src/contract/resources/communications/message-boards.ts
+var bucketAndMessageBoardPathParams = z3.object({
+  bucketId: BasecampIdParamSchema,
+  messageBoardId: BasecampIdParamSchema
+});
+var projectPathParams = z3.object({
+  projectId: BasecampIdParamSchema
+});
+var messageBoardsRouter = c.router({
+  get: {
+    summary: "Get a message board",
+    description: "Return a message board container for a project.",
+    metadata: {
+      tag: "Message Boards",
+      operationId: "messageBoards.get",
+      docsPath: "/docs/basecamp-api-specs/sections/message_boards.md#get-message-board"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/message_boards/:messageBoardId",
+    pathParams: bucketAndMessageBoardPathParams,
+    responses: {
+      200: MessageBoardSchema
+    }
+  },
+  listForProject: {
+    summary: "List message boards for a project",
+    description: "Return message boards available for a project.",
+    metadata: {
+      tag: "Message Boards",
+      operationId: "messageBoards.listForProject",
+      docsPath: "/docs/basecamp-api-specs/sections/message_boards.md#get-message-board"
+    },
+    method: "GET",
+    path: "/projects/:projectId/message_boards",
+    pathParams: projectPathParams,
+    responses: {
+      200: MessageBoardsResponseSchema
+    }
+  }
+});
+
+// src/contract/resources/communications/message-types.ts
+import { z as z5 } from "zod";
+
+// src/contract/schemas/communications/message-types.ts
+import { z as z4 } from "zod";
+var MessageTypeSchema = z4.object({
+  id: BasecampIdSchema,
+  name: z4.string(),
+  icon: z4.string(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema
+});
+var MessageTypesResponseSchema = z4.array(MessageTypeSchema);
+var MessageTypeCreateBodySchema = z4.object({
+  name: z4.string().min(1),
+  icon: z4.string().min(1)
+});
+var MessageTypeUpdateBodySchema = z4.object({
+  name: z4.string().min(1).optional(),
+  icon: z4.string().min(1).optional()
+});
+
+// src/contract/resources/communications/message-types.ts
+var bucketPathParams = z5.object({
+  bucketId: BasecampIdParamSchema
+});
+var bucketAndCategoryPathParams = bucketPathParams.extend({
+  categoryId: BasecampIdParamSchema
+});
+var messageTypesRouter = c.router({
+  list: {
+    summary: "List message types",
+    description: "Return all message types (categories) available in a project.",
+    metadata: {
+      tag: "Message Types",
+      operationId: "messageTypes.list",
+      docsPath: "/docs/basecamp-api-specs/sections/message_types.md#get-message-types"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/categories",
+    pathParams: bucketPathParams,
+    responses: {
+      200: MessageTypesResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a message type",
+    description: "Return a specific message type by its ID.",
+    metadata: {
+      tag: "Message Types",
+      operationId: "messageTypes.get",
+      docsPath: "/docs/basecamp-api-specs/sections/message_types.md#get-a-message-type"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/categories/:categoryId",
+    pathParams: bucketAndCategoryPathParams,
+    responses: {
+      200: MessageTypeSchema
+    }
+  },
+  create: {
+    summary: "Create a message type",
+    description: "Create a new message type in a project.",
+    metadata: {
+      tag: "Message Types",
+      operationId: "messageTypes.create",
+      docsPath: "/docs/basecamp-api-specs/sections/message_types.md#create-a-message-type"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/categories",
+    pathParams: bucketPathParams,
+    body: MessageTypeCreateBodySchema,
+    responses: {
+      201: MessageTypeSchema
+    }
+  },
+  update: {
+    summary: "Update a message type",
+    description: "Update an existing message type.",
+    metadata: {
+      tag: "Message Types",
+      operationId: "messageTypes.update",
+      docsPath: "/docs/basecamp-api-specs/sections/message_types.md#update-a-message-type"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/categories/:categoryId",
+    pathParams: bucketAndCategoryPathParams,
+    body: MessageTypeUpdateBodySchema,
+    responses: {
+      200: MessageTypeSchema
+    }
+  },
+  destroy: {
+    summary: "Delete a message type",
+    description: "Delete a message type from a project.",
+    metadata: {
+      tag: "Message Types",
+      operationId: "messageTypes.destroy",
+      docsPath: "/docs/basecamp-api-specs/sections/message_types.md#destroy-a-message-type"
+    },
+    method: "DELETE",
+    path: "/buckets/:bucketId/categories/:categoryId",
+    pathParams: bucketAndCategoryPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/communications/messages.ts
+import { z as z7 } from "zod";
+
+// src/contract/schemas/communications/messages.ts
+import { z as z6 } from "zod";
+var MessageCoreSchema = z6.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z6.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  inherits_status: z6.boolean(),
+  type: z6.string(),
+  url: z6.string().url(),
+  app_url: z6.string().url(),
+  bookmark_url: z6.string().url().optional(),
+  subscription_url: z6.string().url().optional(),
+  comments_count: z6.number().int().nonnegative().optional(),
+  comments_url: z6.string().url().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var MessageSummarySchema = MessageCoreSchema.extend({
+  title: z6.string(),
+  content: HtmlStringSchema.optional()
+});
+var MessageSchema = MessageSummarySchema.extend({
+  subject: z6.string()
+});
+var MessageListResponseSchema = z6.array(MessageSummarySchema);
+var MessageListQuerySchema = z6.object({
+  page: z6.coerce.number().int().positive().optional()
+});
+var MessageCreateBodySchema = z6.object({
+  subject: z6.string().min(1),
+  status: z6.enum(["active", "draft"]).or(z6.string()),
+  content: HtmlStringSchema.optional(),
+  category_id: BasecampIdSchema.optional(),
+  subscriptions: z6.array(BasecampIdSchema).optional()
+});
+var MessageUpdateBodySchema = z6.object({
+  subject: z6.string().min(1).optional(),
+  content: HtmlStringSchema.optional(),
+  category_id: BasecampIdSchema.optional()
+}).refine(
+  (value) => Object.keys(value).length > 0,
+  "At least one field must be provided to update a message."
+);
+
+// src/contract/resources/communications/messages.ts
+var bucketAndBoardPathParams = z7.object({
+  bucketId: BasecampIdParamSchema,
+  messageBoardId: BasecampIdParamSchema
+});
+var bucketAndMessagePathParams = z7.object({
+  bucketId: BasecampIdParamSchema,
+  messageId: BasecampIdParamSchema
+});
+var messagesRouter = c.router({
+  list: {
+    summary: "List message board messages",
+    description: "Returns the messages currently visible on a message board. Pagination data is available via the Link and X-Total-Count headers.",
+    metadata: {
+      tag: "Messages",
+      operationId: "messages.list",
+      docsPath: "/docs/basecamp-api-specs/sections/messages.md#get-messages"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/message_boards/:messageBoardId/messages",
+    pathParams: bucketAndBoardPathParams,
+    query: MessageListQuerySchema,
+    responses: {
+      200: MessageListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a message",
+    description: "Fetch the full representation of a single message.",
+    metadata: {
+      tag: "Messages",
+      operationId: "messages.get",
+      docsPath: "/docs/basecamp-api-specs/sections/messages.md#get-a-message"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/messages/:messageId",
+    pathParams: bucketAndMessagePathParams,
+    responses: {
+      200: MessageSchema
+    }
+  },
+  create: {
+    summary: "Create a message",
+    description: 'Publish a message to a specific message board. Setting status to "active" makes the message visible immediately.',
+    metadata: {
+      tag: "Messages",
+      operationId: "messages.create",
+      docsPath: "/docs/basecamp-api-specs/sections/messages.md#create-a-message"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/message_boards/:messageBoardId/messages",
+    pathParams: bucketAndBoardPathParams,
+    body: MessageCreateBodySchema,
+    responses: {
+      201: MessageSchema
+    }
+  },
+  update: {
+    summary: "Update a message",
+    description: "Update the subject, content, or category of an existing message.",
+    metadata: {
+      tag: "Messages",
+      operationId: "messages.update",
+      docsPath: "/docs/basecamp-api-specs/sections/messages.md#update-a-message"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/messages/:messageId",
+    pathParams: bucketAndMessagePathParams,
+    body: MessageUpdateBodySchema,
+    responses: {
+      200: MessageSchema
+    }
+  },
+  pin: {
+    summary: "Pin a message",
+    description: "Pin a message recording. The same endpoint is used to pin other recording types.",
+    metadata: {
+      tag: "Messages",
+      operationId: "messages.pin",
+      docsPath: "/docs/basecamp-api-specs/sections/messages.md#pin-a-message"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/recordings/:messageId/pin",
+    pathParams: bucketAndMessagePathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  },
+  unpin: {
+    summary: "Unpin a message",
+    description: "Remove a pinned message. Returns no content on success.",
+    metadata: {
+      tag: "Messages",
+      operationId: "messages.unpin",
+      docsPath: "/docs/basecamp-api-specs/sections/messages.md#pin-a-message"
+    },
+    method: "DELETE",
+    path: "/buckets/:bucketId/recordings/:messageId/pin",
+    pathParams: bucketAndMessagePathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  },
+  trash: {
+    summary: "Trash a message",
+    description: "Move a message recording to the trash. Trashed items can be restored via the UI.",
+    metadata: {
+      tag: "Messages",
+      operationId: "messages.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:messageId/status/trashed",
+    pathParams: bucketAndMessagePathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/communications/comments.ts
+import { z as z9 } from "zod";
+
+// src/contract/schemas/communications/comments.ts
+import { z as z8 } from "zod";
+var CommentRecordingCoreSchema = z8.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z8.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z8.string(),
+  inherits_status: z8.boolean(),
+  type: z8.string(),
+  url: z8.string().url(),
+  app_url: z8.string().url(),
+  bookmark_url: z8.string().url().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var CommentSchema = CommentRecordingCoreSchema.extend({
+  content: HtmlStringSchema
+});
+var CommentsResponseSchema = z8.array(CommentSchema);
+var CommentListQuerySchema = z8.object({
+  page: z8.coerce.number().int().positive().optional()
+});
+var CommentCreateBodySchema = z8.object({
+  content: HtmlStringSchema.min(1)
+});
+var CommentUpdateBodySchema = z8.object({
+  content: HtmlStringSchema.min(1)
+});
+
+// src/contract/resources/communications/comments.ts
+var bucketAndRecordingPathParams = z9.object({
+  bucketId: BasecampIdParamSchema,
+  recordingId: BasecampIdParamSchema
+});
+var bucketAndCommentPathParams = z9.object({
+  bucketId: BasecampIdParamSchema,
+  commentId: BasecampIdParamSchema
+});
+var commentsRouter = c.router({
+  list: {
+    summary: "List comments",
+    description: "Return paginated comments for a recording.",
+    metadata: {
+      tag: "Comments",
+      operationId: "comments.list",
+      docsPath: "/docs/basecamp-api-specs/sections/comments.md#get-comments"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/recordings/:recordingId/comments",
+    pathParams: bucketAndRecordingPathParams,
+    query: CommentListQuerySchema,
+    responses: {
+      200: CommentsResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a comment",
+    description: "Return a specific comment by its ID.",
+    metadata: {
+      tag: "Comments",
+      operationId: "comments.get",
+      docsPath: "/docs/basecamp-api-specs/sections/comments.md#get-a-comment"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/comments/:commentId",
+    pathParams: bucketAndCommentPathParams,
+    responses: {
+      200: CommentSchema
+    }
+  },
+  create: {
+    summary: "Create a comment",
+    description: "Create a new comment on a recording.",
+    metadata: {
+      tag: "Comments",
+      operationId: "comments.create",
+      docsPath: "/docs/basecamp-api-specs/sections/comments.md#create-a-comment"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/recordings/:recordingId/comments",
+    pathParams: bucketAndRecordingPathParams,
+    body: CommentCreateBodySchema,
+    responses: {
+      201: CommentSchema
+    }
+  },
+  update: {
+    summary: "Update a comment",
+    description: "Update an existing comment.",
+    metadata: {
+      tag: "Comments",
+      operationId: "comments.update",
+      docsPath: "/docs/basecamp-api-specs/sections/comments.md#update-a-comment"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/comments/:commentId",
+    pathParams: bucketAndCommentPathParams,
+    body: CommentUpdateBodySchema,
+    responses: {
+      200: CommentSchema
+    }
+  },
+  trash: {
+    summary: "Trash a comment",
+    description: "Move a comment to the trash.",
+    metadata: {
+      tag: "Comments",
+      operationId: "comments.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:commentId/status/trashed",
+    pathParams: bucketAndCommentPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/communications/campfires.ts
+import { z as z11 } from "zod";
+
+// src/contract/schemas/communications/campfires.ts
+import { z as z10 } from "zod";
+var CampfireSchema = z10.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z10.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z10.string(),
+  inherits_status: z10.boolean(),
+  type: z10.string(),
+  url: z10.string().url(),
+  app_url: z10.string().url(),
+  bookmark_url: z10.string().url().optional(),
+  subscription_url: z10.string().url().optional(),
+  position: z10.number().int().optional(),
+  topic: z10.string(),
+  lines_url: z10.string().url(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var CampfireListResponseSchema = z10.array(CampfireSchema);
+var CampfireListQuerySchema = z10.object({
+  page: z10.coerce.number().int().positive().optional()
+});
+var CampfireLineSchema = z10.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z10.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z10.string(),
+  inherits_status: z10.boolean(),
+  type: z10.string(),
+  url: z10.string().url(),
+  app_url: z10.string().url(),
+  bookmark_url: z10.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: z10.string()
+});
+var CampfireLineListResponseSchema = z10.array(CampfireLineSchema);
+var CampfireLineListQuerySchema = z10.object({
+  page: z10.coerce.number().int().positive().optional()
+});
+var CampfireLineCreateBodySchema = z10.object({
+  content: z10.string().min(1)
+});
+
+// src/contract/resources/communications/campfires.ts
+var CampfirePathParamsSchema = z11.object({
+  bucketId: BasecampIdParamSchema,
+  campfireId: BasecampIdParamSchema
+});
+var CampfireLinePathParamsSchema = CampfirePathParamsSchema.extend({
+  lineId: BasecampIdParamSchema
+});
+var campfiresRouter = c.router({
+  list: {
+    summary: "List Campfires",
+    description: "Returns the Campfires visible to the authenticated user. Results are paginated via Link headers.",
+    metadata: {
+      tag: "Campfires",
+      operationId: "campfires.list",
+      docsPath: "/docs/basecamp-api-specs/sections/campfires.md#get-campfires"
+    },
+    method: "GET",
+    path: "/chats",
+    query: CampfireListQuerySchema,
+    responses: {
+      200: CampfireListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a Campfire",
+    description: "Fetch a single Campfire transcript for a project.",
+    metadata: {
+      tag: "Campfires",
+      operationId: "campfires.get",
+      docsPath: "/docs/basecamp-api-specs/sections/campfires.md#get-a-campfire"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/chats/:campfireId",
+    pathParams: CampfirePathParamsSchema,
+    responses: {
+      200: CampfireSchema
+    }
+  },
+  listLines: {
+    summary: "List Campfire lines",
+    description: "Return paginated chat lines for a Campfire transcript.",
+    metadata: {
+      tag: "Campfires",
+      operationId: "campfires.listLines",
+      docsPath: "/docs/basecamp-api-specs/sections/campfires.md#get-campfire-lines"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/chats/:campfireId/lines",
+    pathParams: CampfirePathParamsSchema,
+    query: CampfireLineListQuerySchema,
+    responses: {
+      200: CampfireLineListResponseSchema
+    }
+  },
+  getLine: {
+    summary: "Get a Campfire line",
+    description: "Fetch a single Campfire line by identifier.",
+    metadata: {
+      tag: "Campfires",
+      operationId: "campfires.getLine",
+      docsPath: "/docs/basecamp-api-specs/sections/campfires.md#get-a-campfire-line"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/chats/:campfireId/lines/:lineId",
+    pathParams: CampfireLinePathParamsSchema,
+    responses: {
+      200: CampfireLineSchema
+    }
+  },
+  createLine: {
+    summary: "Create a Campfire line",
+    description: "Post a new line of chat to a Campfire transcript.",
+    metadata: {
+      tag: "Campfires",
+      operationId: "campfires.createLine",
+      docsPath: "/docs/basecamp-api-specs/sections/campfires.md#create-a-campfire-line"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/chats/:campfireId/lines",
+    pathParams: CampfirePathParamsSchema,
+    body: CampfireLineCreateBodySchema,
+    responses: {
+      201: CampfireLineSchema
+    }
+  },
+  deleteLine: {
+    summary: "Delete a Campfire line",
+    description: "Delete a Campfire line permanently.",
+    metadata: {
+      tag: "Campfires",
+      operationId: "campfires.deleteLine",
+      docsPath: "/docs/basecamp-api-specs/sections/campfires.md#delete-a-campfire-line"
+    },
+    method: "DELETE",
+    path: "/buckets/:bucketId/chats/:campfireId/lines/:lineId",
+    pathParams: CampfireLinePathParamsSchema,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/communications/inboxes.ts
+import { z as z13 } from "zod";
+
+// src/contract/schemas/communications/inboxes.ts
+import { z as z12 } from "zod";
+var InboxSchema = z12.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z12.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z12.string(),
+  inherits_status: z12.boolean(),
+  type: z12.string(),
+  url: z12.string().url(),
+  app_url: z12.string().url(),
+  bookmark_url: z12.string().url().optional(),
+  position: z12.number().int().optional(),
+  forwards_count: z12.number().int().nonnegative().optional(),
+  forwards_url: z12.string().url().optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+
+// src/contract/resources/communications/inboxes.ts
+var InboxPathParamsSchema = z13.object({
+  bucketId: BasecampIdParamSchema,
+  inboxId: BasecampIdParamSchema
+});
+var inboxesRouter = c.router({
+  get: {
+    summary: "Get an inbox",
+    description: "Return the inbox container for a project. Use the forwards endpoint to list mail forwards associated with the inbox.",
+    metadata: {
+      tag: "Inboxes",
+      operationId: "inboxes.get",
+      docsPath: "/docs/basecamp-api-specs/sections/inboxes.md#get-inbox"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/inboxes/:inboxId",
+    pathParams: InboxPathParamsSchema,
+    responses: {
+      200: InboxSchema
+    }
+  }
+});
+
+// src/contract/resources/communications/forwards.ts
+import { z as z15 } from "zod";
+
+// src/contract/schemas/communications/forwards.ts
+import { z as z14 } from "zod";
+var ForwardSchema = z14.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z14.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z14.string(),
+  inherits_status: z14.boolean(),
+  type: z14.string(),
+  url: z14.string().url(),
+  app_url: z14.string().url(),
+  bookmark_url: z14.string().url().optional(),
+  subscription_url: z14.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: z14.string(),
+  subject: z14.string(),
+  from: z14.string().nullable().optional(),
+  replies_count: z14.number().int().nonnegative(),
+  replies_url: z14.string().url()
+});
+var ForwardListResponseSchema = z14.array(ForwardSchema);
+var ForwardListQuerySchema = z14.object({
+  page: z14.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/forwards.ts
+var ForwardListPathParamsSchema = z15.object({
+  bucketId: BasecampIdParamSchema,
+  inboxId: BasecampIdParamSchema
+});
+var ForwardPathParamsSchema = z15.object({
+  bucketId: BasecampIdParamSchema,
+  forwardId: BasecampIdParamSchema
+});
+var forwardsRouter = c.router({
+  list: {
+    summary: "List forwards",
+    description: "Returns the email forwards that live under a project inbox. Results are paginated via Link headers.",
+    metadata: {
+      tag: "Forwards",
+      operationId: "forwards.list",
+      docsPath: "/docs/basecamp-api-specs/sections/forwards.md#get-forwards"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/inboxes/:inboxId/forwards",
+    pathParams: ForwardListPathParamsSchema,
+    query: ForwardListQuerySchema,
+    responses: {
+      200: ForwardListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a forward",
+    description: "Fetch a single email forward recording.",
+    metadata: {
+      tag: "Forwards",
+      operationId: "forwards.get",
+      docsPath: "/docs/basecamp-api-specs/sections/forwards.md#get-a-forward"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/inbox_forwards/:forwardId",
+    pathParams: ForwardPathParamsSchema,
+    responses: {
+      200: ForwardSchema
+    }
+  },
+  trash: {
+    summary: "Trash a forward",
+    description: "Move a forward to the trash. Trashed forwards can be restored from the Basecamp UI if needed.",
+    metadata: {
+      tag: "Forwards",
+      operationId: "forwards.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:forwardId/status/trashed",
+    pathParams: ForwardPathParamsSchema,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/communications/inbox-replies.ts
+import { z as z17 } from "zod";
+
+// src/contract/schemas/communications/inbox-replies.ts
+import { z as z16 } from "zod";
+var InboxReplySchema = z16.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z16.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z16.string(),
+  inherits_status: z16.boolean(),
+  type: z16.string(),
+  url: z16.string().url(),
+  app_url: z16.string().url(),
+  bookmark_url: z16.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema
+});
+var InboxReplyListResponseSchema = z16.array(InboxReplySchema);
+var InboxReplyListQuerySchema = z16.object({
+  page: z16.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/inbox-replies.ts
+var InboxReplyListPathParamsSchema = z17.object({
+  bucketId: BasecampIdParamSchema,
+  forwardId: BasecampIdParamSchema
+});
+var InboxReplyPathParamsSchema = InboxReplyListPathParamsSchema.extend({
+  replyId: BasecampIdParamSchema
+});
+var inboxRepliesRouter = c.router({
+  list: {
+    summary: "List inbox replies",
+    description: "Returns replies that were posted on a forwarded email.",
+    metadata: {
+      tag: "Inbox Replies",
+      operationId: "inboxReplies.list",
+      docsPath: "/docs/basecamp-api-specs/sections/inbox_replies.md#get-inbox-replies"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/inbox_forwards/:forwardId/replies",
+    pathParams: InboxReplyListPathParamsSchema,
+    query: InboxReplyListQuerySchema,
+    responses: {
+      200: InboxReplyListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get an inbox reply",
+    description: "Fetch a single reply posted to a forwarded email.",
+    metadata: {
+      tag: "Inbox Replies",
+      operationId: "inboxReplies.get",
+      docsPath: "/docs/basecamp-api-specs/sections/inbox_replies.md#get-an-inbox-reply"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/inbox_forwards/:forwardId/replies/:replyId",
+    pathParams: InboxReplyPathParamsSchema,
+    responses: {
+      200: InboxReplySchema
+    }
+  }
+});
+
+// src/contract/resources/communications/client-approvals.ts
+import { z as z19 } from "zod";
+
+// src/contract/schemas/communications/client-approvals.ts
+import { z as z18 } from "zod";
+var ApprovalStatusEnum = z18.enum(["pending", "approved", "rejected"]).or(z18.string());
+var ClientApprovalResponseSchema = z18.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z18.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z18.string(),
+  inherits_status: z18.boolean(),
+  type: z18.string(),
+  url: z18.string().url().optional(),
+  app_url: z18.string().url(),
+  bookmark_url: z18.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema,
+  approved: z18.boolean().optional()
+});
+var ClientApprovalSchema = z18.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z18.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z18.string(),
+  inherits_status: z18.boolean(),
+  type: z18.string(),
+  url: z18.string().url(),
+  app_url: z18.string().url(),
+  bookmark_url: z18.string().url().optional(),
+  subscription_url: z18.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema,
+  subject: z18.string(),
+  due_on: IsoDateSchema.nullable(),
+  replies_count: z18.number().int().nonnegative(),
+  replies_url: z18.string().url(),
+  approval_status: ApprovalStatusEnum,
+  approver: PersonSummarySchema.optional(),
+  responses: z18.array(ClientApprovalResponseSchema).optional()
+});
+var ClientApprovalListResponseSchema = z18.array(ClientApprovalSchema);
+var ClientApprovalListQuerySchema = z18.object({
+  page: z18.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/client-approvals.ts
+var ClientApprovalListPathParamsSchema = z19.object({
+  bucketId: BasecampIdParamSchema
+});
+var ClientApprovalPathParamsSchema = ClientApprovalListPathParamsSchema.extend({
+  approvalId: BasecampIdParamSchema
+});
+var clientApprovalsRouter = c.router({
+  list: {
+    summary: "List client approvals",
+    description: "Returns the client approvals that have been posted in a project. Results are paginated.",
+    metadata: {
+      tag: "Client Approvals",
+      operationId: "clientApprovals.list",
+      docsPath: "/docs/basecamp-api-specs/sections/client_approvals.md#get-client-approvals"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/client/approvals",
+    pathParams: ClientApprovalListPathParamsSchema,
+    query: ClientApprovalListQuerySchema,
+    responses: {
+      200: ClientApprovalListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a client approval",
+    description: "Fetch a specific client approval recording.",
+    metadata: {
+      tag: "Client Approvals",
+      operationId: "clientApprovals.get",
+      docsPath: "/docs/basecamp-api-specs/sections/client_approvals.md#get-a-client-approval"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/client/approvals/:approvalId",
+    pathParams: ClientApprovalPathParamsSchema,
+    responses: {
+      200: ClientApprovalSchema
+    }
+  }
+});
+
+// src/contract/resources/communications/client-correspondences.ts
+import { z as z21 } from "zod";
+
+// src/contract/schemas/communications/client-correspondences.ts
+import { z as z20 } from "zod";
+var ClientCorrespondenceSchema = z20.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z20.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z20.string(),
+  inherits_status: z20.boolean(),
+  type: z20.string(),
+  url: z20.string().url(),
+  app_url: z20.string().url(),
+  bookmark_url: z20.string().url().optional(),
+  subscription_url: z20.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema,
+  subject: z20.string(),
+  replies_count: z20.number().int().nonnegative(),
+  replies_url: z20.string().url()
+});
+var ClientCorrespondenceListResponseSchema = z20.array(ClientCorrespondenceSchema);
+var ClientCorrespondenceListQuerySchema = z20.object({
+  page: z20.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/client-correspondences.ts
+var ClientCorrespondenceListPathParamsSchema = z21.object({
+  bucketId: BasecampIdParamSchema
+});
+var ClientCorrespondencePathParamsSchema = ClientCorrespondenceListPathParamsSchema.extend({
+  correspondenceId: BasecampIdParamSchema
+});
+var clientCorrespondencesRouter = c.router({
+  list: {
+    summary: "List client correspondences",
+    description: "Returns the client correspondences posted in a project.",
+    metadata: {
+      tag: "Client Correspondences",
+      operationId: "clientCorrespondences.list",
+      docsPath: "/docs/basecamp-api-specs/sections/client_correspondences.md#get-client-correspondences"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/client/correspondences",
+    pathParams: ClientCorrespondenceListPathParamsSchema,
+    query: ClientCorrespondenceListQuerySchema,
+    responses: {
+      200: ClientCorrespondenceListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a client correspondence",
+    description: "Fetch a specific client correspondence recording.",
+    metadata: {
+      tag: "Client Correspondences",
+      operationId: "clientCorrespondences.get",
+      docsPath: "/docs/basecamp-api-specs/sections/client_correspondences.md#get-a-client-correspondence"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/client/correspondences/:correspondenceId",
+    pathParams: ClientCorrespondencePathParamsSchema,
+    responses: {
+      200: ClientCorrespondenceSchema
+    }
+  }
+});
+
+// src/contract/resources/communications/client-replies.ts
+import { z as z23 } from "zod";
+
+// src/contract/schemas/communications/client-replies.ts
+import { z as z22 } from "zod";
+var ClientReplySchema = z22.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z22.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z22.string(),
+  inherits_status: z22.boolean(),
+  type: z22.string(),
+  url: z22.string().url(),
+  app_url: z22.string().url(),
+  bookmark_url: z22.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema
+});
+var ClientReplyListResponseSchema = z22.array(ClientReplySchema);
+var ClientReplyListQuerySchema = z22.object({
+  page: z22.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/client-replies.ts
+var ClientReplyListPathParamsSchema = z23.object({
+  bucketId: BasecampIdParamSchema,
+  recordingId: BasecampIdParamSchema
+});
+var ClientReplyPathParamsSchema = ClientReplyListPathParamsSchema.extend({
+  replyId: BasecampIdParamSchema
+});
+var clientRepliesRouter = c.router({
+  list: {
+    summary: "List client replies",
+    description: "Returns replies that clients posted to client correspondences or client approvals.",
+    metadata: {
+      tag: "Client Replies",
+      operationId: "clientReplies.list",
+      docsPath: "/docs/basecamp-api-specs/sections/client_replies.md#get-client-replies"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/client/recordings/:recordingId/replies",
+    pathParams: ClientReplyListPathParamsSchema,
+    query: ClientReplyListQuerySchema,
+    responses: {
+      200: ClientReplyListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a client reply",
+    description: "Fetch a single reply posted by a client.",
+    metadata: {
+      tag: "Client Replies",
+      operationId: "clientReplies.get",
+      docsPath: "/docs/basecamp-api-specs/sections/client_replies.md#get-a-client-reply"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/client/recordings/:recordingId/replies/:replyId",
+    pathParams: ClientReplyPathParamsSchema,
+    responses: {
+      200: ClientReplySchema
+    }
+  }
+});
+
+// src/contract/resources/communications/client-visibility.ts
+import { z as z26 } from "zod";
+
+// src/contract/schemas/communications/client-visibility.ts
+import { z as z25 } from "zod";
+
+// src/contract/schemas/recordings.ts
+import { z as z24 } from "zod";
+var KnownRecordingTypeSchema = z24.enum([
+  "Comment",
+  "Document",
+  "Kanban::Card",
+  "Kanban::Step",
+  "Message",
+  "Question::Answer",
+  "Schedule::Entry",
+  "Todo",
+  "Todolist",
+  "Upload",
+  "Vault"
+]);
+var RecordingTypeSchema = KnownRecordingTypeSchema.or(z24.string());
+var RecordingSummarySchema = z24.object({
+  id: BasecampIdSchema,
+  type: z24.string(),
+  status: RecordingStatusSchema.optional(),
+  title: z24.string().optional(),
+  created_at: IsoDateTimeSchema.optional(),
+  updated_at: IsoDateTimeSchema.optional(),
+  url: z24.string().url(),
+  app_url: z24.string().url(),
+  bucket: BucketRefSchema.optional(),
+  parent: RecordingRefSchema.optional(),
+  creator: PersonSummarySchema.optional()
+}).passthrough();
+var RecordingListResponseSchema = z24.array(RecordingSummarySchema);
+var RecordingListQuerySchema = z24.object({
+  type: RecordingTypeSchema,
+  bucket: z24.string().optional(),
+  status: RecordingStatusSchema.optional(),
+  sort: z24.enum(["created_at", "updated_at"]).or(z24.string()).optional(),
+  direction: z24.enum(["asc", "desc"]).or(z24.string()).optional(),
+  page: z24.coerce.number().int().positive().optional()
+});
+
+// src/contract/schemas/communications/client-visibility.ts
+var ClientVisibilityUpdateBodySchema = z25.object({
+  visible_to_clients: z25.boolean()
+});
+var ClientVisibilityRecordingSchema = RecordingSummarySchema.extend({
+  visible_to_clients: z25.boolean().optional()
+});
+
+// src/contract/resources/communications/client-visibility.ts
+var ClientVisibilityPathParamsSchema = z26.object({
+  bucketId: BasecampIdParamSchema,
+  recordingId: BasecampIdParamSchema
+});
+var clientVisibilityRouter = c.router({
+  update: {
+    summary: "Toggle client visibility",
+    description: "Update whether a recording is visible to clients. Only recordings that control their own visibility can be toggled.",
+    metadata: {
+      tag: "Client Visibility",
+      operationId: "clientVisibility.update",
+      docsPath: "/docs/basecamp-api-specs/sections/client_visibility.md#toggle-client-visibility"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:recordingId/client_visibility",
+    pathParams: ClientVisibilityPathParamsSchema,
+    body: ClientVisibilityUpdateBodySchema,
+    responses: {
+      200: ClientVisibilityRecordingSchema
+    }
+  }
+});
+
+// src/contract/resources/documents/documents.ts
+import { z as z31 } from "zod";
+
+// src/contract/schemas/documents/documents.ts
+import { z as z27 } from "zod";
+var DocumentCoreSchema = z27.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z27.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z27.string(),
+  inherits_status: z27.boolean(),
+  type: z27.literal("Document"),
+  url: z27.string().url(),
+  app_url: z27.string().url(),
+  bookmark_url: z27.string().url(),
+  subscription_url: z27.string().url(),
+  comments_count: z27.number().int().nonnegative(),
+  comments_url: z27.string().url(),
+  position: z27.number().int().nonnegative(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var DocumentSchema = DocumentCoreSchema.extend({
+  content: HtmlStringSchema
+});
+var DocumentListResponseSchema = z27.array(DocumentSchema);
+var DocumentListQuerySchema = z27.object({
+  page: z27.coerce.number().int().positive().optional()
+});
+var DocumentCreateBodySchema = z27.object({
+  title: z27.string().min(1),
+  content: HtmlStringSchema,
+  status: z27.enum(["active", "draft"]).or(z27.string()).optional()
+});
+var DocumentUpdateBodySchema = z27.object({
+  title: z27.string().min(1).optional(),
+  content: HtmlStringSchema.optional()
+}).refine(
+  (value) => Object.keys(value).length > 0,
+  "At least one field must be provided to update a document."
+);
+
+// src/contract/schemas/documents/vaults.ts
+import { z as z28 } from "zod";
+var VaultCoreSchema = z28.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z28.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z28.string(),
+  inherits_status: z28.boolean(),
+  type: z28.literal("Vault"),
+  url: z28.string().url(),
+  app_url: z28.string().url(),
+  bookmark_url: z28.string().url(),
+  position: z28.number().int().nonnegative(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var VaultSchema = VaultCoreSchema.extend({
+  documents_count: z28.number().int().nonnegative(),
+  documents_url: z28.string().url(),
+  uploads_count: z28.number().int().nonnegative(),
+  uploads_url: z28.string().url(),
+  vaults_count: z28.number().int().nonnegative(),
+  vaults_url: z28.string().url()
+});
+var VaultListResponseSchema = z28.array(VaultSchema);
+var VaultListQuerySchema = z28.object({
+  page: z28.coerce.number().int().positive().optional()
+});
+var VaultCreateBodySchema = z28.object({
+  title: z28.string().min(1)
+});
+var VaultUpdateBodySchema = z28.object({
+  title: z28.string().min(1)
+});
+
+// src/contract/schemas/documents/uploads.ts
+import { z as z29 } from "zod";
+var UploadCoreSchema = z29.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z29.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z29.string(),
+  inherits_status: z29.boolean(),
+  type: z29.literal("Upload"),
+  url: z29.string().url(),
+  app_url: z29.string().url(),
+  bookmark_url: z29.string().url(),
+  subscription_url: z29.string().url(),
+  comments_count: z29.number().int().nonnegative(),
+  comments_url: z29.string().url(),
+  position: z29.number().int().nonnegative(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var UploadSchema = UploadCoreSchema.extend({
+  description: HtmlStringSchema.optional(),
+  content_type: z29.string(),
+  byte_size: z29.number().int().nonnegative(),
+  filename: z29.string(),
+  download_url: z29.string().url(),
+  app_download_url: z29.string().url(),
+  width: z29.number().int().nonnegative().optional(),
+  height: z29.number().int().nonnegative().optional()
+});
+var UploadListResponseSchema = z29.array(UploadSchema);
+var UploadListQuerySchema = z29.object({
+  page: z29.coerce.number().int().positive().optional()
+});
+var UploadCreateBodySchema = z29.object({
+  attachable_sgid: z29.string().min(1),
+  description: HtmlStringSchema.optional(),
+  base_name: z29.string().optional()
+});
+var UploadUpdateBodySchema = z29.object({
+  description: HtmlStringSchema.optional(),
+  base_name: z29.string().optional()
+}).refine(
+  (value) => Object.keys(value).length > 0,
+  "At least one field must be provided to update an upload."
+);
+
+// src/contract/schemas/documents/attachments.ts
+import { z as z30 } from "zod";
+var AttachmentResponseSchema = z30.object({
+  attachable_sgid: z30.string().min(1)
+});
+var AttachmentCreateQuerySchema = z30.object({
+  name: z30.string().min(1)
+});
+
+// src/contract/resources/documents/documents.ts
+var bucketAndVaultPathParams = z31.object({
+  bucketId: BasecampIdParamSchema,
+  vaultId: BasecampIdParamSchema
+});
+var bucketAndDocumentPathParams = z31.object({
+  bucketId: BasecampIdParamSchema,
+  documentId: BasecampIdParamSchema
+});
+var documentsRouter = c.router({
+  list: {
+    summary: "List documents",
+    description: "Returns a paginated list of active documents in a vault. Pagination data is available via the Link and X-Total-Count headers.",
+    metadata: {
+      tag: "Documents",
+      operationId: "documents.list",
+      docsPath: "/docs/basecamp-api-specs/sections/documents.md#get-documents"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/vaults/:vaultId/documents",
+    pathParams: bucketAndVaultPathParams,
+    query: DocumentListQuerySchema,
+    responses: {
+      200: DocumentListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a document",
+    description: "Fetch the full representation of a single document.",
+    metadata: {
+      tag: "Documents",
+      operationId: "documents.get",
+      docsPath: "/docs/basecamp-api-specs/sections/documents.md#get-a-document"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/documents/:documentId",
+    pathParams: bucketAndDocumentPathParams,
+    responses: {
+      200: DocumentSchema
+    }
+  },
+  create: {
+    summary: "Create a document",
+    description: 'Publish a document in a vault. Setting status to "active" makes the document visible immediately.',
+    metadata: {
+      tag: "Documents",
+      operationId: "documents.create",
+      docsPath: "/docs/basecamp-api-specs/sections/documents.md#create-a-document"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/vaults/:vaultId/documents",
+    pathParams: bucketAndVaultPathParams,
+    body: DocumentCreateBodySchema,
+    responses: {
+      201: DocumentSchema
+    }
+  },
+  update: {
+    summary: "Update a document",
+    description: "Update the title or content of an existing document.",
+    metadata: {
+      tag: "Documents",
+      operationId: "documents.update",
+      docsPath: "/docs/basecamp-api-specs/sections/documents.md#update-a-document"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/documents/:documentId",
+    pathParams: bucketAndDocumentPathParams,
+    body: DocumentUpdateBodySchema,
+    responses: {
+      200: DocumentSchema
+    }
+  },
+  trash: {
+    summary: "Trash a document",
+    description: "Move a document recording to the trash. Trashed items can be restored via the UI.",
+    metadata: {
+      tag: "Documents",
+      operationId: "documents.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:documentId/status/trashed",
+    pathParams: bucketAndDocumentPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/documents/vaults.ts
+import { z as z32 } from "zod";
+var bucketAndVaultPathParams2 = z32.object({
+  bucketId: BasecampIdParamSchema,
+  vaultId: BasecampIdParamSchema
+});
+var bucketAndParentVaultPathParams = z32.object({
+  bucketId: BasecampIdParamSchema,
+  parentVaultId: BasecampIdParamSchema
+});
+var vaultsRouter = c.router({
+  list: {
+    summary: "List vaults",
+    description: "Returns a paginated list of vaults nested under a parent vault. Pagination data is available via the Link and X-Total-Count headers.",
+    metadata: {
+      tag: "Vaults",
+      operationId: "vaults.list",
+      docsPath: "/docs/basecamp-api-specs/sections/vaults.md#get-vaults"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/vaults/:parentVaultId/vaults",
+    pathParams: bucketAndParentVaultPathParams,
+    query: VaultListQuerySchema,
+    responses: {
+      200: VaultListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a vault",
+    description: "Fetch the full representation of a single vault.",
+    metadata: {
+      tag: "Vaults",
+      operationId: "vaults.get",
+      docsPath: "/docs/basecamp-api-specs/sections/vaults.md#get-a-vault"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/vaults/:vaultId",
+    pathParams: bucketAndVaultPathParams2,
+    responses: {
+      200: VaultSchema
+    }
+  },
+  create: {
+    summary: "Create a vault",
+    description: "Create a new vault nested under a parent vault.",
+    metadata: {
+      tag: "Vaults",
+      operationId: "vaults.create",
+      docsPath: "/docs/basecamp-api-specs/sections/vaults.md#create-a-vault"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/vaults/:parentVaultId/vaults",
+    pathParams: bucketAndParentVaultPathParams,
+    body: VaultCreateBodySchema,
+    responses: {
+      201: VaultSchema
+    }
+  },
+  update: {
+    summary: "Update a vault",
+    description: "Update the title of an existing vault.",
+    metadata: {
+      tag: "Vaults",
+      operationId: "vaults.update",
+      docsPath: "/docs/basecamp-api-specs/sections/vaults.md#update-a-vault"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/vaults/:vaultId",
+    pathParams: bucketAndVaultPathParams2,
+    body: VaultUpdateBodySchema,
+    responses: {
+      200: VaultSchema
+    }
+  },
+  trash: {
+    summary: "Trash a vault",
+    description: "Move a vault recording to the trash. Trashed items can be restored via the UI.",
+    metadata: {
+      tag: "Vaults",
+      operationId: "vaults.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:vaultId/status/trashed",
+    pathParams: bucketAndVaultPathParams2,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/documents/uploads.ts
+import { z as z33 } from "zod";
+var bucketAndVaultPathParams3 = z33.object({
+  bucketId: BasecampIdParamSchema,
+  vaultId: BasecampIdParamSchema
+});
+var bucketAndUploadPathParams = z33.object({
+  bucketId: BasecampIdParamSchema,
+  uploadId: BasecampIdParamSchema
+});
+var uploadsRouter = c.router({
+  list: {
+    summary: "List uploads",
+    description: "Returns a paginated list of active uploads in a vault. Pagination data is available via the Link and X-Total-Count headers.",
+    metadata: {
+      tag: "Uploads",
+      operationId: "uploads.list",
+      docsPath: "/docs/basecamp-api-specs/sections/uploads.md#get-uploads"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/vaults/:vaultId/uploads",
+    pathParams: bucketAndVaultPathParams3,
+    query: UploadListQuerySchema,
+    responses: {
+      200: UploadListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get an upload",
+    description: "Fetch the full representation of a single upload.",
+    metadata: {
+      tag: "Uploads",
+      operationId: "uploads.get",
+      docsPath: "/docs/basecamp-api-specs/sections/uploads.md#get-an-upload"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/uploads/:uploadId",
+    pathParams: bucketAndUploadPathParams,
+    responses: {
+      200: UploadSchema
+    }
+  },
+  create: {
+    summary: "Create an upload",
+    description: "Create an upload in a vault using a previously obtained attachable_sgid from the attachments endpoint.",
+    metadata: {
+      tag: "Uploads",
+      operationId: "uploads.create",
+      docsPath: "/docs/basecamp-api-specs/sections/uploads.md#create-an-upload"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/vaults/:vaultId/uploads",
+    pathParams: bucketAndVaultPathParams3,
+    body: UploadCreateBodySchema,
+    responses: {
+      201: UploadSchema
+    }
+  },
+  update: {
+    summary: "Update an upload",
+    description: "Update the description or base name of an existing upload.",
+    metadata: {
+      tag: "Uploads",
+      operationId: "uploads.update",
+      docsPath: "/docs/basecamp-api-specs/sections/uploads.md#update-an-upload"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/uploads/:uploadId",
+    pathParams: bucketAndUploadPathParams,
+    body: UploadUpdateBodySchema,
+    responses: {
+      200: UploadSchema
+    }
+  },
+  trash: {
+    summary: "Trash an upload",
+    description: "Move an upload recording to the trash. Trashed items can be restored via the UI.",
+    metadata: {
+      tag: "Uploads",
+      operationId: "uploads.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:uploadId/status/trashed",
+    pathParams: bucketAndUploadPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/documents/attachments.ts
+var attachmentsRouter = c.router({
+  create: {
+    summary: "Create an attachment",
+    description: "Upload a file to get an attachable_sgid that can be used in subsequent requests to create uploads or documents. The request body should be the raw binary file data. Note: Content-Type and Content-Length headers must be set by the caller.",
+    metadata: {
+      tag: "Attachments",
+      operationId: "attachments.create",
+      docsPath: "/docs/basecamp-api-specs/sections/attachments.md#create-an-attachment"
+    },
+    method: "POST",
+    path: "/attachments",
+    query: AttachmentCreateQuerySchema,
+    body: c.type(),
+    responses: {
+      201: AttachmentResponseSchema
+    }
+  }
+});
+
+// src/contract/resources/events.ts
+import { z as z35 } from "zod";
+
+// src/contract/schemas/events.ts
+import { z as z34 } from "zod";
+var EventDetailsSchema = z34.object({}).passthrough();
+var RecordingEventSchema = z34.object({
+  id: BasecampIdSchema,
+  recording_id: BasecampIdSchema,
+  action: z34.string(),
+  details: EventDetailsSchema,
+  created_at: IsoDateTimeSchema,
+  creator: PersonSummarySchema
+});
+var RecordingEventListResponseSchema = z34.array(RecordingEventSchema);
+var RecordingEventListQuerySchema = z34.object({
+  page: z34.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/events.ts
+var RecordingEventsPathParamsSchema = z35.object({
+  bucketId: BasecampIdParamSchema,
+  recordingId: BasecampIdParamSchema
+});
+var eventsRouter = c.router({
+  listForRecording: {
+    summary: "List recording events",
+    description: "Returns the event history for a specific recording. Pagination data is available via Link headers.",
+    metadata: {
+      tag: "Events",
+      operationId: "events.listForRecording",
+      docsPath: "/docs/basecamp-api-specs/sections/events.md#get-events"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/recordings/:recordingId/events",
+    pathParams: RecordingEventsPathParamsSchema,
+    query: RecordingEventListQuerySchema.optional(),
+    responses: {
+      200: RecordingEventListResponseSchema
+    }
+  }
+});
+
+// src/contract/resources/lineup-markers.ts
+import { z as z37 } from "zod";
+
+// src/contract/schemas/lineup-markers.ts
+import { z as z36 } from "zod";
+var LineupMarkerCreateBodySchema = z36.object({
+  name: z36.string().min(1),
+  date: IsoDateSchema
+});
+var LineupMarkerUpdateBodySchema = z36.object({
+  name: z36.string().min(1).optional(),
+  date: IsoDateSchema.optional()
+}).refine((value) => value.name !== void 0 || value.date !== void 0, {
+  message: "Either name or date must be provided."
+});
+
+// src/contract/resources/lineup-markers.ts
+var LineupMarkerPathParamsSchema = z37.object({
+  markerId: BasecampIdParamSchema
+});
+var lineupMarkersRouter = c.router({
+  create: {
+    summary: "Create a lineup marker",
+    description: "Create an account-wide lineup marker that appears on the Lineup timeline.",
+    metadata: {
+      tag: "LineupMarkers",
+      operationId: "lineupMarkers.create",
+      docsPath: "/docs/basecamp-api-specs/sections/lineup_markers.md#create-a-marker"
+    },
+    method: "POST",
+    path: "/lineup/markers",
+    body: LineupMarkerCreateBodySchema,
+    responses: {
+      201: c.noBody()
+    }
+  },
+  update: {
+    summary: "Update a lineup marker",
+    description: "Update the name or date of an existing lineup marker.",
+    metadata: {
+      tag: "LineupMarkers",
+      operationId: "lineupMarkers.update",
+      docsPath: "/docs/basecamp-api-specs/sections/lineup_markers.md#update-a-marker"
+    },
+    method: "PUT",
+    path: "/lineup/markers/:markerId",
+    pathParams: LineupMarkerPathParamsSchema,
+    body: LineupMarkerUpdateBodySchema,
+    responses: {
+      200: c.noBody()
+    }
+  },
+  destroy: {
+    summary: "Destroy a lineup marker",
+    description: "Permanently delete a lineup marker immediately.",
+    metadata: {
+      tag: "LineupMarkers",
+      operationId: "lineupMarkers.destroy",
+      docsPath: "/docs/basecamp-api-specs/sections/lineup_markers.md#destroy-a-marker"
+    },
+    method: "DELETE",
+    path: "/lineup/markers/:markerId",
+    pathParams: LineupMarkerPathParamsSchema,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/people.ts
+import { z as z39 } from "zod";
+
+// src/contract/schemas/people.ts
+import { z as z38 } from "zod";
+var PersonSchema = PersonSummarySchema;
+var PeopleListQuerySchema = z38.object({
+  page: z38.coerce.number().int().positive().optional()
+});
+var PeopleListResponseSchema = z38.array(PersonSchema);
+var ProjectAccessCreateEntrySchema = z38.object({
+  name: z38.string().min(1),
+  email_address: z38.string().email(),
+  title: z38.string().optional(),
+  company_name: z38.string().optional()
+});
+var ProjectPeopleAccessBodySchema = z38.object({
+  grant: z38.array(BasecampIdSchema).min(1).optional(),
+  revoke: z38.array(BasecampIdSchema).min(1).optional(),
+  create: z38.array(ProjectAccessCreateEntrySchema).min(1).optional()
+}).refine(
+  (value) => value.grant !== void 0 || value.revoke !== void 0 || value.create !== void 0,
+  {
+    message: "At least one of grant, revoke, or create must be provided.",
+    path: ["grant"]
+  }
+);
+var ProjectPeopleAccessResponseSchema = z38.object({
+  granted: z38.array(PersonSchema),
+  revoked: z38.array(PersonSchema)
+});
+
+// src/contract/resources/people.ts
+var ProjectPathParamsSchema = z39.object({
+  projectId: BasecampIdParamSchema
+});
+var PersonPathParamsSchema = z39.object({
+  personId: BasecampIdParamSchema
+});
+var peopleRouter = c.router({
+  list: {
+    summary: "List people",
+    description: "Returns the people visible to the authenticated user across the entire Basecamp account. Pagination data is provided through Link headers when the dataset exceeds a single page.",
+    metadata: {
+      tag: "People",
+      operationId: "people.list",
+      docsPath: "/docs/basecamp-api-specs/sections/people.md#get-all-people"
+    },
+    method: "GET",
+    path: "/people",
+    query: PeopleListQuerySchema.optional(),
+    responses: {
+      200: PeopleListResponseSchema
+    }
+  },
+  listForProject: {
+    summary: "List project people",
+    description: "Returns the active people on a specific project.",
+    metadata: {
+      tag: "People",
+      operationId: "people.listForProject",
+      docsPath: "/docs/basecamp-api-specs/sections/people.md#get-people-on-a-project"
+    },
+    method: "GET",
+    path: "/projects/:projectId/people",
+    pathParams: ProjectPathParamsSchema,
+    responses: {
+      200: PeopleListResponseSchema
+    }
+  },
+  updateProjectAccess: {
+    summary: "Update project access",
+    description: "Grant, revoke, or create people directly on a project. At least one of grant, revoke, or create must be present in the request body.",
+    metadata: {
+      tag: "People",
+      operationId: "people.updateProjectAccess",
+      docsPath: "/docs/basecamp-api-specs/sections/people.md#update-who-can-access-a-project"
+    },
+    method: "PUT",
+    path: "/projects/:projectId/people/users",
+    pathParams: ProjectPathParamsSchema,
+    body: ProjectPeopleAccessBodySchema,
+    responses: {
+      200: ProjectPeopleAccessResponseSchema
+    }
+  },
+  listPingable: {
+    summary: "List pingable people",
+    description: "Returns the people who can be pinged by the authenticated user. The endpoint is not paginated.",
+    metadata: {
+      tag: "People",
+      operationId: "people.listPingable",
+      docsPath: "/docs/basecamp-api-specs/sections/people.md#get-pingable-people"
+    },
+    method: "GET",
+    path: "/circles/people",
+    responses: {
+      200: PeopleListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a person",
+    description: "Fetch the profile for a person by identifier.",
+    metadata: {
+      tag: "People",
+      operationId: "people.get",
+      docsPath: "/docs/basecamp-api-specs/sections/people.md#get-person"
+    },
+    method: "GET",
+    path: "/people/:personId",
+    pathParams: PersonPathParamsSchema,
+    responses: {
+      200: PersonSchema
+    }
+  },
+  me: {
+    summary: "Get my personal info",
+    description: "Fetch the profile for the authenticated user.",
+    metadata: {
+      tag: "People",
+      operationId: "people.me",
+      docsPath: "/docs/basecamp-api-specs/sections/people.md#get-my-personal-info"
+    },
+    method: "GET",
+    path: "/my/profile",
+    responses: {
+      200: PersonSchema
+    }
+  }
+});
+
+// src/contract/resources/projects.ts
+import { z as z41 } from "zod";
+
+// src/contract/schemas/projects.ts
+import { z as z40 } from "zod";
+var ProjectDockEntrySchema = z40.object({
+  id: BasecampIdSchema,
+  title: z40.string(),
+  name: z40.string(),
+  enabled: z40.boolean(),
+  position: z40.number().int().nullable(),
+  url: z40.string().url(),
+  app_url: z40.string().url()
+});
+var ProjectClientCompanySchema = z40.object({
+  id: BasecampIdSchema,
+  name: z40.string()
+});
+var ProjectClientsideSchema = z40.object({
+  url: z40.string().url(),
+  app_url: z40.string().url()
+});
+var ProjectStatusSchema = z40.enum(["active", "archived", "trashed"]).or(z40.string());
+var ProjectCoreSchema = z40.object({
+  id: BasecampIdSchema,
+  status: ProjectStatusSchema,
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  name: z40.string(),
+  description: HtmlStringSchema.nullable().optional(),
+  purpose: z40.string(),
+  clients_enabled: z40.boolean(),
+  bookmark_url: z40.string().url(),
+  url: z40.string().url(),
+  app_url: z40.string().url(),
+  dock: z40.array(ProjectDockEntrySchema),
+  client_company: ProjectClientCompanySchema.optional(),
+  clientside: ProjectClientsideSchema.optional()
+});
+var ProjectSchema = ProjectCoreSchema.extend({
+  bookmarked: z40.boolean().optional()
+});
+var ProjectListResponseSchema = z40.array(ProjectSchema);
+var ProjectListQuerySchema = z40.object({
+  status: z40.enum(["active", "archived", "trashed"]).or(z40.string()).optional(),
+  page: z40.coerce.number().int().positive().optional()
+});
+var ProjectCreateBodySchema = z40.object({
+  name: z40.string().min(1),
+  description: HtmlStringSchema.nullable().optional()
+});
+var ScheduleAttributesSchema = z40.object({
+  start_date: z40.string().date().optional(),
+  end_date: z40.string().date().optional()
+}).refine(
+  (value) => value.start_date === void 0 && value.end_date === void 0 || value.start_date !== void 0 && value.end_date !== void 0,
+  {
+    message: "Both start_date and end_date must be provided together.",
+    path: ["end_date"]
+  }
+);
+var ProjectUpdateBodySchema = z40.object({
+  name: z40.string().min(1),
+  description: HtmlStringSchema.nullable().optional(),
+  admissions: z40.enum(["invite", "employee", "team"]).or(z40.string()).optional(),
+  schedule_attributes: ScheduleAttributesSchema.optional()
+});
+
+// src/contract/resources/projects.ts
+var ProjectPathParamsSchema2 = z41.object({
+  projectId: BasecampIdParamSchema
+});
+var projectsRouter = c.router({
+  list: {
+    summary: "List projects",
+    description: "Returns active projects visible to the authenticated user. Pagination data is exposed via standard Link headers.",
+    metadata: {
+      tag: "Projects",
+      operationId: "projects.list",
+      docsPath: "/docs/basecamp-api-specs/sections/projects.md#get-projects"
+    },
+    method: "GET",
+    path: "/projects",
+    query: ProjectListQuerySchema.optional(),
+    responses: {
+      200: ProjectListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a project",
+    description: "Fetch the full representation of a single project by its identifier.",
+    metadata: {
+      tag: "Projects",
+      operationId: "projects.get",
+      docsPath: "/docs/basecamp-api-specs/sections/projects.md#get-a-project"
+    },
+    method: "GET",
+    path: "/projects/:projectId",
+    pathParams: ProjectPathParamsSchema2,
+    responses: {
+      200: ProjectSchema
+    }
+  },
+  create: {
+    summary: "Create a project",
+    description: "Create a new project with an optional description.",
+    metadata: {
+      tag: "Projects",
+      operationId: "projects.create",
+      docsPath: "/docs/basecamp-api-specs/sections/projects.md#create-a-project"
+    },
+    method: "POST",
+    path: "/projects",
+    body: ProjectCreateBodySchema,
+    responses: {
+      201: ProjectSchema,
+      507: z41.object({
+        error: z41.string()
+      })
+    }
+  },
+  update: {
+    summary: "Update a project",
+    description: "Update a project name, description, admissions policy, or schedule dates. Basecamp requires the name to be present in every update request.",
+    metadata: {
+      tag: "Projects",
+      operationId: "projects.update",
+      docsPath: "/docs/basecamp-api-specs/sections/projects.md#update-a-project"
+    },
+    method: "PUT",
+    path: "/projects/:projectId",
+    pathParams: ProjectPathParamsSchema2,
+    body: ProjectUpdateBodySchema,
+    responses: {
+      200: ProjectSchema
+    }
+  },
+  trash: {
+    summary: "Trash a project",
+    description: "Move a project to the trash. The project will be permanently deleted after 30 days unless restored via the UI.",
+    metadata: {
+      tag: "Projects",
+      operationId: "projects.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/projects.md#trash-a-project"
+    },
+    method: "DELETE",
+    path: "/projects/:projectId",
+    pathParams: ProjectPathParamsSchema2,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/recordings.ts
+import { z as z42 } from "zod";
+var BucketRecordingPathParamsSchema = z42.object({
+  bucketId: BasecampIdParamSchema,
+  recordingId: BasecampIdParamSchema
+});
+var recordingsRouter = c.router({
+  list: {
+    summary: "List recordings",
+    description: "Returns a paginated list of recordings filtered by type and optional bucket or status filters. Use this endpoint to enumerate cross-project activity for a specific recording type.",
+    metadata: {
+      tag: "Recordings",
+      operationId: "recordings.list",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#get-recordings"
+    },
+    method: "GET",
+    path: "/projects/recordings",
+    query: RecordingListQuerySchema,
+    responses: {
+      200: RecordingListResponseSchema
+    }
+  },
+  trash: {
+    summary: "Trash a recording",
+    description: "Mark a recording as trashed. Trashed recordings can be restored via the UI.",
+    metadata: {
+      tag: "Recordings",
+      operationId: "recordings.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:recordingId/status/trashed",
+    pathParams: BucketRecordingPathParamsSchema,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  },
+  archive: {
+    summary: "Archive a recording",
+    description: "Mark a recording as archived. Archived recordings remain available but hidden.",
+    metadata: {
+      tag: "Recordings",
+      operationId: "recordings.archive",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#archive-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:recordingId/status/archived",
+    pathParams: BucketRecordingPathParamsSchema,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  },
+  activate: {
+    summary: "Unarchive a recording",
+    description: "Mark a recording as active to reverse a previous archive action.",
+    metadata: {
+      tag: "Recordings",
+      operationId: "recordings.activate",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#unarchive-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:recordingId/status/active",
+    pathParams: BucketRecordingPathParamsSchema,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/scheduling/schedules.ts
+import { z as z44 } from "zod";
+
+// src/contract/schemas/scheduling/schedules.ts
+import { z as z43 } from "zod";
+var ScheduleSchema = z43.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z43.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z43.string(),
+  inherits_status: z43.boolean(),
+  type: z43.literal("Schedule"),
+  url: z43.string().url(),
+  app_url: z43.string().url(),
+  bookmark_url: z43.string().url(),
+  position: z43.number().int(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  include_due_assignments: z43.boolean(),
+  entries_count: z43.number().int(),
+  entries_url: z43.string().url()
+});
+var ScheduleUpdateBodySchema = z43.object({
+  include_due_assignments: z43.boolean()
+});
+
+// src/contract/resources/scheduling/schedules.ts
+var bucketAndSchedulePathParams = z44.object({
+  bucketId: BasecampIdParamSchema,
+  scheduleId: BasecampIdParamSchema
+});
+var schedulesRouter = c.router({
+  get: {
+    summary: "Get schedule",
+    description: "Returns the schedule for a project. All schedule entries under a project are children of this resource.",
+    metadata: {
+      tag: "Schedules",
+      operationId: "schedules.get",
+      docsPath: "/docs/basecamp-api-specs/sections/schedules.md#get-schedule"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/schedules/:scheduleId",
+    pathParams: bucketAndSchedulePathParams,
+    responses: {
+      200: ScheduleSchema
+    }
+  },
+  update: {
+    summary: "Update a schedule",
+    description: "Update whether the schedule should include due dates from to-dos, cards, and steps.",
+    metadata: {
+      tag: "Schedules",
+      operationId: "schedules.update",
+      docsPath: "/docs/basecamp-api-specs/sections/schedules.md#update-a-schedule"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/schedules/:scheduleId",
+    pathParams: bucketAndSchedulePathParams,
+    body: ScheduleUpdateBodySchema,
+    responses: {
+      200: ScheduleSchema
+    }
+  }
+});
+
+// src/contract/resources/scheduling/schedule-entries.ts
+import { z as z46 } from "zod";
+
+// src/contract/schemas/scheduling/schedule-entries.ts
+import { z as z45 } from "zod";
+var RecurrenceScheduleSchema = z45.object({
+  frequency: z45.string(),
+  days: z45.array(z45.number().int()),
+  hour: z45.number().int(),
+  minute: z45.number().int(),
+  week_instance: z45.number().int().nullable(),
+  week_interval: z45.number().int().nullable(),
+  month_interval: z45.number().int().nullable(),
+  start_date: z45.string(),
+  end_date: z45.string().nullable()
+});
+var ScheduleEntrySchema = z45.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z45.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z45.string(),
+  inherits_status: z45.boolean(),
+  type: z45.literal("Schedule::Entry"),
+  url: z45.string().url(),
+  app_url: z45.string().url(),
+  bookmark_url: z45.string().url(),
+  subscription_url: z45.string().url(),
+  comments_count: z45.number().int(),
+  comments_url: z45.string().url(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  description: HtmlStringSchema,
+  summary: z45.string(),
+  all_day: z45.boolean(),
+  starts_at: z45.string(),
+  ends_at: z45.string(),
+  participants: z45.array(PersonSummarySchema),
+  recurrence_schedule: RecurrenceScheduleSchema.optional()
+});
+var ScheduleEntryListResponseSchema = z45.array(ScheduleEntrySchema);
+var ScheduleEntryListQuerySchema = z45.object({
+  status: RecordingStatusSchema.optional(),
+  page: z45.coerce.number().int().positive().optional()
+});
+var ScheduleEntryCreateBodySchema = z45.object({
+  summary: z45.string(),
+  starts_at: z45.string(),
+  ends_at: z45.string(),
+  description: HtmlStringSchema.optional(),
+  participant_ids: z45.array(BasecampIdSchema).optional(),
+  all_day: z45.boolean().optional(),
+  notify: z45.boolean().optional()
+});
+var ScheduleEntryUpdateBodySchema = z45.object({
+  summary: z45.string().optional(),
+  starts_at: z45.string().optional(),
+  ends_at: z45.string().optional(),
+  description: HtmlStringSchema.optional(),
+  participant_ids: z45.array(BasecampIdSchema).optional(),
+  all_day: z45.boolean().optional(),
+  notify: z45.boolean().optional()
+});
+
+// src/contract/resources/scheduling/schedule-entries.ts
+var bucketAndSchedulePathParams2 = z46.object({
+  bucketId: BasecampIdParamSchema,
+  scheduleId: BasecampIdParamSchema
+});
+var bucketAndEntryPathParams = z46.object({
+  bucketId: BasecampIdParamSchema,
+  scheduleEntryId: BasecampIdParamSchema
+});
+var bucketEntryOccurrencePathParams = z46.object({
+  bucketId: BasecampIdParamSchema,
+  scheduleEntryId: BasecampIdParamSchema,
+  occurrenceDate: z46.string()
+});
+var scheduleEntriesRouter = c.router({
+  list: {
+    summary: "List schedule entries",
+    description: "Returns a paginated list of schedule entries in a schedule. Use status filter to get archived or trashed entries.",
+    metadata: {
+      tag: "Schedule Entries",
+      operationId: "scheduleEntries.list",
+      docsPath: "/docs/basecamp-api-specs/sections/schedule_entries.md#get-schedule-entries"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/schedules/:scheduleId/entries",
+    pathParams: bucketAndSchedulePathParams2,
+    query: ScheduleEntryListQuerySchema,
+    responses: {
+      200: ScheduleEntryListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a schedule entry",
+    description: "Returns a schedule entry. For recurring entries, this redirects to the first occurrence.",
+    metadata: {
+      tag: "Schedule Entries",
+      operationId: "scheduleEntries.get",
+      docsPath: "/docs/basecamp-api-specs/sections/schedule_entries.md#get-a-schedule-entry"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/schedule_entries/:scheduleEntryId",
+    pathParams: bucketAndEntryPathParams,
+    responses: {
+      200: ScheduleEntrySchema
+    }
+  },
+  getOccurrence: {
+    summary: "Get a specific occurrence of a recurring schedule entry",
+    description: "Returns a specific occurrence of a recurring schedule entry (e.g., 20190218 for February 18, 2019).",
+    metadata: {
+      tag: "Schedule Entries",
+      operationId: "scheduleEntries.getOccurrence",
+      docsPath: "/docs/basecamp-api-specs/sections/schedule_entries.md#get-a-schedule-entry"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/schedule_entries/:scheduleEntryId/occurrences/:occurrenceDate",
+    pathParams: bucketEntryOccurrencePathParams,
+    responses: {
+      200: ScheduleEntrySchema
+    }
+  },
+  create: {
+    summary: "Create a schedule entry",
+    description: "Creates a new schedule entry in a schedule. Required fields: summary, starts_at, and ends_at.",
+    metadata: {
+      tag: "Schedule Entries",
+      operationId: "scheduleEntries.create",
+      docsPath: "/docs/basecamp-api-specs/sections/schedule_entries.md#create-a-schedule-entry"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/schedules/:scheduleId/entries",
+    pathParams: bucketAndSchedulePathParams2,
+    body: ScheduleEntryCreateBodySchema,
+    responses: {
+      201: ScheduleEntrySchema
+    }
+  },
+  update: {
+    summary: "Update a schedule entry",
+    description: "Updates an existing schedule entry. Any create parameters can be changed.",
+    metadata: {
+      tag: "Schedule Entries",
+      operationId: "scheduleEntries.update",
+      docsPath: "/docs/basecamp-api-specs/sections/schedule_entries.md#update-a-schedule-entry"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/schedule_entries/:scheduleEntryId",
+    pathParams: bucketAndEntryPathParams,
+    body: ScheduleEntryUpdateBodySchema,
+    responses: {
+      200: ScheduleEntrySchema
+    }
+  },
+  trash: {
+    summary: "Trash a schedule entry",
+    description: "Moves a schedule entry to the trash. Trashed items can be restored via the UI.",
+    metadata: {
+      tag: "Schedule Entries",
+      operationId: "scheduleEntries.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:scheduleEntryId/status/trashed",
+    pathParams: bucketAndEntryPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/scheduling/questionnaires.ts
+import { z as z48 } from "zod";
+
+// src/contract/schemas/scheduling/questionnaires.ts
+import { z as z47 } from "zod";
+var QuestionnaireSchema = z47.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z47.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z47.string(),
+  inherits_status: z47.boolean(),
+  type: z47.literal("Questionnaire"),
+  url: z47.string().url(),
+  app_url: z47.string().url(),
+  bookmark_url: z47.string().url(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  name: z47.string(),
+  questions_count: z47.number().int(),
+  questions_url: z47.string().url()
+});
+
+// src/contract/resources/scheduling/questionnaires.ts
+var bucketAndQuestionnairePathParams = z48.object({
+  bucketId: BasecampIdParamSchema,
+  questionnaireId: BasecampIdParamSchema
+});
+var questionnairesRouter = c.router({
+  get: {
+    summary: "Get questionnaire",
+    description: "Returns the questionnaire for a project. All automatic check-in questions are children of this resource.",
+    metadata: {
+      tag: "Questionnaires",
+      operationId: "questionnaires.get",
+      docsPath: "/docs/basecamp-api-specs/sections/questionnaires.md#get-questionnaire"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/questionnaires/:questionnaireId",
+    pathParams: bucketAndQuestionnairePathParams,
+    responses: {
+      200: QuestionnaireSchema
+    }
+  }
+});
+
+// src/contract/resources/scheduling/questions.ts
+import { z as z50 } from "zod";
+
+// src/contract/schemas/scheduling/questions.ts
+import { z as z49 } from "zod";
+var QuestionScheduleSchema = z49.object({
+  frequency: z49.string(),
+  days: z49.array(z49.number().int()),
+  hour: z49.number().int(),
+  minute: z49.number().int(),
+  week_instance: z49.number().int().nullable(),
+  week_interval: z49.number().int().nullable(),
+  month_interval: z49.number().int().nullable(),
+  start_date: z49.string(),
+  end_date: z49.string().nullable()
+});
+var QuestionSchema = z49.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z49.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z49.string(),
+  inherits_status: z49.boolean(),
+  type: z49.literal("Question"),
+  url: z49.string().url(),
+  app_url: z49.string().url(),
+  bookmark_url: z49.string().url(),
+  subscription_url: z49.string().url(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  paused: z49.boolean(),
+  schedule: QuestionScheduleSchema,
+  answers_count: z49.number().int(),
+  answers_url: z49.string().url()
+});
+var QuestionListResponseSchema = z49.array(QuestionSchema);
+var QuestionListQuerySchema = z49.object({
+  page: z49.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/scheduling/questions.ts
+var bucketAndQuestionnairePathParams2 = z50.object({
+  bucketId: BasecampIdParamSchema,
+  questionnaireId: BasecampIdParamSchema
+});
+var bucketAndQuestionPathParams = z50.object({
+  bucketId: BasecampIdParamSchema,
+  questionId: BasecampIdParamSchema
+});
+var questionsRouter = c.router({
+  list: {
+    summary: "List questions",
+    description: "Returns a paginated list of questions in a questionnaire (automatic check-ins).",
+    metadata: {
+      tag: "Questions",
+      operationId: "questions.list",
+      docsPath: "/docs/basecamp-api-specs/sections/questions.md#get-questions"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/questionnaires/:questionnaireId/questions",
+    pathParams: bucketAndQuestionnairePathParams2,
+    query: QuestionListQuerySchema,
+    responses: {
+      200: QuestionListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a question",
+    description: "Returns a single automatic check-in question with its schedule and metadata.",
+    metadata: {
+      tag: "Questions",
+      operationId: "questions.get",
+      docsPath: "/docs/basecamp-api-specs/sections/questions.md#get-a-question"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/questions/:questionId",
+    pathParams: bucketAndQuestionPathParams,
+    responses: {
+      200: QuestionSchema
+    }
+  }
+});
+
+// src/contract/resources/tasks/todosets.ts
+import { z as z52 } from "zod";
+
+// src/contract/schemas/tasks/todosets.ts
+import { z as z51 } from "zod";
+var TodoRecordingCoreSchema = z51.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z51.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z51.string(),
+  inherits_status: z51.boolean(),
+  type: z51.string(),
+  url: z51.string().url(),
+  app_url: z51.string().url(),
+  bookmark_url: z51.string().url().optional(),
+  subscription_url: z51.string().url().optional(),
+  comments_count: z51.number().int().nonnegative().optional(),
+  comments_url: z51.string().url().optional(),
+  position: z51.number().int().nonnegative().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var TodoSetSchema = TodoRecordingCoreSchema.omit({
+  subscription_url: true,
+  comments_count: true,
+  comments_url: true
+}).extend({
+  completed: z51.boolean(),
+  completed_ratio: z51.string(),
+  name: z51.string(),
+  todolists_count: z51.number().int().nonnegative(),
+  todolists_url: z51.string().url(),
+  app_todoslists_url: z51.string().url()
+});
+
+// src/contract/resources/tasks/todosets.ts
+var bucketPathParams2 = z52.object({
+  bucketId: BasecampIdParamSchema
+});
+var bucketAndTodoSetPathParams = bucketPathParams2.extend({
+  todosetId: BasecampIdParamSchema
+});
+var todoSetsRouter = c.router({
+  get: {
+    summary: "Get a to-do set",
+    description: "Return the to-do set container for a project. Use this to discover to-do lists and their groups.",
+    metadata: {
+      tag: "Todo Sets",
+      operationId: "todoSets.get",
+      docsPath: "/docs/basecamp-api-specs/sections/todosets.md#get-to-do-set"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/todosets/:todosetId",
+    pathParams: bucketAndTodoSetPathParams,
+    responses: {
+      200: TodoSetSchema
+    }
+  }
+});
+
+// src/contract/resources/tasks/todolists.ts
+import { z as z54 } from "zod";
+
+// src/contract/schemas/tasks/todolists.ts
+import { z as z53 } from "zod";
+var TodoRecordingCoreSchema2 = z53.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z53.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z53.string(),
+  inherits_status: z53.boolean(),
+  type: z53.string(),
+  url: z53.string().url(),
+  app_url: z53.string().url(),
+  bookmark_url: z53.string().url().optional(),
+  subscription_url: z53.string().url().optional(),
+  comments_count: z53.number().int().nonnegative().optional(),
+  comments_url: z53.string().url().optional(),
+  position: z53.number().int().nonnegative().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var TodoListBaseSchema = TodoRecordingCoreSchema2.extend({
+  description: HtmlStringSchema.optional(),
+  completed: z53.boolean(),
+  completed_ratio: z53.string(),
+  name: z53.string(),
+  todos_url: z53.string().url(),
+  app_todos_url: z53.string().url()
+});
+var TodoTopLevelListSchema = TodoListBaseSchema.extend({
+  groups_url: z53.string().url()
+});
+var TodoListGroupSchema = TodoListBaseSchema.extend({
+  group_position_url: z53.string().url()
+});
+var TodoListSchema = z53.union([TodoTopLevelListSchema, TodoListGroupSchema]);
+var TodoListsResponseSchema = z53.array(TodoTopLevelListSchema);
+var TodoListQuerySchema = z53.object({
+  status: z53.enum(["active", "archived", "trashed"]).or(z53.string()).optional(),
+  page: z53.coerce.number().int().positive().optional()
+});
+var TodoListCreateBodySchema = z53.object({
+  name: z53.string().min(1),
+  description: HtmlStringSchema.nullable().optional()
+});
+var TodoListUpdateBodySchema = z53.object({
+  name: z53.string().min(1),
+  description: HtmlStringSchema.nullable().optional()
+});
+
+// src/contract/resources/tasks/todolists.ts
+var bucketPathParams3 = z54.object({
+  bucketId: BasecampIdParamSchema
+});
+var bucketAndTodoSetPathParams2 = bucketPathParams3.extend({
+  todosetId: BasecampIdParamSchema
+});
+var bucketAndTodoListPathParams = bucketPathParams3.extend({
+  todolistId: BasecampIdParamSchema
+});
+var todoListsRouter = c.router({
+  list: {
+    summary: "List to-do lists",
+    description: "List active to-do lists within a to-do set. Pagination metadata is exposed via Link headers.",
+    metadata: {
+      tag: "Todo Lists",
+      operationId: "todoLists.list",
+      docsPath: "/docs/basecamp-api-specs/sections/todolists.md#get-to-do-lists"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/todosets/:todosetId/todolists",
+    pathParams: bucketAndTodoSetPathParams2,
+    query: TodoListQuerySchema.optional(),
+    responses: {
+      200: TodoListsResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a to-do list",
+    description: "Fetch a to-do list or group. When the list represents a group, the payload includes a group_position_url instead of groups_url.",
+    metadata: {
+      tag: "Todo Lists",
+      operationId: "todoLists.get",
+      docsPath: "/docs/basecamp-api-specs/sections/todolists.md#get-a-to-do-list"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/todolists/:todolistId",
+    pathParams: bucketAndTodoListPathParams,
+    responses: {
+      200: TodoListSchema
+    }
+  },
+  create: {
+    summary: "Create a to-do list",
+    description: "Create a new to-do list inside a to-do set. Descriptions accept rich text HTML.",
+    metadata: {
+      tag: "Todo Lists",
+      operationId: "todoLists.create",
+      docsPath: "/docs/basecamp-api-specs/sections/todolists.md#create-a-to-do-list"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/todosets/:todosetId/todolists",
+    pathParams: bucketAndTodoSetPathParams2,
+    body: TodoListCreateBodySchema,
+    responses: {
+      201: TodoTopLevelListSchema
+    }
+  },
+  update: {
+    summary: "Update a to-do list",
+    description: "Update the name or description of an existing to-do list. Basecamp requires the name to be present on every update.",
+    metadata: {
+      tag: "Todo Lists",
+      operationId: "todoLists.update",
+      docsPath: "/docs/basecamp-api-specs/sections/todolists.md#update-a-to-do-list"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/todolists/:todolistId",
+    pathParams: bucketAndTodoListPathParams,
+    body: TodoListUpdateBodySchema,
+    responses: {
+      200: TodoListSchema
+    }
+  },
+  trash: {
+    summary: "Trash a to-do list",
+    description: "Move a to-do list or group to the trash. Trashed items can be restored from the Basecamp UI.",
+    metadata: {
+      tag: "Todo Lists",
+      operationId: "todoLists.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:todolistId/status/trashed",
+    pathParams: bucketAndTodoListPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/tasks/todolist-groups.ts
+import { z as z56 } from "zod";
+
+// src/contract/schemas/tasks/todolist-groups.ts
+import { z as z55 } from "zod";
+var TodoRecordingCoreSchema3 = z55.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z55.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z55.string(),
+  inherits_status: z55.boolean(),
+  type: z55.string(),
+  url: z55.string().url(),
+  app_url: z55.string().url(),
+  bookmark_url: z55.string().url().optional(),
+  subscription_url: z55.string().url().optional(),
+  comments_count: z55.number().int().nonnegative().optional(),
+  comments_url: z55.string().url().optional(),
+  position: z55.number().int().nonnegative().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var TodoListBaseSchema2 = TodoRecordingCoreSchema3.extend({
+  description: HtmlStringSchema.optional(),
+  completed: z55.boolean(),
+  completed_ratio: z55.string(),
+  name: z55.string(),
+  todos_url: z55.string().url(),
+  app_todos_url: z55.string().url()
+});
+var TodoListGroupSchema2 = TodoListBaseSchema2.extend({
+  group_position_url: z55.string().url()
+});
+var TodoListSchema2 = TodoListGroupSchema2;
+var TodoListGroupsResponseSchema = z55.array(TodoListGroupSchema2);
+var TodoListGroupQuerySchema = z55.object({
+  status: z55.enum(["active", "archived", "trashed"]).or(z55.string()).optional(),
+  page: z55.coerce.number().int().positive().optional()
+});
+var TodoListGroupCreateBodySchema = z55.object({
+  name: z55.string().min(1),
+  color: z55.enum([
+    "white",
+    "red",
+    "orange",
+    "yellow",
+    "green",
+    "blue",
+    "aqua",
+    "purple",
+    "gray",
+    "pink",
+    "brown"
+  ]).or(z55.string()).optional()
+});
+var TodoListGroupRepositionBodySchema = z55.object({
+  position: z55.number().int().gte(1)
+});
+
+// src/contract/resources/tasks/todolist-groups.ts
+var bucketPathParams4 = z56.object({
+  bucketId: BasecampIdParamSchema
+});
+var bucketAndTodoListPathParams2 = bucketPathParams4.extend({
+  todolistId: BasecampIdParamSchema
+});
+var bucketAndGroupPathParams = bucketPathParams4.extend({
+  groupId: BasecampIdParamSchema
+});
+var todoListGroupsRouter = c.router({
+  list: {
+    summary: "List to-do list groups",
+    description: "List the to-do list groups contained within a to-do list. Use the status filter to browse archived or trashed groups.",
+    metadata: {
+      tag: "Todo Groups",
+      operationId: "todoListGroups.list",
+      docsPath: "/docs/basecamp-api-specs/sections/todolist_groups.md#list-to-do-list-groups"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/todolists/:todolistId/groups",
+    pathParams: bucketAndTodoListPathParams2,
+    query: TodoListGroupQuerySchema.optional(),
+    responses: {
+      200: TodoListGroupsResponseSchema
+    }
+  },
+  create: {
+    summary: "Create a to-do list group",
+    description: "Create a nested group inside a to-do list. Groups share the same representation as to-do lists.",
+    metadata: {
+      tag: "Todo Groups",
+      operationId: "todoListGroups.create",
+      docsPath: "/docs/basecamp-api-specs/sections/todolist_groups.md#create-a-to-do-list-group"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/todolists/:todolistId/groups",
+    pathParams: bucketAndTodoListPathParams2,
+    body: TodoListGroupCreateBodySchema,
+    responses: {
+      201: TodoListSchema2
+    }
+  },
+  reposition: {
+    summary: "Reposition a to-do list group",
+    description: "Change the position of a to-do list group within its parent list.",
+    metadata: {
+      tag: "Todo Groups",
+      operationId: "todoListGroups.reposition",
+      docsPath: "/docs/basecamp-api-specs/sections/todolist_groups.md#reposition-a-to-do-list-group"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/todolists/groups/:groupId/position",
+    pathParams: bucketAndGroupPathParams,
+    body: TodoListGroupRepositionBodySchema,
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/resources/tasks/todos.ts
+import { z as z58 } from "zod";
+
+// src/contract/schemas/tasks/todos.ts
+import { z as z57 } from "zod";
+var TodoCompletionSchema = z57.object({
+  created_at: IsoDateTimeSchema,
+  creator: PersonSummarySchema
+});
+var TodoRecordingCoreSchema4 = z57.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: z57.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: z57.string(),
+  inherits_status: z57.boolean(),
+  type: z57.string(),
+  url: z57.string().url(),
+  app_url: z57.string().url(),
+  bookmark_url: z57.string().url().optional(),
+  subscription_url: z57.string().url().optional(),
+  comments_count: z57.number().int().nonnegative().optional(),
+  comments_url: z57.string().url().optional(),
+  position: z57.number().int().nonnegative().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var TodoSchema = TodoRecordingCoreSchema4.extend({
+  description: HtmlStringSchema.optional(),
+  completed: z57.boolean(),
+  completion: TodoCompletionSchema.optional(),
+  content: z57.string(),
+  starts_on: z57.string().date().nullable().optional(),
+  due_on: z57.string().date().nullable().optional(),
+  assignees: z57.array(PersonSummarySchema),
+  completion_subscribers: z57.array(PersonSummarySchema),
+  completion_url: z57.string().url()
+});
+var TodoCollectionResponseSchema = z57.array(TodoSchema);
+var TodoQuerySchema = z57.object({
+  status: z57.enum(["active", "archived", "trashed"]).or(z57.string()).optional(),
+  completed: z57.coerce.boolean().optional(),
+  page: z57.coerce.number().int().positive().optional()
+});
+var TodoCreateBodySchema = z57.object({
+  content: z57.string().min(1),
+  description: HtmlStringSchema.nullable().optional(),
+  assignee_ids: z57.array(BasecampIdSchema).optional(),
+  completion_subscriber_ids: z57.array(BasecampIdSchema).optional(),
+  notify: z57.boolean().optional(),
+  due_on: z57.string().date().nullable().optional(),
+  starts_on: z57.string().date().nullable().optional()
+});
+var TodoUpdateBodySchema = z57.object({
+  content: z57.string().min(1),
+  description: HtmlStringSchema.nullable().optional(),
+  assignee_ids: z57.array(BasecampIdSchema).optional(),
+  completion_subscriber_ids: z57.array(BasecampIdSchema).optional(),
+  notify: z57.boolean().optional(),
+  due_on: z57.string().date().nullable().optional(),
+  starts_on: z57.string().date().nullable().optional()
+});
+var TodoRepositionBodySchema = z57.object({
+  position: z57.number().int().gte(1)
+});
+
+// src/contract/resources/tasks/todos.ts
+var bucketPathParams5 = z58.object({
+  bucketId: BasecampIdParamSchema
+});
+var bucketAndTodoListPathParams3 = bucketPathParams5.extend({
+  todolistId: BasecampIdParamSchema
+});
+var bucketAndTodoPathParams = bucketPathParams5.extend({
+  todoId: BasecampIdParamSchema
+});
+var todosRouter = c.router({
+  list: {
+    summary: "List to-dos",
+    description: "List pending or completed to-dos within a to-do list. Use the status and completed filters to target archived or finished items.",
+    metadata: {
+      tag: "Todos",
+      operationId: "todos.list",
+      docsPath: "/docs/basecamp-api-specs/sections/todos.md#get-to-dos"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/todolists/:todolistId/todos",
+    pathParams: bucketAndTodoListPathParams3,
+    query: TodoQuerySchema.optional(),
+    responses: {
+      200: TodoCollectionResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a to-do",
+    description: "Fetch a single to-do item by its identifier.",
+    metadata: {
+      tag: "Todos",
+      operationId: "todos.get",
+      docsPath: "/docs/basecamp-api-specs/sections/todos.md#get-a-to-do"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/todos/:todoId",
+    pathParams: bucketAndTodoPathParams,
+    responses: {
+      200: TodoSchema
+    }
+  },
+  create: {
+    summary: "Create a to-do",
+    description: "Create a to-do inside a to-do list. Rich text HTML is accepted in the description.",
+    metadata: {
+      tag: "Todos",
+      operationId: "todos.create",
+      docsPath: "/docs/basecamp-api-specs/sections/todos.md#create-a-to-do"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/todolists/:todolistId/todos",
+    pathParams: bucketAndTodoListPathParams3,
+    body: TodoCreateBodySchema,
+    responses: {
+      201: TodoSchema
+    }
+  },
+  update: {
+    summary: "Update a to-do",
+    description: "Update the content, description, assignees, or scheduling fields of an existing to-do. The content field must always be provided.",
+    metadata: {
+      tag: "Todos",
+      operationId: "todos.update",
+      docsPath: "/docs/basecamp-api-specs/sections/todos.md#update-a-to-do"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/todos/:todoId",
+    pathParams: bucketAndTodoPathParams,
+    body: TodoUpdateBodySchema,
+    responses: {
+      200: TodoSchema
+    }
+  },
+  complete: {
+    summary: "Complete a to-do",
+    description: "Mark a to-do as completed.",
+    metadata: {
+      tag: "Todos",
+      operationId: "todos.complete",
+      docsPath: "/docs/basecamp-api-specs/sections/todos.md#complete-a-to-do"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/todos/:todoId/completion",
+    pathParams: bucketAndTodoPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  },
+  uncomplete: {
+    summary: "Uncomplete a to-do",
+    description: "Remove the completion mark from a to-do.",
+    metadata: {
+      tag: "Todos",
+      operationId: "todos.uncomplete",
+      docsPath: "/docs/basecamp-api-specs/sections/todos.md#uncomplete-a-to-do"
+    },
+    method: "DELETE",
+    path: "/buckets/:bucketId/todos/:todoId/completion",
+    pathParams: bucketAndTodoPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  },
+  reposition: {
+    summary: "Reposition a to-do",
+    description: "Change the position of a to-do within its list.",
+    metadata: {
+      tag: "Todos",
+      operationId: "todos.reposition",
+      docsPath: "/docs/basecamp-api-specs/sections/todos.md#reposition-a-to-do"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/todos/:todoId/position",
+    pathParams: bucketAndTodoPathParams,
+    body: TodoRepositionBodySchema,
+    responses: {
+      204: c.noBody()
+    }
+  },
+  trash: {
+    summary: "Trash a to-do",
+    description: "Move a to-do to the trash queue.",
+    metadata: {
+      tag: "Todos",
+      operationId: "todos.trash",
+      docsPath: "/docs/basecamp-api-specs/sections/recordings.md#trash-a-recording"
+    },
+    method: "PUT",
+    path: "/buckets/:bucketId/recordings/:todoId/status/trashed",
+    pathParams: bucketAndTodoPathParams,
+    body: c.noBody(),
+    responses: {
+      204: c.noBody()
+    }
+  }
+});
+
+// src/contract/index.ts
+var contract = c.router(
+  {
+    projects: projectsRouter,
+    people: peopleRouter,
+    recordings: recordingsRouter,
+    events: eventsRouter,
+    lineupMarkers: lineupMarkersRouter,
+    todoSets: todoSetsRouter,
+    todoLists: todoListsRouter,
+    todoListGroups: todoListGroupsRouter,
+    todos: todosRouter,
+    messageBoards: messageBoardsRouter,
+    messageTypes: messageTypesRouter,
+    messages: messagesRouter,
+    comments: commentsRouter,
+    campfires: campfiresRouter,
+    inboxes: inboxesRouter,
+    forwards: forwardsRouter,
+    inboxReplies: inboxRepliesRouter,
+    clientApprovals: clientApprovalsRouter,
+    clientCorrespondences: clientCorrespondencesRouter,
+    clientReplies: clientRepliesRouter,
+    clientVisibility: clientVisibilityRouter,
+    schedules: schedulesRouter,
+    scheduleEntries: scheduleEntriesRouter,
+    questionnaires: questionnairesRouter,
+    questions: questionsRouter,
+    documents: documentsRouter,
+    vaults: vaultsRouter,
+    uploads: uploadsRouter,
+    attachments: attachmentsRouter
+  },
+  {
+    strictStatusCodes: true,
+    baseHeaders: z59.object({
+      Authorization: z59.string().min(1),
+      "User-Agent": z59.string().min(1),
+      Accept: z59.literal("application/json").optional()
+    })
+  }
+);
+
+// src/fetcher.ts
+import { tsRestFetchApi } from "@ts-rest/core";
+var MAX_RETRIES = 20;
+var BASE_DELAY_MS = 500;
+var JITTER_MS = 250;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var parseRetryAfterHeader = (headers) => {
+  const retryAfter = headers.get("Retry-After");
+  if (!retryAfter) {
+    return void 0;
+  }
+  const asSeconds = Number(retryAfter);
+  if (!Number.isNaN(asSeconds)) {
+    return Math.max(0, asSeconds * 1e3);
+  }
+  const parsedDate = Date.parse(retryAfter);
+  if (!Number.isNaN(parsedDate)) {
+    return Math.max(0, parsedDate - Date.now());
+  }
+  return void 0;
+};
+var computeBackoffDelay = (attempt, retryAfterMs) => {
+  const linearDelay = BASE_DELAY_MS * attempt;
+  const jitter = Math.random() * JITTER_MS;
+  const computed = linearDelay + jitter;
+  if (retryAfterMs === void 0) {
+    return computed;
+  }
+  return Math.max(computed, retryAfterMs);
+};
+async function fetcher(args) {
+  const url = new URL(args.path);
+  if (!url.pathname.endsWith(".json")) {
+    url.pathname = `${url.pathname}.json`;
+  }
+  const pathWithSuffix = url.toString();
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
+    const response = await tsRestFetchApi({
+      ...args,
+      path: pathWithSuffix
+    });
+    if (response.status !== 429) {
+      return response;
+    }
+    if (attempt === MAX_RETRIES) {
+      return response;
+    }
+    const retryAfterMs = parseRetryAfterHeader(response.headers);
+    const delay = computeBackoffDelay(attempt + 1, retryAfterMs);
+    if (delay > 0) {
+      await sleep(delay);
+    }
+  }
+  throw new Error("Exceeded retry attempts for Basecamp API request.");
+}
+
+// src/buildClient.ts
+function buildClient(options) {
+  return tsRestInitClient(contract, {
+    baseUrl: `https://3.basecampapi.com/${options.accountId}`,
+    baseHeaders: {
+      Authorization: `Bearer ${options.bearerToken}`,
+      "User-Agent": options.userAgent,
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    throwOnUnknownStatus: true,
+    api: fetcher
+  });
+}
+
+// src/getBearerToken.ts
+async function getBearerToken({
+  clientId,
+  clientSecret,
+  refreshToken,
+  userAgent
+}) {
+  const response = await fetch("https://launchpad.37signals.com/authorization/token", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": userAgent
+    },
+    body: JSON.stringify({
+      type: "refresh",
+      client_id: clientId,
+      client_secret: clientSecret,
+      refresh_token: refreshToken
+    })
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`Failed to obtain access token (${response.status}): ${errorBody}`);
+  }
+  const payload = await response.json();
+  return payload.access_token;
+}
+export {
+  buildClient,
+  contract,
+  getBearerToken
+};
+//# sourceMappingURL=index.mjs.map