basecamp-client 1.0.1

package/dist/index.js

@@ -0,0 +1,3209 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildClient: () => buildClient,
+  contract: () => contract,
+  getBearerToken: () => getBearerToken
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/buildClient.ts
+var import_core3 = require("@ts-rest/core");
+
+// src/contract/index.ts
+var import_zod59 = require("zod");
+
+// src/contract/c.ts
+var import_core = require("@ts-rest/core");
+var c = (0, import_core.initContract)();
+
+// src/contract/resources/communications/message-boards.ts
+var import_zod3 = require("zod");
+
+// src/contract/schemas/common.ts
+var import_zod = require("zod");
+var BasecampIdSchema = import_zod.z.number().int().nonnegative();
+var BasecampIdParamSchema = import_zod.z.coerce.number().int().nonnegative();
+var IsoDateTimeSchema = import_zod.z.string().datetime({ offset: true });
+var IsoDateSchema = import_zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be formatted as YYYY-MM-DD");
+var RecordingStatusSchema = import_zod.z.enum(["active", "trashed"]).or(import_zod.z.string());
+var HtmlStringSchema = import_zod.z.string().min(0);
+var BucketRefSchema = import_zod.z.object({
+  id: BasecampIdSchema,
+  name: import_zod.z.string(),
+  type: import_zod.z.string()
+});
+var RecordingRefSchema = import_zod.z.object({
+  id: BasecampIdSchema,
+  title: import_zod.z.string(),
+  type: import_zod.z.string(),
+  url: import_zod.z.string().url(),
+  app_url: import_zod.z.string().url()
+});
+var PersonSummarySchema = import_zod.z.object({
+  id: BasecampIdSchema,
+  attachable_sgid: import_zod.z.string().min(1),
+  name: import_zod.z.string(),
+  email_address: import_zod.z.string().email().nullable(),
+  personable_type: import_zod.z.string(),
+  title: import_zod.z.string().nullable(),
+  bio: import_zod.z.string().nullable(),
+  location: import_zod.z.string().nullable(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  admin: import_zod.z.boolean(),
+  owner: import_zod.z.boolean(),
+  client: import_zod.z.boolean(),
+  employee: import_zod.z.boolean(),
+  time_zone: import_zod.z.string(),
+  avatar_url: import_zod.z.string().url(),
+  company: import_zod.z.object({
+    id: BasecampIdSchema,
+    name: import_zod.z.string()
+  }).optional(),
+  can_manage_projects: import_zod.z.boolean(),
+  can_manage_people: import_zod.z.boolean()
+});
+
+// src/contract/schemas/communications/message-boards.ts
+var import_zod2 = require("zod");
+var MessageBoardRecordingCoreSchema = import_zod2.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod2.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod2.z.string(),
+  inherits_status: import_zod2.z.boolean(),
+  type: import_zod2.z.string(),
+  url: import_zod2.z.string().url(),
+  app_url: import_zod2.z.string().url(),
+  bookmark_url: import_zod2.z.string().url().optional(),
+  position: import_zod2.z.number().int().nonnegative().optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var MessageBoardSchema = MessageBoardRecordingCoreSchema.extend({
+  messages_count: import_zod2.z.number().int().nonnegative(),
+  messages_url: import_zod2.z.string().url(),
+  app_messages_url: import_zod2.z.string().url()
+});
+var MessageBoardsResponseSchema = import_zod2.z.array(MessageBoardSchema);
+
+// src/contract/resources/communications/message-boards.ts
+var bucketAndMessageBoardPathParams = import_zod3.z.object({
+  bucketId: BasecampIdParamSchema,
+  messageBoardId: BasecampIdParamSchema
+});
+var projectPathParams = import_zod3.z.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
+var import_zod5 = require("zod");
+
+// src/contract/schemas/communications/message-types.ts
+var import_zod4 = require("zod");
+var MessageTypeSchema = import_zod4.z.object({
+  id: BasecampIdSchema,
+  name: import_zod4.z.string(),
+  icon: import_zod4.z.string(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema
+});
+var MessageTypesResponseSchema = import_zod4.z.array(MessageTypeSchema);
+var MessageTypeCreateBodySchema = import_zod4.z.object({
+  name: import_zod4.z.string().min(1),
+  icon: import_zod4.z.string().min(1)
+});
+var MessageTypeUpdateBodySchema = import_zod4.z.object({
+  name: import_zod4.z.string().min(1).optional(),
+  icon: import_zod4.z.string().min(1).optional()
+});
+
+// src/contract/resources/communications/message-types.ts
+var bucketPathParams = import_zod5.z.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
+var import_zod7 = require("zod");
+
+// src/contract/schemas/communications/messages.ts
+var import_zod6 = require("zod");
+var MessageCoreSchema = import_zod6.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod6.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  inherits_status: import_zod6.z.boolean(),
+  type: import_zod6.z.string(),
+  url: import_zod6.z.string().url(),
+  app_url: import_zod6.z.string().url(),
+  bookmark_url: import_zod6.z.string().url().optional(),
+  subscription_url: import_zod6.z.string().url().optional(),
+  comments_count: import_zod6.z.number().int().nonnegative().optional(),
+  comments_url: import_zod6.z.string().url().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var MessageSummarySchema = MessageCoreSchema.extend({
+  title: import_zod6.z.string(),
+  content: HtmlStringSchema.optional()
+});
+var MessageSchema = MessageSummarySchema.extend({
+  subject: import_zod6.z.string()
+});
+var MessageListResponseSchema = import_zod6.z.array(MessageSummarySchema);
+var MessageListQuerySchema = import_zod6.z.object({
+  page: import_zod6.z.coerce.number().int().positive().optional()
+});
+var MessageCreateBodySchema = import_zod6.z.object({
+  subject: import_zod6.z.string().min(1),
+  status: import_zod6.z.enum(["active", "draft"]).or(import_zod6.z.string()),
+  content: HtmlStringSchema.optional(),
+  category_id: BasecampIdSchema.optional(),
+  subscriptions: import_zod6.z.array(BasecampIdSchema).optional()
+});
+var MessageUpdateBodySchema = import_zod6.z.object({
+  subject: import_zod6.z.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 = import_zod7.z.object({
+  bucketId: BasecampIdParamSchema,
+  messageBoardId: BasecampIdParamSchema
+});
+var bucketAndMessagePathParams = import_zod7.z.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
+var import_zod9 = require("zod");
+
+// src/contract/schemas/communications/comments.ts
+var import_zod8 = require("zod");
+var CommentRecordingCoreSchema = import_zod8.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod8.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod8.z.string(),
+  inherits_status: import_zod8.z.boolean(),
+  type: import_zod8.z.string(),
+  url: import_zod8.z.string().url(),
+  app_url: import_zod8.z.string().url(),
+  bookmark_url: import_zod8.z.string().url().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var CommentSchema = CommentRecordingCoreSchema.extend({
+  content: HtmlStringSchema
+});
+var CommentsResponseSchema = import_zod8.z.array(CommentSchema);
+var CommentListQuerySchema = import_zod8.z.object({
+  page: import_zod8.z.coerce.number().int().positive().optional()
+});
+var CommentCreateBodySchema = import_zod8.z.object({
+  content: HtmlStringSchema.min(1)
+});
+var CommentUpdateBodySchema = import_zod8.z.object({
+  content: HtmlStringSchema.min(1)
+});
+
+// src/contract/resources/communications/comments.ts
+var bucketAndRecordingPathParams = import_zod9.z.object({
+  bucketId: BasecampIdParamSchema,
+  recordingId: BasecampIdParamSchema
+});
+var bucketAndCommentPathParams = import_zod9.z.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
+var import_zod11 = require("zod");
+
+// src/contract/schemas/communications/campfires.ts
+var import_zod10 = require("zod");
+var CampfireSchema = import_zod10.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod10.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod10.z.string(),
+  inherits_status: import_zod10.z.boolean(),
+  type: import_zod10.z.string(),
+  url: import_zod10.z.string().url(),
+  app_url: import_zod10.z.string().url(),
+  bookmark_url: import_zod10.z.string().url().optional(),
+  subscription_url: import_zod10.z.string().url().optional(),
+  position: import_zod10.z.number().int().optional(),
+  topic: import_zod10.z.string(),
+  lines_url: import_zod10.z.string().url(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var CampfireListResponseSchema = import_zod10.z.array(CampfireSchema);
+var CampfireListQuerySchema = import_zod10.z.object({
+  page: import_zod10.z.coerce.number().int().positive().optional()
+});
+var CampfireLineSchema = import_zod10.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod10.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod10.z.string(),
+  inherits_status: import_zod10.z.boolean(),
+  type: import_zod10.z.string(),
+  url: import_zod10.z.string().url(),
+  app_url: import_zod10.z.string().url(),
+  bookmark_url: import_zod10.z.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: import_zod10.z.string()
+});
+var CampfireLineListResponseSchema = import_zod10.z.array(CampfireLineSchema);
+var CampfireLineListQuerySchema = import_zod10.z.object({
+  page: import_zod10.z.coerce.number().int().positive().optional()
+});
+var CampfireLineCreateBodySchema = import_zod10.z.object({
+  content: import_zod10.z.string().min(1)
+});
+
+// src/contract/resources/communications/campfires.ts
+var CampfirePathParamsSchema = import_zod11.z.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
+var import_zod13 = require("zod");
+
+// src/contract/schemas/communications/inboxes.ts
+var import_zod12 = require("zod");
+var InboxSchema = import_zod12.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod12.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod12.z.string(),
+  inherits_status: import_zod12.z.boolean(),
+  type: import_zod12.z.string(),
+  url: import_zod12.z.string().url(),
+  app_url: import_zod12.z.string().url(),
+  bookmark_url: import_zod12.z.string().url().optional(),
+  position: import_zod12.z.number().int().optional(),
+  forwards_count: import_zod12.z.number().int().nonnegative().optional(),
+  forwards_url: import_zod12.z.string().url().optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+
+// src/contract/resources/communications/inboxes.ts
+var InboxPathParamsSchema = import_zod13.z.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
+var import_zod15 = require("zod");
+
+// src/contract/schemas/communications/forwards.ts
+var import_zod14 = require("zod");
+var ForwardSchema = import_zod14.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod14.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod14.z.string(),
+  inherits_status: import_zod14.z.boolean(),
+  type: import_zod14.z.string(),
+  url: import_zod14.z.string().url(),
+  app_url: import_zod14.z.string().url(),
+  bookmark_url: import_zod14.z.string().url().optional(),
+  subscription_url: import_zod14.z.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: import_zod14.z.string(),
+  subject: import_zod14.z.string(),
+  from: import_zod14.z.string().nullable().optional(),
+  replies_count: import_zod14.z.number().int().nonnegative(),
+  replies_url: import_zod14.z.string().url()
+});
+var ForwardListResponseSchema = import_zod14.z.array(ForwardSchema);
+var ForwardListQuerySchema = import_zod14.z.object({
+  page: import_zod14.z.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/forwards.ts
+var ForwardListPathParamsSchema = import_zod15.z.object({
+  bucketId: BasecampIdParamSchema,
+  inboxId: BasecampIdParamSchema
+});
+var ForwardPathParamsSchema = import_zod15.z.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
+var import_zod17 = require("zod");
+
+// src/contract/schemas/communications/inbox-replies.ts
+var import_zod16 = require("zod");
+var InboxReplySchema = import_zod16.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod16.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod16.z.string(),
+  inherits_status: import_zod16.z.boolean(),
+  type: import_zod16.z.string(),
+  url: import_zod16.z.string().url(),
+  app_url: import_zod16.z.string().url(),
+  bookmark_url: import_zod16.z.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema
+});
+var InboxReplyListResponseSchema = import_zod16.z.array(InboxReplySchema);
+var InboxReplyListQuerySchema = import_zod16.z.object({
+  page: import_zod16.z.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/inbox-replies.ts
+var InboxReplyListPathParamsSchema = import_zod17.z.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
+var import_zod19 = require("zod");
+
+// src/contract/schemas/communications/client-approvals.ts
+var import_zod18 = require("zod");
+var ApprovalStatusEnum = import_zod18.z.enum(["pending", "approved", "rejected"]).or(import_zod18.z.string());
+var ClientApprovalResponseSchema = import_zod18.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod18.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod18.z.string(),
+  inherits_status: import_zod18.z.boolean(),
+  type: import_zod18.z.string(),
+  url: import_zod18.z.string().url().optional(),
+  app_url: import_zod18.z.string().url(),
+  bookmark_url: import_zod18.z.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema,
+  approved: import_zod18.z.boolean().optional()
+});
+var ClientApprovalSchema = import_zod18.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod18.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod18.z.string(),
+  inherits_status: import_zod18.z.boolean(),
+  type: import_zod18.z.string(),
+  url: import_zod18.z.string().url(),
+  app_url: import_zod18.z.string().url(),
+  bookmark_url: import_zod18.z.string().url().optional(),
+  subscription_url: import_zod18.z.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema,
+  subject: import_zod18.z.string(),
+  due_on: IsoDateSchema.nullable(),
+  replies_count: import_zod18.z.number().int().nonnegative(),
+  replies_url: import_zod18.z.string().url(),
+  approval_status: ApprovalStatusEnum,
+  approver: PersonSummarySchema.optional(),
+  responses: import_zod18.z.array(ClientApprovalResponseSchema).optional()
+});
+var ClientApprovalListResponseSchema = import_zod18.z.array(ClientApprovalSchema);
+var ClientApprovalListQuerySchema = import_zod18.z.object({
+  page: import_zod18.z.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/client-approvals.ts
+var ClientApprovalListPathParamsSchema = import_zod19.z.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
+var import_zod21 = require("zod");
+
+// src/contract/schemas/communications/client-correspondences.ts
+var import_zod20 = require("zod");
+var ClientCorrespondenceSchema = import_zod20.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod20.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod20.z.string(),
+  inherits_status: import_zod20.z.boolean(),
+  type: import_zod20.z.string(),
+  url: import_zod20.z.string().url(),
+  app_url: import_zod20.z.string().url(),
+  bookmark_url: import_zod20.z.string().url().optional(),
+  subscription_url: import_zod20.z.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema,
+  subject: import_zod20.z.string(),
+  replies_count: import_zod20.z.number().int().nonnegative(),
+  replies_url: import_zod20.z.string().url()
+});
+var ClientCorrespondenceListResponseSchema = import_zod20.z.array(ClientCorrespondenceSchema);
+var ClientCorrespondenceListQuerySchema = import_zod20.z.object({
+  page: import_zod20.z.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/client-correspondences.ts
+var ClientCorrespondenceListPathParamsSchema = import_zod21.z.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
+var import_zod23 = require("zod");
+
+// src/contract/schemas/communications/client-replies.ts
+var import_zod22 = require("zod");
+var ClientReplySchema = import_zod22.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod22.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod22.z.string(),
+  inherits_status: import_zod22.z.boolean(),
+  type: import_zod22.z.string(),
+  url: import_zod22.z.string().url(),
+  app_url: import_zod22.z.string().url(),
+  bookmark_url: import_zod22.z.string().url().optional(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  content: HtmlStringSchema
+});
+var ClientReplyListResponseSchema = import_zod22.z.array(ClientReplySchema);
+var ClientReplyListQuerySchema = import_zod22.z.object({
+  page: import_zod22.z.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/communications/client-replies.ts
+var ClientReplyListPathParamsSchema = import_zod23.z.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
+var import_zod26 = require("zod");
+
+// src/contract/schemas/communications/client-visibility.ts
+var import_zod25 = require("zod");
+
+// src/contract/schemas/recordings.ts
+var import_zod24 = require("zod");
+var KnownRecordingTypeSchema = import_zod24.z.enum([
+  "Comment",
+  "Document",
+  "Kanban::Card",
+  "Kanban::Step",
+  "Message",
+  "Question::Answer",
+  "Schedule::Entry",
+  "Todo",
+  "Todolist",
+  "Upload",
+  "Vault"
+]);
+var RecordingTypeSchema = KnownRecordingTypeSchema.or(import_zod24.z.string());
+var RecordingSummarySchema = import_zod24.z.object({
+  id: BasecampIdSchema,
+  type: import_zod24.z.string(),
+  status: RecordingStatusSchema.optional(),
+  title: import_zod24.z.string().optional(),
+  created_at: IsoDateTimeSchema.optional(),
+  updated_at: IsoDateTimeSchema.optional(),
+  url: import_zod24.z.string().url(),
+  app_url: import_zod24.z.string().url(),
+  bucket: BucketRefSchema.optional(),
+  parent: RecordingRefSchema.optional(),
+  creator: PersonSummarySchema.optional()
+}).passthrough();
+var RecordingListResponseSchema = import_zod24.z.array(RecordingSummarySchema);
+var RecordingListQuerySchema = import_zod24.z.object({
+  type: RecordingTypeSchema,
+  bucket: import_zod24.z.string().optional(),
+  status: RecordingStatusSchema.optional(),
+  sort: import_zod24.z.enum(["created_at", "updated_at"]).or(import_zod24.z.string()).optional(),
+  direction: import_zod24.z.enum(["asc", "desc"]).or(import_zod24.z.string()).optional(),
+  page: import_zod24.z.coerce.number().int().positive().optional()
+});
+
+// src/contract/schemas/communications/client-visibility.ts
+var ClientVisibilityUpdateBodySchema = import_zod25.z.object({
+  visible_to_clients: import_zod25.z.boolean()
+});
+var ClientVisibilityRecordingSchema = RecordingSummarySchema.extend({
+  visible_to_clients: import_zod25.z.boolean().optional()
+});
+
+// src/contract/resources/communications/client-visibility.ts
+var ClientVisibilityPathParamsSchema = import_zod26.z.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
+var import_zod31 = require("zod");
+
+// src/contract/schemas/documents/documents.ts
+var import_zod27 = require("zod");
+var DocumentCoreSchema = import_zod27.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod27.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod27.z.string(),
+  inherits_status: import_zod27.z.boolean(),
+  type: import_zod27.z.literal("Document"),
+  url: import_zod27.z.string().url(),
+  app_url: import_zod27.z.string().url(),
+  bookmark_url: import_zod27.z.string().url(),
+  subscription_url: import_zod27.z.string().url(),
+  comments_count: import_zod27.z.number().int().nonnegative(),
+  comments_url: import_zod27.z.string().url(),
+  position: import_zod27.z.number().int().nonnegative(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var DocumentSchema = DocumentCoreSchema.extend({
+  content: HtmlStringSchema
+});
+var DocumentListResponseSchema = import_zod27.z.array(DocumentSchema);
+var DocumentListQuerySchema = import_zod27.z.object({
+  page: import_zod27.z.coerce.number().int().positive().optional()
+});
+var DocumentCreateBodySchema = import_zod27.z.object({
+  title: import_zod27.z.string().min(1),
+  content: HtmlStringSchema,
+  status: import_zod27.z.enum(["active", "draft"]).or(import_zod27.z.string()).optional()
+});
+var DocumentUpdateBodySchema = import_zod27.z.object({
+  title: import_zod27.z.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
+var import_zod28 = require("zod");
+var VaultCoreSchema = import_zod28.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod28.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod28.z.string(),
+  inherits_status: import_zod28.z.boolean(),
+  type: import_zod28.z.literal("Vault"),
+  url: import_zod28.z.string().url(),
+  app_url: import_zod28.z.string().url(),
+  bookmark_url: import_zod28.z.string().url(),
+  position: import_zod28.z.number().int().nonnegative(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var VaultSchema = VaultCoreSchema.extend({
+  documents_count: import_zod28.z.number().int().nonnegative(),
+  documents_url: import_zod28.z.string().url(),
+  uploads_count: import_zod28.z.number().int().nonnegative(),
+  uploads_url: import_zod28.z.string().url(),
+  vaults_count: import_zod28.z.number().int().nonnegative(),
+  vaults_url: import_zod28.z.string().url()
+});
+var VaultListResponseSchema = import_zod28.z.array(VaultSchema);
+var VaultListQuerySchema = import_zod28.z.object({
+  page: import_zod28.z.coerce.number().int().positive().optional()
+});
+var VaultCreateBodySchema = import_zod28.z.object({
+  title: import_zod28.z.string().min(1)
+});
+var VaultUpdateBodySchema = import_zod28.z.object({
+  title: import_zod28.z.string().min(1)
+});
+
+// src/contract/schemas/documents/uploads.ts
+var import_zod29 = require("zod");
+var UploadCoreSchema = import_zod29.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod29.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod29.z.string(),
+  inherits_status: import_zod29.z.boolean(),
+  type: import_zod29.z.literal("Upload"),
+  url: import_zod29.z.string().url(),
+  app_url: import_zod29.z.string().url(),
+  bookmark_url: import_zod29.z.string().url(),
+  subscription_url: import_zod29.z.string().url(),
+  comments_count: import_zod29.z.number().int().nonnegative(),
+  comments_url: import_zod29.z.string().url(),
+  position: import_zod29.z.number().int().nonnegative(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var UploadSchema = UploadCoreSchema.extend({
+  description: HtmlStringSchema.optional(),
+  content_type: import_zod29.z.string(),
+  byte_size: import_zod29.z.number().int().nonnegative(),
+  filename: import_zod29.z.string(),
+  download_url: import_zod29.z.string().url(),
+  app_download_url: import_zod29.z.string().url(),
+  width: import_zod29.z.number().int().nonnegative().optional(),
+  height: import_zod29.z.number().int().nonnegative().optional()
+});
+var UploadListResponseSchema = import_zod29.z.array(UploadSchema);
+var UploadListQuerySchema = import_zod29.z.object({
+  page: import_zod29.z.coerce.number().int().positive().optional()
+});
+var UploadCreateBodySchema = import_zod29.z.object({
+  attachable_sgid: import_zod29.z.string().min(1),
+  description: HtmlStringSchema.optional(),
+  base_name: import_zod29.z.string().optional()
+});
+var UploadUpdateBodySchema = import_zod29.z.object({
+  description: HtmlStringSchema.optional(),
+  base_name: import_zod29.z.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
+var import_zod30 = require("zod");
+var AttachmentResponseSchema = import_zod30.z.object({
+  attachable_sgid: import_zod30.z.string().min(1)
+});
+var AttachmentCreateQuerySchema = import_zod30.z.object({
+  name: import_zod30.z.string().min(1)
+});
+
+// src/contract/resources/documents/documents.ts
+var bucketAndVaultPathParams = import_zod31.z.object({
+  bucketId: BasecampIdParamSchema,
+  vaultId: BasecampIdParamSchema
+});
+var bucketAndDocumentPathParams = import_zod31.z.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
+var import_zod32 = require("zod");
+var bucketAndVaultPathParams2 = import_zod32.z.object({
+  bucketId: BasecampIdParamSchema,
+  vaultId: BasecampIdParamSchema
+});
+var bucketAndParentVaultPathParams = import_zod32.z.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
+var import_zod33 = require("zod");
+var bucketAndVaultPathParams3 = import_zod33.z.object({
+  bucketId: BasecampIdParamSchema,
+  vaultId: BasecampIdParamSchema
+});
+var bucketAndUploadPathParams = import_zod33.z.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
+var import_zod35 = require("zod");
+
+// src/contract/schemas/events.ts
+var import_zod34 = require("zod");
+var EventDetailsSchema = import_zod34.z.object({}).passthrough();
+var RecordingEventSchema = import_zod34.z.object({
+  id: BasecampIdSchema,
+  recording_id: BasecampIdSchema,
+  action: import_zod34.z.string(),
+  details: EventDetailsSchema,
+  created_at: IsoDateTimeSchema,
+  creator: PersonSummarySchema
+});
+var RecordingEventListResponseSchema = import_zod34.z.array(RecordingEventSchema);
+var RecordingEventListQuerySchema = import_zod34.z.object({
+  page: import_zod34.z.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/events.ts
+var RecordingEventsPathParamsSchema = import_zod35.z.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
+var import_zod37 = require("zod");
+
+// src/contract/schemas/lineup-markers.ts
+var import_zod36 = require("zod");
+var LineupMarkerCreateBodySchema = import_zod36.z.object({
+  name: import_zod36.z.string().min(1),
+  date: IsoDateSchema
+});
+var LineupMarkerUpdateBodySchema = import_zod36.z.object({
+  name: import_zod36.z.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 = import_zod37.z.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
+var import_zod39 = require("zod");
+
+// src/contract/schemas/people.ts
+var import_zod38 = require("zod");
+var PersonSchema = PersonSummarySchema;
+var PeopleListQuerySchema = import_zod38.z.object({
+  page: import_zod38.z.coerce.number().int().positive().optional()
+});
+var PeopleListResponseSchema = import_zod38.z.array(PersonSchema);
+var ProjectAccessCreateEntrySchema = import_zod38.z.object({
+  name: import_zod38.z.string().min(1),
+  email_address: import_zod38.z.string().email(),
+  title: import_zod38.z.string().optional(),
+  company_name: import_zod38.z.string().optional()
+});
+var ProjectPeopleAccessBodySchema = import_zod38.z.object({
+  grant: import_zod38.z.array(BasecampIdSchema).min(1).optional(),
+  revoke: import_zod38.z.array(BasecampIdSchema).min(1).optional(),
+  create: import_zod38.z.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 = import_zod38.z.object({
+  granted: import_zod38.z.array(PersonSchema),
+  revoked: import_zod38.z.array(PersonSchema)
+});
+
+// src/contract/resources/people.ts
+var ProjectPathParamsSchema = import_zod39.z.object({
+  projectId: BasecampIdParamSchema
+});
+var PersonPathParamsSchema = import_zod39.z.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
+var import_zod41 = require("zod");
+
+// src/contract/schemas/projects.ts
+var import_zod40 = require("zod");
+var ProjectDockEntrySchema = import_zod40.z.object({
+  id: BasecampIdSchema,
+  title: import_zod40.z.string(),
+  name: import_zod40.z.string(),
+  enabled: import_zod40.z.boolean(),
+  position: import_zod40.z.number().int().nullable(),
+  url: import_zod40.z.string().url(),
+  app_url: import_zod40.z.string().url()
+});
+var ProjectClientCompanySchema = import_zod40.z.object({
+  id: BasecampIdSchema,
+  name: import_zod40.z.string()
+});
+var ProjectClientsideSchema = import_zod40.z.object({
+  url: import_zod40.z.string().url(),
+  app_url: import_zod40.z.string().url()
+});
+var ProjectStatusSchema = import_zod40.z.enum(["active", "archived", "trashed"]).or(import_zod40.z.string());
+var ProjectCoreSchema = import_zod40.z.object({
+  id: BasecampIdSchema,
+  status: ProjectStatusSchema,
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  name: import_zod40.z.string(),
+  description: HtmlStringSchema.nullable().optional(),
+  purpose: import_zod40.z.string(),
+  clients_enabled: import_zod40.z.boolean(),
+  bookmark_url: import_zod40.z.string().url(),
+  url: import_zod40.z.string().url(),
+  app_url: import_zod40.z.string().url(),
+  dock: import_zod40.z.array(ProjectDockEntrySchema),
+  client_company: ProjectClientCompanySchema.optional(),
+  clientside: ProjectClientsideSchema.optional()
+});
+var ProjectSchema = ProjectCoreSchema.extend({
+  bookmarked: import_zod40.z.boolean().optional()
+});
+var ProjectListResponseSchema = import_zod40.z.array(ProjectSchema);
+var ProjectListQuerySchema = import_zod40.z.object({
+  status: import_zod40.z.enum(["active", "archived", "trashed"]).or(import_zod40.z.string()).optional(),
+  page: import_zod40.z.coerce.number().int().positive().optional()
+});
+var ProjectCreateBodySchema = import_zod40.z.object({
+  name: import_zod40.z.string().min(1),
+  description: HtmlStringSchema.nullable().optional()
+});
+var ScheduleAttributesSchema = import_zod40.z.object({
+  start_date: import_zod40.z.string().date().optional(),
+  end_date: import_zod40.z.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 = import_zod40.z.object({
+  name: import_zod40.z.string().min(1),
+  description: HtmlStringSchema.nullable().optional(),
+  admissions: import_zod40.z.enum(["invite", "employee", "team"]).or(import_zod40.z.string()).optional(),
+  schedule_attributes: ScheduleAttributesSchema.optional()
+});
+
+// src/contract/resources/projects.ts
+var ProjectPathParamsSchema2 = import_zod41.z.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: import_zod41.z.object({
+        error: import_zod41.z.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
+var import_zod42 = require("zod");
+var BucketRecordingPathParamsSchema = import_zod42.z.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
+var import_zod44 = require("zod");
+
+// src/contract/schemas/scheduling/schedules.ts
+var import_zod43 = require("zod");
+var ScheduleSchema = import_zod43.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod43.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod43.z.string(),
+  inherits_status: import_zod43.z.boolean(),
+  type: import_zod43.z.literal("Schedule"),
+  url: import_zod43.z.string().url(),
+  app_url: import_zod43.z.string().url(),
+  bookmark_url: import_zod43.z.string().url(),
+  position: import_zod43.z.number().int(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  include_due_assignments: import_zod43.z.boolean(),
+  entries_count: import_zod43.z.number().int(),
+  entries_url: import_zod43.z.string().url()
+});
+var ScheduleUpdateBodySchema = import_zod43.z.object({
+  include_due_assignments: import_zod43.z.boolean()
+});
+
+// src/contract/resources/scheduling/schedules.ts
+var bucketAndSchedulePathParams = import_zod44.z.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
+var import_zod46 = require("zod");
+
+// src/contract/schemas/scheduling/schedule-entries.ts
+var import_zod45 = require("zod");
+var RecurrenceScheduleSchema = import_zod45.z.object({
+  frequency: import_zod45.z.string(),
+  days: import_zod45.z.array(import_zod45.z.number().int()),
+  hour: import_zod45.z.number().int(),
+  minute: import_zod45.z.number().int(),
+  week_instance: import_zod45.z.number().int().nullable(),
+  week_interval: import_zod45.z.number().int().nullable(),
+  month_interval: import_zod45.z.number().int().nullable(),
+  start_date: import_zod45.z.string(),
+  end_date: import_zod45.z.string().nullable()
+});
+var ScheduleEntrySchema = import_zod45.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod45.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod45.z.string(),
+  inherits_status: import_zod45.z.boolean(),
+  type: import_zod45.z.literal("Schedule::Entry"),
+  url: import_zod45.z.string().url(),
+  app_url: import_zod45.z.string().url(),
+  bookmark_url: import_zod45.z.string().url(),
+  subscription_url: import_zod45.z.string().url(),
+  comments_count: import_zod45.z.number().int(),
+  comments_url: import_zod45.z.string().url(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  description: HtmlStringSchema,
+  summary: import_zod45.z.string(),
+  all_day: import_zod45.z.boolean(),
+  starts_at: import_zod45.z.string(),
+  ends_at: import_zod45.z.string(),
+  participants: import_zod45.z.array(PersonSummarySchema),
+  recurrence_schedule: RecurrenceScheduleSchema.optional()
+});
+var ScheduleEntryListResponseSchema = import_zod45.z.array(ScheduleEntrySchema);
+var ScheduleEntryListQuerySchema = import_zod45.z.object({
+  status: RecordingStatusSchema.optional(),
+  page: import_zod45.z.coerce.number().int().positive().optional()
+});
+var ScheduleEntryCreateBodySchema = import_zod45.z.object({
+  summary: import_zod45.z.string(),
+  starts_at: import_zod45.z.string(),
+  ends_at: import_zod45.z.string(),
+  description: HtmlStringSchema.optional(),
+  participant_ids: import_zod45.z.array(BasecampIdSchema).optional(),
+  all_day: import_zod45.z.boolean().optional(),
+  notify: import_zod45.z.boolean().optional()
+});
+var ScheduleEntryUpdateBodySchema = import_zod45.z.object({
+  summary: import_zod45.z.string().optional(),
+  starts_at: import_zod45.z.string().optional(),
+  ends_at: import_zod45.z.string().optional(),
+  description: HtmlStringSchema.optional(),
+  participant_ids: import_zod45.z.array(BasecampIdSchema).optional(),
+  all_day: import_zod45.z.boolean().optional(),
+  notify: import_zod45.z.boolean().optional()
+});
+
+// src/contract/resources/scheduling/schedule-entries.ts
+var bucketAndSchedulePathParams2 = import_zod46.z.object({
+  bucketId: BasecampIdParamSchema,
+  scheduleId: BasecampIdParamSchema
+});
+var bucketAndEntryPathParams = import_zod46.z.object({
+  bucketId: BasecampIdParamSchema,
+  scheduleEntryId: BasecampIdParamSchema
+});
+var bucketEntryOccurrencePathParams = import_zod46.z.object({
+  bucketId: BasecampIdParamSchema,
+  scheduleEntryId: BasecampIdParamSchema,
+  occurrenceDate: import_zod46.z.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
+var import_zod48 = require("zod");
+
+// src/contract/schemas/scheduling/questionnaires.ts
+var import_zod47 = require("zod");
+var QuestionnaireSchema = import_zod47.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod47.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod47.z.string(),
+  inherits_status: import_zod47.z.boolean(),
+  type: import_zod47.z.literal("Questionnaire"),
+  url: import_zod47.z.string().url(),
+  app_url: import_zod47.z.string().url(),
+  bookmark_url: import_zod47.z.string().url(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  name: import_zod47.z.string(),
+  questions_count: import_zod47.z.number().int(),
+  questions_url: import_zod47.z.string().url()
+});
+
+// src/contract/resources/scheduling/questionnaires.ts
+var bucketAndQuestionnairePathParams = import_zod48.z.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
+var import_zod50 = require("zod");
+
+// src/contract/schemas/scheduling/questions.ts
+var import_zod49 = require("zod");
+var QuestionScheduleSchema = import_zod49.z.object({
+  frequency: import_zod49.z.string(),
+  days: import_zod49.z.array(import_zod49.z.number().int()),
+  hour: import_zod49.z.number().int(),
+  minute: import_zod49.z.number().int(),
+  week_instance: import_zod49.z.number().int().nullable(),
+  week_interval: import_zod49.z.number().int().nullable(),
+  month_interval: import_zod49.z.number().int().nullable(),
+  start_date: import_zod49.z.string(),
+  end_date: import_zod49.z.string().nullable()
+});
+var QuestionSchema = import_zod49.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod49.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod49.z.string(),
+  inherits_status: import_zod49.z.boolean(),
+  type: import_zod49.z.literal("Question"),
+  url: import_zod49.z.string().url(),
+  app_url: import_zod49.z.string().url(),
+  bookmark_url: import_zod49.z.string().url(),
+  subscription_url: import_zod49.z.string().url(),
+  parent: RecordingRefSchema,
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema,
+  paused: import_zod49.z.boolean(),
+  schedule: QuestionScheduleSchema,
+  answers_count: import_zod49.z.number().int(),
+  answers_url: import_zod49.z.string().url()
+});
+var QuestionListResponseSchema = import_zod49.z.array(QuestionSchema);
+var QuestionListQuerySchema = import_zod49.z.object({
+  page: import_zod49.z.coerce.number().int().positive().optional()
+});
+
+// src/contract/resources/scheduling/questions.ts
+var bucketAndQuestionnairePathParams2 = import_zod50.z.object({
+  bucketId: BasecampIdParamSchema,
+  questionnaireId: BasecampIdParamSchema
+});
+var bucketAndQuestionPathParams = import_zod50.z.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
+var import_zod52 = require("zod");
+
+// src/contract/schemas/tasks/todosets.ts
+var import_zod51 = require("zod");
+var TodoRecordingCoreSchema = import_zod51.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod51.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod51.z.string(),
+  inherits_status: import_zod51.z.boolean(),
+  type: import_zod51.z.string(),
+  url: import_zod51.z.string().url(),
+  app_url: import_zod51.z.string().url(),
+  bookmark_url: import_zod51.z.string().url().optional(),
+  subscription_url: import_zod51.z.string().url().optional(),
+  comments_count: import_zod51.z.number().int().nonnegative().optional(),
+  comments_url: import_zod51.z.string().url().optional(),
+  position: import_zod51.z.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: import_zod51.z.boolean(),
+  completed_ratio: import_zod51.z.string(),
+  name: import_zod51.z.string(),
+  todolists_count: import_zod51.z.number().int().nonnegative(),
+  todolists_url: import_zod51.z.string().url(),
+  app_todoslists_url: import_zod51.z.string().url()
+});
+
+// src/contract/resources/tasks/todosets.ts
+var bucketPathParams2 = import_zod52.z.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
+var import_zod54 = require("zod");
+
+// src/contract/schemas/tasks/todolists.ts
+var import_zod53 = require("zod");
+var TodoRecordingCoreSchema2 = import_zod53.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod53.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod53.z.string(),
+  inherits_status: import_zod53.z.boolean(),
+  type: import_zod53.z.string(),
+  url: import_zod53.z.string().url(),
+  app_url: import_zod53.z.string().url(),
+  bookmark_url: import_zod53.z.string().url().optional(),
+  subscription_url: import_zod53.z.string().url().optional(),
+  comments_count: import_zod53.z.number().int().nonnegative().optional(),
+  comments_url: import_zod53.z.string().url().optional(),
+  position: import_zod53.z.number().int().nonnegative().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var TodoListBaseSchema = TodoRecordingCoreSchema2.extend({
+  description: HtmlStringSchema.optional(),
+  completed: import_zod53.z.boolean(),
+  completed_ratio: import_zod53.z.string(),
+  name: import_zod53.z.string(),
+  todos_url: import_zod53.z.string().url(),
+  app_todos_url: import_zod53.z.string().url()
+});
+var TodoTopLevelListSchema = TodoListBaseSchema.extend({
+  groups_url: import_zod53.z.string().url()
+});
+var TodoListGroupSchema = TodoListBaseSchema.extend({
+  group_position_url: import_zod53.z.string().url()
+});
+var TodoListSchema = import_zod53.z.union([TodoTopLevelListSchema, TodoListGroupSchema]);
+var TodoListsResponseSchema = import_zod53.z.array(TodoTopLevelListSchema);
+var TodoListQuerySchema = import_zod53.z.object({
+  status: import_zod53.z.enum(["active", "archived", "trashed"]).or(import_zod53.z.string()).optional(),
+  page: import_zod53.z.coerce.number().int().positive().optional()
+});
+var TodoListCreateBodySchema = import_zod53.z.object({
+  name: import_zod53.z.string().min(1),
+  description: HtmlStringSchema.nullable().optional()
+});
+var TodoListUpdateBodySchema = import_zod53.z.object({
+  name: import_zod53.z.string().min(1),
+  description: HtmlStringSchema.nullable().optional()
+});
+
+// src/contract/resources/tasks/todolists.ts
+var bucketPathParams3 = import_zod54.z.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
+var import_zod56 = require("zod");
+
+// src/contract/schemas/tasks/todolist-groups.ts
+var import_zod55 = require("zod");
+var TodoRecordingCoreSchema3 = import_zod55.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod55.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod55.z.string(),
+  inherits_status: import_zod55.z.boolean(),
+  type: import_zod55.z.string(),
+  url: import_zod55.z.string().url(),
+  app_url: import_zod55.z.string().url(),
+  bookmark_url: import_zod55.z.string().url().optional(),
+  subscription_url: import_zod55.z.string().url().optional(),
+  comments_count: import_zod55.z.number().int().nonnegative().optional(),
+  comments_url: import_zod55.z.string().url().optional(),
+  position: import_zod55.z.number().int().nonnegative().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var TodoListBaseSchema2 = TodoRecordingCoreSchema3.extend({
+  description: HtmlStringSchema.optional(),
+  completed: import_zod55.z.boolean(),
+  completed_ratio: import_zod55.z.string(),
+  name: import_zod55.z.string(),
+  todos_url: import_zod55.z.string().url(),
+  app_todos_url: import_zod55.z.string().url()
+});
+var TodoListGroupSchema2 = TodoListBaseSchema2.extend({
+  group_position_url: import_zod55.z.string().url()
+});
+var TodoListSchema2 = TodoListGroupSchema2;
+var TodoListGroupsResponseSchema = import_zod55.z.array(TodoListGroupSchema2);
+var TodoListGroupQuerySchema = import_zod55.z.object({
+  status: import_zod55.z.enum(["active", "archived", "trashed"]).or(import_zod55.z.string()).optional(),
+  page: import_zod55.z.coerce.number().int().positive().optional()
+});
+var TodoListGroupCreateBodySchema = import_zod55.z.object({
+  name: import_zod55.z.string().min(1),
+  color: import_zod55.z.enum([
+    "white",
+    "red",
+    "orange",
+    "yellow",
+    "green",
+    "blue",
+    "aqua",
+    "purple",
+    "gray",
+    "pink",
+    "brown"
+  ]).or(import_zod55.z.string()).optional()
+});
+var TodoListGroupRepositionBodySchema = import_zod55.z.object({
+  position: import_zod55.z.number().int().gte(1)
+});
+
+// src/contract/resources/tasks/todolist-groups.ts
+var bucketPathParams4 = import_zod56.z.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
+var import_zod58 = require("zod");
+
+// src/contract/schemas/tasks/todos.ts
+var import_zod57 = require("zod");
+var TodoCompletionSchema = import_zod57.z.object({
+  created_at: IsoDateTimeSchema,
+  creator: PersonSummarySchema
+});
+var TodoRecordingCoreSchema4 = import_zod57.z.object({
+  id: BasecampIdSchema,
+  status: RecordingStatusSchema,
+  visible_to_clients: import_zod57.z.boolean(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema,
+  title: import_zod57.z.string(),
+  inherits_status: import_zod57.z.boolean(),
+  type: import_zod57.z.string(),
+  url: import_zod57.z.string().url(),
+  app_url: import_zod57.z.string().url(),
+  bookmark_url: import_zod57.z.string().url().optional(),
+  subscription_url: import_zod57.z.string().url().optional(),
+  comments_count: import_zod57.z.number().int().nonnegative().optional(),
+  comments_url: import_zod57.z.string().url().optional(),
+  position: import_zod57.z.number().int().nonnegative().optional(),
+  parent: RecordingRefSchema.optional(),
+  bucket: BucketRefSchema,
+  creator: PersonSummarySchema
+});
+var TodoSchema = TodoRecordingCoreSchema4.extend({
+  description: HtmlStringSchema.optional(),
+  completed: import_zod57.z.boolean(),
+  completion: TodoCompletionSchema.optional(),
+  content: import_zod57.z.string(),
+  starts_on: import_zod57.z.string().date().nullable().optional(),
+  due_on: import_zod57.z.string().date().nullable().optional(),
+  assignees: import_zod57.z.array(PersonSummarySchema),
+  completion_subscribers: import_zod57.z.array(PersonSummarySchema),
+  completion_url: import_zod57.z.string().url()
+});
+var TodoCollectionResponseSchema = import_zod57.z.array(TodoSchema);
+var TodoQuerySchema = import_zod57.z.object({
+  status: import_zod57.z.enum(["active", "archived", "trashed"]).or(import_zod57.z.string()).optional(),
+  completed: import_zod57.z.coerce.boolean().optional(),
+  page: import_zod57.z.coerce.number().int().positive().optional()
+});
+var TodoCreateBodySchema = import_zod57.z.object({
+  content: import_zod57.z.string().min(1),
+  description: HtmlStringSchema.nullable().optional(),
+  assignee_ids: import_zod57.z.array(BasecampIdSchema).optional(),
+  completion_subscriber_ids: import_zod57.z.array(BasecampIdSchema).optional(),
+  notify: import_zod57.z.boolean().optional(),
+  due_on: import_zod57.z.string().date().nullable().optional(),
+  starts_on: import_zod57.z.string().date().nullable().optional()
+});
+var TodoUpdateBodySchema = import_zod57.z.object({
+  content: import_zod57.z.string().min(1),
+  description: HtmlStringSchema.nullable().optional(),
+  assignee_ids: import_zod57.z.array(BasecampIdSchema).optional(),
+  completion_subscriber_ids: import_zod57.z.array(BasecampIdSchema).optional(),
+  notify: import_zod57.z.boolean().optional(),
+  due_on: import_zod57.z.string().date().nullable().optional(),
+  starts_on: import_zod57.z.string().date().nullable().optional()
+});
+var TodoRepositionBodySchema = import_zod57.z.object({
+  position: import_zod57.z.number().int().gte(1)
+});
+
+// src/contract/resources/tasks/todos.ts
+var bucketPathParams5 = import_zod58.z.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: import_zod59.z.object({
+      Authorization: import_zod59.z.string().min(1),
+      "User-Agent": import_zod59.z.string().min(1),
+      Accept: import_zod59.z.literal("application/json").optional()
+    })
+  }
+);
+
+// src/fetcher.ts
+var import_core2 = require("@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 (0, import_core2.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 (0, import_core3.initClient)(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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildClient,
+  contract,
+  getBearerToken
+});
+//# sourceMappingURL=index.js.map