basecamp-client 1.0.8 → 1.0.10

package/dist/index.mjs

@@ -130,7 +130,7 @@ async function asyncPagedToArray(options) {
 import { initClient as tsRestInitClient } from "@ts-rest/core";
 
 // src/contract/index.ts
-import { z as z68 } from "zod";
+import { z as z71 } from "zod";
 
 // src/contract/c.ts
 import { initContract } from "@ts-rest/core";
@@ -1189,28 +1189,54 @@ var clientVisibilityRouter = c.router({
   }
 });
 
+// src/contract/resources/blobs.ts
+import { z as z27 } from "zod";
+var blobsRouter = c.router({
+  download: {
+    summary: "Download a blob",
+    description: "Download the raw file content of a blob. Blobs represent files embedded in documents and messages via bc-attachment tags.",
+    metadata: {
+      tag: "Blobs",
+      operationId: "blobs.download",
+      rawResponse: true
+    },
+    method: "GET",
+    path: "/blobs/:blobId/download/:filename",
+    pathParams: z27.object({
+      blobId: z27.string().min(1),
+      filename: z27.string().min(1)
+    }),
+    responses: {
+      200: c.otherResponse({
+        contentType: "application/octet-stream",
+        body: c.type()
+      })
+    }
+  }
+});
+
 // src/contract/resources/documents/documents.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 
 // src/contract/schemas/documents/documents.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var DocumentCoreSchema = RecordingBaseSchema.extend({
-  type: z27.literal("Document")
+  type: z28.literal("Document")
 });
 var DocumentSchema = DocumentCoreSchema.extend({
   content: HtmlStringSchema
 });
-var DocumentListResponseSchema = z27.array(DocumentSchema);
-var DocumentListQuerySchema = z27.object({
-  page: z27.coerce.number().int().positive().optional()
+var DocumentListResponseSchema = z28.array(DocumentSchema);
+var DocumentListQuerySchema = z28.object({
+  page: z28.coerce.number().int().positive().optional()
 });
-var DocumentCreateBodySchema = z27.object({
-  title: z27.string().min(1),
+var DocumentCreateBodySchema = z28.object({
+  title: z28.string().min(1),
   content: HtmlStringSchema,
-  status: z27.enum(["active", "draft"]).or(z27.string()).optional()
+  status: z28.enum(["active", "draft"]).or(z28.string()).optional()
 });
-var DocumentUpdateBodySchema = z27.object({
-  title: z27.string().min(1).optional(),
+var DocumentUpdateBodySchema = z28.object({
+  title: z28.string().min(1).optional(),
   content: HtmlStringSchema.optional()
 }).refine(
   (value) => Object.keys(value).length > 0,
@@ -1218,76 +1244,76 @@ var DocumentUpdateBodySchema = z27.object({
 );
 
 // src/contract/schemas/documents/vaults.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var VaultCoreSchema = RecordingBaseSchema.extend({
-  type: z28.literal("Vault")
+  type: z29.literal("Vault")
 });
 var VaultSchema = VaultCoreSchema.extend({
-  documents_count: z28.number().int().nonnegative(),
-  documents_url: z28.string().url(),
-  uploads_count: z28.number().int().nonnegative(),
-  uploads_url: z28.string().url(),
-  vaults_count: z28.number().int().nonnegative(),
-  vaults_url: z28.string().url()
-});
-var VaultListResponseSchema = z28.array(VaultSchema);
-var VaultListQuerySchema = z28.object({
-  page: z28.coerce.number().int().positive().optional()
+  documents_count: z29.number().int().nonnegative(),
+  documents_url: z29.string().url(),
+  uploads_count: z29.number().int().nonnegative(),
+  uploads_url: z29.string().url(),
+  vaults_count: z29.number().int().nonnegative(),
+  vaults_url: z29.string().url()
+});
+var VaultListResponseSchema = z29.array(VaultSchema);
+var VaultListQuerySchema = z29.object({
+  page: z29.coerce.number().int().positive().optional()
 });
-var VaultCreateBodySchema = z28.object({
-  title: z28.string().min(1)
+var VaultCreateBodySchema = z29.object({
+  title: z29.string().min(1)
 });
-var VaultUpdateBodySchema = z28.object({
-  title: z28.string().min(1)
+var VaultUpdateBodySchema = z29.object({
+  title: z29.string().min(1)
 });
 
 // src/contract/schemas/documents/uploads.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var UploadCoreSchema = RecordingBaseSchema.extend({
-  type: z29.literal("Upload")
+  type: z30.literal("Upload")
 });
 var UploadSchema = UploadCoreSchema.extend({
   description: HtmlStringSchema.optional(),
-  content_type: z29.string(),
-  byte_size: z29.number().int().nonnegative(),
-  filename: z29.string(),
-  download_url: z29.string().url(),
-  app_download_url: z29.string().url(),
-  width: z29.number().int().nonnegative().optional(),
-  height: z29.number().int().nonnegative().optional()
-});
-var UploadListResponseSchema = z29.array(UploadSchema);
-var UploadListQuerySchema = z29.object({
-  page: z29.coerce.number().int().positive().optional()
-});
-var UploadCreateBodySchema = z29.object({
-  attachable_sgid: z29.string().min(1),
+  content_type: z30.string(),
+  byte_size: z30.number().int().nonnegative(),
+  filename: z30.string(),
+  download_url: z30.string().url(),
+  app_download_url: z30.string().url(),
+  width: z30.number().int().nonnegative().optional(),
+  height: z30.number().int().nonnegative().optional()
+});
+var UploadListResponseSchema = z30.array(UploadSchema);
+var UploadListQuerySchema = z30.object({
+  page: z30.coerce.number().int().positive().optional()
+});
+var UploadCreateBodySchema = z30.object({
+  attachable_sgid: z30.string().min(1),
   description: HtmlStringSchema.optional(),
-  base_name: z29.string().optional()
+  base_name: z30.string().optional()
 });
-var UploadUpdateBodySchema = z29.object({
+var UploadUpdateBodySchema = z30.object({
   description: HtmlStringSchema.optional(),
-  base_name: z29.string().optional()
+  base_name: z30.string().optional()
 }).refine(
   (value) => Object.keys(value).length > 0,
   "At least one field must be provided to update an upload."
 );
 
 // src/contract/schemas/documents/attachments.ts
-import { z as z30 } from "zod";
-var AttachmentResponseSchema = z30.object({
-  attachable_sgid: z30.string().min(1)
+import { z as z31 } from "zod";
+var AttachmentResponseSchema = z31.object({
+  attachable_sgid: z31.string().min(1)
 });
-var AttachmentCreateQuerySchema = z30.object({
-  name: z30.string().min(1)
+var AttachmentCreateQuerySchema = z31.object({
+  name: z31.string().min(1)
 });
 
 // src/contract/resources/documents/documents.ts
-var bucketAndVaultPathParams = z31.object({
+var bucketAndVaultPathParams = z32.object({
   bucketId: BasecampIdParamSchema,
   vaultId: BasecampIdParamSchema
 });
-var bucketAndDocumentPathParams = z31.object({
+var bucketAndDocumentPathParams = z32.object({
   bucketId: BasecampIdParamSchema,
   documentId: BasecampIdParamSchema
 });
@@ -1374,12 +1400,12 @@ var documentsRouter = c.router({
 });
 
 // src/contract/resources/documents/vaults.ts
-import { z as z32 } from "zod";
-var bucketAndVaultPathParams2 = z32.object({
+import { z as z33 } from "zod";
+var bucketAndVaultPathParams2 = z33.object({
   bucketId: BasecampIdParamSchema,
   vaultId: BasecampIdParamSchema
 });
-var bucketAndParentVaultPathParams = z32.object({
+var bucketAndParentVaultPathParams = z33.object({
   bucketId: BasecampIdParamSchema,
   parentVaultId: BasecampIdParamSchema
 });
@@ -1466,12 +1492,12 @@ var vaultsRouter = c.router({
 });
 
 // src/contract/resources/documents/uploads.ts
-import { z as z33 } from "zod";
-var bucketAndVaultPathParams3 = z33.object({
+import { z as z34 } from "zod";
+var bucketAndVaultPathParams3 = z34.object({
   bucketId: BasecampIdParamSchema,
   vaultId: BasecampIdParamSchema
 });
-var bucketAndUploadPathParams = z33.object({
+var bucketAndUploadPathParams = z34.object({
   bucketId: BasecampIdParamSchema,
   uploadId: BasecampIdParamSchema
 });
@@ -1539,6 +1565,29 @@ var uploadsRouter = c.router({
       200: UploadSchema
     }
   },
+  download: {
+    summary: "Download an upload",
+    description: "Download the raw file content of an upload.",
+    metadata: {
+      tag: "Uploads",
+      operationId: "uploads.download",
+      docsPath: "/docs/basecamp-api-specs/sections/uploads.md",
+      rawResponse: true
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/uploads/:uploadId/download/:filename",
+    pathParams: z34.object({
+      bucketId: BasecampIdParamSchema,
+      uploadId: BasecampIdParamSchema,
+      filename: z34.string().min(1)
+    }),
+    responses: {
+      200: c.otherResponse({
+        contentType: "application/octet-stream",
+        body: c.type()
+      })
+    }
+  },
   trash: {
     summary: "Trash an upload",
     description: "Move an upload recording to the trash. Trashed items can be restored via the UI.",
@@ -1578,26 +1627,26 @@ var attachmentsRouter = c.router({
 });
 
 // src/contract/resources/events.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // src/contract/schemas/events.ts
-import { z as z34 } from "zod";
-var EventDetailsSchema = z34.object({}).passthrough();
-var RecordingEventSchema = z34.object({
+import { z as z35 } from "zod";
+var EventDetailsSchema = z35.object({}).passthrough();
+var RecordingEventSchema = z35.object({
   id: BasecampIdSchema,
   recording_id: BasecampIdSchema,
-  action: z34.string(),
+  action: z35.string(),
   details: EventDetailsSchema,
   created_at: IsoDateTimeSchema,
   creator: PersonSummarySchema
 });
-var RecordingEventListResponseSchema = z34.array(RecordingEventSchema);
-var RecordingEventListQuerySchema = z34.object({
-  page: z34.coerce.number().int().positive().optional()
+var RecordingEventListResponseSchema = z35.array(RecordingEventSchema);
+var RecordingEventListQuerySchema = z35.object({
+  page: z35.coerce.number().int().positive().optional()
 });
 
 // src/contract/resources/events.ts
-var RecordingEventsPathParamsSchema = z35.object({
+var RecordingEventsPathParamsSchema = z36.object({
   bucketId: BasecampIdParamSchema,
   recordingId: BasecampIdParamSchema
 });
@@ -1621,23 +1670,23 @@ var eventsRouter = c.router({
 });
 
 // src/contract/resources/lineup-markers.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 
 // src/contract/schemas/lineup-markers.ts
-import { z as z36 } from "zod";
-var LineupMarkerCreateBodySchema = z36.object({
-  name: z36.string().min(1),
+import { z as z37 } from "zod";
+var LineupMarkerCreateBodySchema = z37.object({
+  name: z37.string().min(1),
   date: IsoDateSchema
 });
-var LineupMarkerUpdateBodySchema = z36.object({
-  name: z36.string().min(1).optional(),
+var LineupMarkerUpdateBodySchema = z37.object({
+  name: z37.string().min(1).optional(),
   date: IsoDateSchema.optional()
 }).refine((value) => value.name !== void 0 || value.date !== void 0, {
   message: "Either name or date must be provided."
 });
 
 // src/contract/resources/lineup-markers.ts
-var LineupMarkerPathParamsSchema = z37.object({
+var LineupMarkerPathParamsSchema = z38.object({
   markerId: BasecampIdParamSchema
 });
 var lineupMarkersRouter = c.router({
@@ -1691,25 +1740,25 @@ var lineupMarkersRouter = c.router({
 });
 
 // src/contract/resources/people.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // src/contract/schemas/people.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var PersonSchema = PersonSummarySchema;
-var PeopleListQuerySchema = z38.object({
-  page: z38.coerce.number().int().positive().optional()
-});
-var PeopleListResponseSchema = z38.array(PersonSchema);
-var ProjectAccessCreateEntrySchema = z38.object({
-  name: z38.string().min(1),
-  email_address: z38.string().email(),
-  title: z38.string().optional(),
-  company_name: z38.string().optional()
-});
-var ProjectPeopleAccessBodySchema = z38.object({
-  grant: z38.array(BasecampIdSchema).min(1).optional(),
-  revoke: z38.array(BasecampIdSchema).min(1).optional(),
-  create: z38.array(ProjectAccessCreateEntrySchema).min(1).optional()
+var PeopleListQuerySchema = z39.object({
+  page: z39.coerce.number().int().positive().optional()
+});
+var PeopleListResponseSchema = z39.array(PersonSchema);
+var ProjectAccessCreateEntrySchema = z39.object({
+  name: z39.string().min(1),
+  email_address: z39.string().email(),
+  title: z39.string().optional(),
+  company_name: z39.string().optional()
+});
+var ProjectPeopleAccessBodySchema = z39.object({
+  grant: z39.array(BasecampIdSchema).min(1).optional(),
+  revoke: z39.array(BasecampIdSchema).min(1).optional(),
+  create: z39.array(ProjectAccessCreateEntrySchema).min(1).optional()
 }).refine(
   (value) => value.grant !== void 0 || value.revoke !== void 0 || value.create !== void 0,
   {
@@ -1717,16 +1766,16 @@ var ProjectPeopleAccessBodySchema = z38.object({
     path: ["grant"]
   }
 );
-var ProjectPeopleAccessResponseSchema = z38.object({
-  granted: z38.array(PersonSchema),
-  revoked: z38.array(PersonSchema)
+var ProjectPeopleAccessResponseSchema = z39.object({
+  granted: z39.array(PersonSchema),
+  revoked: z39.array(PersonSchema)
 });
 
 // src/contract/resources/people.ts
-var ProjectPathParamsSchema = z39.object({
+var ProjectPathParamsSchema = z40.object({
   projectId: BasecampIdParamSchema
 });
-var PersonPathParamsSchema = z39.object({
+var PersonPathParamsSchema = z40.object({
   personId: BasecampIdParamSchema
 });
 var peopleRouter = c.router({
@@ -1822,59 +1871,59 @@ var peopleRouter = c.router({
 });
 
 // src/contract/resources/projects.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 
 // src/contract/schemas/projects.ts
-import { z as z40 } from "zod";
-var ProjectDockEntrySchema = z40.object({
+import { z as z41 } from "zod";
+var ProjectDockEntrySchema = z41.object({
   id: BasecampIdSchema,
-  title: z40.string(),
-  name: z40.string(),
-  enabled: z40.boolean(),
-  position: z40.number().int().nullable(),
-  url: z40.string().url(),
-  app_url: z40.string().url()
-});
-var ProjectClientCompanySchema = z40.object({
+  title: z41.string(),
+  name: z41.string(),
+  enabled: z41.boolean(),
+  position: z41.number().int().nullable(),
+  url: z41.string().url(),
+  app_url: z41.string().url()
+});
+var ProjectClientCompanySchema = z41.object({
   id: BasecampIdSchema,
-  name: z40.string()
+  name: z41.string()
 });
-var ProjectClientsideSchema = z40.object({
-  url: z40.string().url(),
-  app_url: z40.string().url()
+var ProjectClientsideSchema = z41.object({
+  url: z41.string().url(),
+  app_url: z41.string().url()
 });
-var ProjectStatusSchema = z40.enum(["active", "archived", "trashed"]).or(z40.string());
-var ProjectCoreSchema = z40.object({
+var ProjectStatusSchema = z41.enum(["active", "archived", "trashed"]).or(z41.string());
+var ProjectCoreSchema = z41.object({
   id: BasecampIdSchema,
   status: ProjectStatusSchema,
   created_at: IsoDateTimeSchema,
   updated_at: IsoDateTimeSchema,
-  name: z40.string(),
+  name: z41.string(),
   description: HtmlStringSchema.nullable().optional(),
-  purpose: z40.string(),
-  clients_enabled: z40.boolean(),
-  bookmark_url: z40.string().url(),
-  url: z40.string().url(),
-  app_url: z40.string().url(),
-  dock: z40.array(ProjectDockEntrySchema),
+  purpose: z41.string(),
+  clients_enabled: z41.boolean(),
+  bookmark_url: z41.string().url(),
+  url: z41.string().url(),
+  app_url: z41.string().url(),
+  dock: z41.array(ProjectDockEntrySchema),
   client_company: ProjectClientCompanySchema.optional(),
   clientside: ProjectClientsideSchema.optional()
 });
 var ProjectSchema = ProjectCoreSchema.extend({
-  bookmarked: z40.boolean().optional()
+  bookmarked: z41.boolean().optional()
 });
-var ProjectListResponseSchema = z40.array(ProjectSchema);
-var ProjectListQuerySchema = z40.object({
-  status: z40.enum(["active", "archived", "trashed"]).or(z40.string()).optional(),
-  page: z40.coerce.number().int().positive().optional()
+var ProjectListResponseSchema = z41.array(ProjectSchema);
+var ProjectListQuerySchema = z41.object({
+  status: z41.enum(["active", "archived", "trashed"]).or(z41.string()).optional(),
+  page: z41.coerce.number().int().positive().optional()
 });
-var ProjectCreateBodySchema = z40.object({
-  name: z40.string().min(1),
+var ProjectCreateBodySchema = z41.object({
+  name: z41.string().min(1),
   description: HtmlStringSchema.nullable().optional()
 });
-var ScheduleAttributesSchema = z40.object({
-  start_date: z40.string().date().optional(),
-  end_date: z40.string().date().optional()
+var ScheduleAttributesSchema = z41.object({
+  start_date: z41.string().date().optional(),
+  end_date: z41.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,
   {
@@ -1882,15 +1931,15 @@ var ScheduleAttributesSchema = z40.object({
     path: ["end_date"]
   }
 );
-var ProjectUpdateBodySchema = z40.object({
-  name: z40.string().min(1),
+var ProjectUpdateBodySchema = z41.object({
+  name: z41.string().min(1),
   description: HtmlStringSchema.nullable().optional(),
-  admissions: z40.enum(["invite", "employee", "team"]).or(z40.string()).optional(),
+  admissions: z41.enum(["invite", "employee", "team"]).or(z41.string()).optional(),
   schedule_attributes: ScheduleAttributesSchema.optional()
 });
 
 // src/contract/resources/projects.ts
-var ProjectPathParamsSchema2 = z41.object({
+var ProjectPathParamsSchema2 = z42.object({
   projectId: BasecampIdParamSchema
 });
 var projectsRouter = c.router({
@@ -1937,8 +1986,8 @@ var projectsRouter = c.router({
     body: ProjectCreateBodySchema,
     responses: {
       201: ProjectSchema,
-      507: z41.object({
-        error: z41.string()
+      507: z42.object({
+        error: z42.string()
       })
     }
   },
@@ -1977,8 +2026,8 @@ var projectsRouter = c.router({
 });
 
 // src/contract/resources/recordings.ts
-import { z as z42 } from "zod";
-var BucketRecordingPathParamsSchema = z42.object({
+import { z as z43 } from "zod";
+var BucketRecordingPathParamsSchema = z43.object({
   bucketId: BasecampIdParamSchema,
   recordingId: BasecampIdParamSchema
 });
@@ -2049,14 +2098,14 @@ var recordingsRouter = c.router({
 });
 
 // src/contract/resources/kanban/card-tables.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 
 // src/contract/schemas/kanban/card-tables.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 
 // src/contract/schemas/kanban/common.ts
-import { z as z43 } from "zod";
-var KanbanColumnColorSchema = z43.enum([
+import { z as z44 } from "zod";
+var KanbanColumnColorSchema = z44.enum([
   "white",
   "red",
   "orange",
@@ -2068,22 +2117,22 @@ var KanbanColumnColorSchema = z43.enum([
   "gray",
   "pink",
   "brown"
-]).or(z43.string());
+]).or(z44.string());
 
 // src/contract/schemas/kanban/columns.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var CardTableColumnSchema = RecordingBaseSchema.extend({
-  type: z44.enum(["Kanban::Column", "Kanban::Triage", "Kanban::NotNowColumn", "Kanban::DoneColumn"]),
+  type: z45.enum(["Kanban::Column", "Kanban::Triage", "Kanban::NotNowColumn", "Kanban::DoneColumn"]),
   description: HtmlStringSchema.nullable().optional(),
-  subscribers: z44.array(PersonSummarySchema),
+  subscribers: z45.array(PersonSummarySchema),
   color: KanbanColumnColorSchema.nullable().optional(),
-  cards_count: z44.number().int().nonnegative().optional(),
-  comment_count: z44.number().int().nonnegative().optional(),
-  cards_url: z44.string().url(),
-  on_hold: z44.unknown().optional()
+  cards_count: z45.number().int().nonnegative().optional(),
+  comment_count: z45.number().int().nonnegative().optional(),
+  cards_url: z45.string().url(),
+  on_hold: z45.unknown().optional()
 });
-var CardTableColumnCreateBodySchema = z44.object({
-  title: z44.string().min(1),
+var CardTableColumnCreateBodySchema = z45.object({
+  title: z45.string().min(1),
   description: HtmlStringSchema.nullable().optional()
 });
 var CardTableColumnUpdateBodySchema = CardTableColumnCreateBodySchema.partial().refine(
@@ -2092,41 +2141,41 @@ var CardTableColumnUpdateBodySchema = CardTableColumnCreateBodySchema.partial().
     message: "At least one field must be provided to update a column."
   }
 );
-var CardTableColumnMoveBodySchema = z44.object({
+var CardTableColumnMoveBodySchema = z45.object({
   source_id: BasecampIdSchema,
   target_id: BasecampIdSchema,
-  position: z44.number().int().positive().optional()
+  position: z45.number().int().positive().optional()
 });
-var CardTableColumnColorBodySchema = z44.object({
+var CardTableColumnColorBodySchema = z45.object({
   color: KanbanColumnColorSchema
 });
 
 // src/contract/schemas/kanban/card-tables.ts
 var CardTableSchema = RecordingBaseSchema.extend({
-  type: z45.literal("Kanban::Board"),
-  subscribers: z45.array(PersonSummarySchema),
-  public_link_url: z45.string().url().optional(),
-  lists: z45.array(CardTableColumnSchema)
+  type: z46.literal("Kanban::Board"),
+  subscribers: z46.array(PersonSummarySchema),
+  public_link_url: z46.string().url().optional(),
+  lists: z46.array(CardTableColumnSchema)
 });
 
 // src/contract/schemas/kanban/cards.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 
 // src/contract/schemas/kanban/steps.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 var CardTableStepSchema = RecordingBaseSchema.extend({
-  type: z46.literal("Kanban::Step"),
-  completed: z46.boolean(),
+  type: z47.literal("Kanban::Step"),
+  completed: z47.boolean(),
   due_on: IsoDateSchema.nullable().optional(),
-  assignees: z46.array(PersonSummarySchema),
-  completion_url: z46.string().min(1),
-  completion_subscribers: z46.array(PersonSummarySchema).optional(),
+  assignees: z47.array(PersonSummarySchema),
+  completion_url: z47.string().min(1),
+  completion_subscribers: z47.array(PersonSummarySchema).optional(),
   description: HtmlStringSchema.nullable().optional()
 });
-var CardTableStepCreateBodySchema = z46.object({
-  title: z46.string().min(1),
+var CardTableStepCreateBodySchema = z47.object({
+  title: z47.string().min(1),
   due_on: IsoDateSchema.optional(),
-  assignees: z46.string().optional()
+  assignees: z47.string().optional()
 });
 var CardTableStepUpdateBodySchema = CardTableStepCreateBodySchema.partial().refine(
   (value) => value.title !== void 0 || value.due_on !== void 0 || value.assignees !== void 0,
@@ -2134,57 +2183,57 @@ var CardTableStepUpdateBodySchema = CardTableStepCreateBodySchema.partial().refi
     message: "At least one field must be provided to update a step."
   }
 );
-var CardTableStepCompletionBodySchema = z46.object({
-  completion: z46.enum(["on", "off"])
+var CardTableStepCompletionBodySchema = z47.object({
+  completion: z47.enum(["on", "off"])
 });
-var CardTableStepRepositionBodySchema = z46.object({
+var CardTableStepRepositionBodySchema = z47.object({
   source_id: BasecampIdSchema,
-  position: z46.number().int().nonnegative()
+  position: z47.number().int().nonnegative()
 });
 
 // src/contract/schemas/kanban/cards.ts
 var CardTableCardSchema = RecordingBaseSchema.extend({
-  type: z47.literal("Kanban::Card"),
+  type: z48.literal("Kanban::Card"),
   description: HtmlStringSchema.nullable().optional(),
-  completed: z47.boolean(),
+  completed: z48.boolean(),
   content: HtmlStringSchema.nullable().optional(),
   due_on: IsoDateSchema.nullable().optional(),
-  comment_count: z47.number().int().nonnegative().optional(),
-  assignees: z47.array(PersonSummarySchema),
-  completion_subscribers: z47.array(PersonSummarySchema),
-  completion_url: z47.string().min(1),
-  steps: z47.array(CardTableStepSchema).optional()
-});
-var CardTableCardListResponseSchema = z47.array(CardTableCardSchema);
-var CardTableCardListQuerySchema = z47.object({
-  page: z47.coerce.number().int().positive().optional()
-});
-var CardTableCardCreateBodySchema = z47.object({
-  title: z47.string().min(1),
+  comment_count: z48.number().int().nonnegative().optional(),
+  assignees: z48.array(PersonSummarySchema),
+  completion_subscribers: z48.array(PersonSummarySchema),
+  completion_url: z48.string().min(1),
+  steps: z48.array(CardTableStepSchema).optional()
+});
+var CardTableCardListResponseSchema = z48.array(CardTableCardSchema);
+var CardTableCardListQuerySchema = z48.object({
+  page: z48.coerce.number().int().positive().optional()
+});
+var CardTableCardCreateBodySchema = z48.object({
+  title: z48.string().min(1),
   content: HtmlStringSchema.nullable().optional(),
   due_on: IsoDateSchema.optional(),
-  notify: z47.boolean().optional(),
-  assignee_ids: z47.array(BasecampIdSchema).optional()
+  notify: z48.boolean().optional(),
+  assignee_ids: z48.array(BasecampIdSchema).optional()
 });
-var CardTableCardUpdateBodySchema = z47.object({
-  title: z47.string().min(1).optional(),
+var CardTableCardUpdateBodySchema = z48.object({
+  title: z48.string().min(1).optional(),
   content: HtmlStringSchema.nullable().optional(),
   due_on: IsoDateSchema.nullable().optional(),
-  assignee_ids: z47.array(BasecampIdSchema).optional(),
-  notify: z47.boolean().optional()
+  assignee_ids: z48.array(BasecampIdSchema).optional(),
+  notify: z48.boolean().optional()
 }).refine(
   (value) => value.title !== void 0 || value.content !== void 0 || value.due_on !== void 0 || value.assignee_ids !== void 0 || value.notify !== void 0,
   {
     message: "At least one field must be provided to update a card."
   }
 );
-var CardTableCardMoveBodySchema = z47.object({
+var CardTableCardMoveBodySchema = z48.object({
   column_id: BasecampIdSchema,
-  position: z47.number().int().nonnegative().optional()
+  position: z48.number().int().positive().optional()
 });
 
 // src/contract/resources/kanban/card-tables.ts
-var cardTablePathParams = z48.object({
+var cardTablePathParams = z49.object({
   bucketId: BasecampIdParamSchema,
   cardTableId: BasecampIdParamSchema
 });
@@ -2207,8 +2256,8 @@ var cardTablesRouter = c.router({
 });
 
 // src/contract/resources/kanban/columns.ts
-import { z as z49 } from "zod";
-var bucketParams = z49.object({
+import { z as z50 } from "zod";
+var bucketParams = z50.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndCardTableParams = bucketParams.extend({
@@ -2364,8 +2413,8 @@ var cardTableColumnsRouter = c.router({
 });
 
 // src/contract/resources/kanban/cards.ts
-import { z as z50 } from "zod";
-var bucketParams2 = z50.object({
+import { z as z51 } from "zod";
+var bucketParams2 = z51.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndColumnParams2 = bucketParams2.extend({
@@ -2457,8 +2506,8 @@ var cardTableCardsRouter = c.router({
 });
 
 // src/contract/resources/kanban/steps.ts
-import { z as z51 } from "zod";
-var bucketParams3 = z51.object({
+import { z as z52 } from "zod";
+var bucketParams3 = z52.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndCardParams2 = bucketParams3.extend({
@@ -2535,22 +2584,22 @@ var cardTableStepsRouter = c.router({
 });
 
 // src/contract/resources/scheduling/schedules.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 
 // src/contract/schemas/scheduling/schedules.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 var ScheduleSchema = RecordingBaseSchema.extend({
-  type: z52.literal("Schedule"),
-  include_due_assignments: z52.boolean(),
-  entries_count: z52.number().int(),
-  entries_url: z52.string().url()
+  type: z53.literal("Schedule"),
+  include_due_assignments: z53.boolean(),
+  entries_count: z53.number().int(),
+  entries_url: z53.string().url()
 });
-var ScheduleUpdateBodySchema = z52.object({
-  include_due_assignments: z52.boolean()
+var ScheduleUpdateBodySchema = z53.object({
+  include_due_assignments: z53.boolean()
 });
 
 // src/contract/resources/scheduling/schedules.ts
-var bucketAndSchedulePathParams = z53.object({
+var bucketAndSchedulePathParams = z54.object({
   bucketId: BasecampIdParamSchema,
   scheduleId: BasecampIdParamSchema
 });
@@ -2589,68 +2638,68 @@ var schedulesRouter = c.router({
 });
 
 // src/contract/resources/scheduling/schedule-entries.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 
 // src/contract/schemas/scheduling/schedule-entries.ts
-import { z as z54 } from "zod";
-var RecurrenceScheduleSchema = z54.object({
-  frequency: z54.string(),
-  days: z54.array(z54.number().int()),
-  hour: z54.number().int(),
-  minute: z54.number().int(),
-  week_instance: z54.number().int().nullable(),
-  week_interval: z54.number().int().nullable(),
-  month_interval: z54.number().int().nullable(),
-  start_date: z54.string(),
-  end_date: z54.string().nullable()
+import { z as z55 } from "zod";
+var RecurrenceScheduleSchema = z55.object({
+  frequency: z55.string(),
+  days: z55.array(z55.number().int()),
+  hour: z55.number().int(),
+  minute: z55.number().int(),
+  week_instance: z55.number().int().nullable(),
+  week_interval: z55.number().int().nullable(),
+  month_interval: z55.number().int().nullable(),
+  start_date: z55.string(),
+  end_date: z55.string().nullable()
 });
 var ScheduleEntrySchema = RecordingBaseSchema.extend({
-  type: z54.literal("Schedule::Entry"),
+  type: z55.literal("Schedule::Entry"),
   description: HtmlStringSchema,
-  summary: z54.string(),
-  all_day: z54.boolean(),
-  starts_at: z54.string(),
-  ends_at: z54.string(),
-  participants: z54.array(PersonSummarySchema),
+  summary: z55.string(),
+  all_day: z55.boolean(),
+  starts_at: z55.string(),
+  ends_at: z55.string(),
+  participants: z55.array(PersonSummarySchema),
   recurrence_schedule: RecurrenceScheduleSchema.optional()
 });
-var ScheduleEntryListResponseSchema = z54.array(ScheduleEntrySchema);
-var ScheduleEntryListQuerySchema = z54.object({
+var ScheduleEntryListResponseSchema = z55.array(ScheduleEntrySchema);
+var ScheduleEntryListQuerySchema = z55.object({
   status: RecordingStatusSchema.optional(),
-  page: z54.coerce.number().int().positive().optional()
+  page: z55.coerce.number().int().positive().optional()
 });
-var ScheduleEntryCreateBodySchema = z54.object({
-  summary: z54.string(),
-  starts_at: z54.string(),
-  ends_at: z54.string(),
+var ScheduleEntryCreateBodySchema = z55.object({
+  summary: z55.string(),
+  starts_at: z55.string(),
+  ends_at: z55.string(),
   description: HtmlStringSchema.optional(),
-  participant_ids: z54.array(BasecampIdSchema).optional(),
-  all_day: z54.boolean().optional(),
-  notify: z54.boolean().optional()
-});
-var ScheduleEntryUpdateBodySchema = z54.object({
-  summary: z54.string().optional(),
-  starts_at: z54.string().optional(),
-  ends_at: z54.string().optional(),
+  participant_ids: z55.array(BasecampIdSchema).optional(),
+  all_day: z55.boolean().optional(),
+  notify: z55.boolean().optional()
+});
+var ScheduleEntryUpdateBodySchema = z55.object({
+  summary: z55.string().optional(),
+  starts_at: z55.string().optional(),
+  ends_at: z55.string().optional(),
   description: HtmlStringSchema.optional(),
-  participant_ids: z54.array(BasecampIdSchema).optional(),
-  all_day: z54.boolean().optional(),
-  notify: z54.boolean().optional()
+  participant_ids: z55.array(BasecampIdSchema).optional(),
+  all_day: z55.boolean().optional(),
+  notify: z55.boolean().optional()
 });
 
 // src/contract/resources/scheduling/schedule-entries.ts
-var bucketAndSchedulePathParams2 = z55.object({
+var bucketAndSchedulePathParams2 = z56.object({
   bucketId: BasecampIdParamSchema,
   scheduleId: BasecampIdParamSchema
 });
-var bucketAndEntryPathParams = z55.object({
+var bucketAndEntryPathParams = z56.object({
   bucketId: BasecampIdParamSchema,
   scheduleEntryId: BasecampIdParamSchema
 });
-var bucketEntryOccurrencePathParams = z55.object({
+var bucketEntryOccurrencePathParams = z56.object({
   bucketId: BasecampIdParamSchema,
   scheduleEntryId: BasecampIdParamSchema,
-  occurrenceDate: z55.string()
+  occurrenceDate: z56.string()
 });
 var scheduleEntriesRouter = c.router({
   list: {
@@ -2750,19 +2799,19 @@ var scheduleEntriesRouter = c.router({
 });
 
 // src/contract/resources/scheduling/questionnaires.ts
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 
 // src/contract/schemas/scheduling/questionnaires.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 var QuestionnaireSchema = RecordingBaseSchema.extend({
-  type: z56.literal("Questionnaire"),
-  name: z56.string(),
-  questions_count: z56.number().int(),
-  questions_url: z56.string().url()
+  type: z57.literal("Questionnaire"),
+  name: z57.string(),
+  questions_count: z57.number().int(),
+  questions_url: z57.string().url()
 });
 
 // src/contract/resources/scheduling/questionnaires.ts
-var bucketAndQuestionnairePathParams = z57.object({
+var bucketAndQuestionnairePathParams = z58.object({
   bucketId: BasecampIdParamSchema,
   questionnaireId: BasecampIdParamSchema
 });
@@ -2785,39 +2834,39 @@ var questionnairesRouter = c.router({
 });
 
 // src/contract/resources/scheduling/questions.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 
 // src/contract/schemas/scheduling/questions.ts
-import { z as z58 } from "zod";
-var QuestionScheduleSchema = z58.object({
-  frequency: z58.string(),
-  days: z58.array(z58.number().int()),
-  hour: z58.number().int(),
-  minute: z58.number().int(),
-  week_instance: z58.number().int().nullable(),
-  week_interval: z58.number().int().nullable(),
-  month_interval: z58.number().int().nullable(),
-  start_date: z58.string(),
-  end_date: z58.string().nullable()
+import { z as z59 } from "zod";
+var QuestionScheduleSchema = z59.object({
+  frequency: z59.string(),
+  days: z59.array(z59.number().int()),
+  hour: z59.number().int(),
+  minute: z59.number().int(),
+  week_instance: z59.number().int().nullable(),
+  week_interval: z59.number().int().nullable(),
+  month_interval: z59.number().int().nullable(),
+  start_date: z59.string(),
+  end_date: z59.string().nullable()
 });
 var QuestionSchema = RecordingBaseSchema.extend({
-  type: z58.literal("Question"),
-  paused: z58.boolean(),
+  type: z59.literal("Question"),
+  paused: z59.boolean(),
   schedule: QuestionScheduleSchema,
-  answers_count: z58.number().int(),
-  answers_url: z58.string().url()
+  answers_count: z59.number().int(),
+  answers_url: z59.string().url()
 });
-var QuestionListResponseSchema = z58.array(QuestionSchema);
-var QuestionListQuerySchema = z58.object({
-  page: z58.coerce.number().int().positive().optional()
+var QuestionListResponseSchema = z59.array(QuestionSchema);
+var QuestionListQuerySchema = z59.object({
+  page: z59.coerce.number().int().positive().optional()
 });
 
 // src/contract/resources/scheduling/questions.ts
-var bucketAndQuestionnairePathParams2 = z59.object({
+var bucketAndQuestionnairePathParams2 = z60.object({
   bucketId: BasecampIdParamSchema,
   questionnaireId: BasecampIdParamSchema
 });
-var bucketAndQuestionPathParams = z59.object({
+var bucketAndQuestionPathParams = z60.object({
   bucketId: BasecampIdParamSchema,
   questionId: BasecampIdParamSchema
 });
@@ -2855,26 +2904,104 @@ var questionsRouter = c.router({
   }
 });
 
-// src/contract/resources/tasks/todosets.ts
+// src/contract/resources/scheduling/question-answers.ts
+import { z as z62 } from "zod";
+
+// src/contract/schemas/scheduling/question-answers.ts
 import { z as z61 } from "zod";
+var QuestionAnswerSchema = RecordingBaseSchema.extend({
+  type: z61.literal("Question::Answer"),
+  content: HtmlStringSchema,
+  group_on: z61.string()
+});
+var QuestionAnswerListResponseSchema = z61.array(QuestionAnswerSchema);
+var QuestionAnswerListQuerySchema = z61.object({
+  page: z61.coerce.number().int().positive().optional()
+});
+var QuestionAnswerCreateBodySchema = z61.object({
+  content: HtmlStringSchema.min(1),
+  group_on: z61.string()
+});
+
+// src/contract/resources/scheduling/question-answers.ts
+var bucketAndQuestionPathParams2 = z62.object({
+  bucketId: BasecampIdParamSchema,
+  questionId: BasecampIdParamSchema
+});
+var bucketAndAnswerPathParams = z62.object({
+  bucketId: BasecampIdParamSchema,
+  answerId: BasecampIdParamSchema
+});
+var questionAnswersRouter = c.router({
+  list: {
+    summary: "List question answers",
+    description: "Returns a paginated list of answers for a specific check-in question.",
+    metadata: {
+      tag: "Question Answers",
+      operationId: "questionAnswers.list",
+      docsPath: "/docs/basecamp-api-specs/sections/question_answers.md#get-question-answers"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/questions/:questionId/answers",
+    pathParams: bucketAndQuestionPathParams2,
+    query: QuestionAnswerListQuerySchema,
+    responses: {
+      200: QuestionAnswerListResponseSchema
+    }
+  },
+  get: {
+    summary: "Get a question answer",
+    description: "Returns a single question answer by its ID.",
+    metadata: {
+      tag: "Question Answers",
+      operationId: "questionAnswers.get",
+      docsPath: "/docs/basecamp-api-specs/sections/question_answers.md#get-a-question-answer"
+    },
+    method: "GET",
+    path: "/buckets/:bucketId/question_answers/:answerId",
+    pathParams: bucketAndAnswerPathParams,
+    responses: {
+      200: QuestionAnswerSchema
+    }
+  },
+  create: {
+    summary: "Create a question answer",
+    description: "Create a new answer for a check-in question.",
+    metadata: {
+      tag: "Question Answers",
+      operationId: "questionAnswers.create",
+      docsPath: "/docs/basecamp-api-specs/sections/question_answers.md#get-question-answers"
+    },
+    method: "POST",
+    path: "/buckets/:bucketId/questions/:questionId/answers",
+    pathParams: bucketAndQuestionPathParams2,
+    body: QuestionAnswerCreateBodySchema,
+    responses: {
+      201: QuestionAnswerSchema
+    }
+  }
+});
+
+// src/contract/resources/tasks/todosets.ts
+import { z as z64 } from "zod";
 
 // src/contract/schemas/tasks/todosets.ts
-import { z as z60 } from "zod";
+import { z as z63 } from "zod";
 var TodoSetSchema = RecordingBaseSchema.omit({
   subscription_url: true,
   comments_count: true,
   comments_url: true
 }).extend({
-  completed: z60.boolean(),
-  completed_ratio: z60.string(),
-  name: z60.string(),
-  todolists_count: z60.number().int().nonnegative(),
-  todolists_url: z60.string().url(),
-  app_todoslists_url: z60.string().url()
+  completed: z63.boolean(),
+  completed_ratio: z63.string(),
+  name: z63.string(),
+  todolists_count: z63.number().int().nonnegative(),
+  todolists_url: z63.string().url(),
+  app_todoslists_url: z63.string().url()
 });
 
 // src/contract/resources/tasks/todosets.ts
-var bucketPathParams2 = z61.object({
+var bucketPathParams2 = z64.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndTodoSetPathParams = bucketPathParams2.extend({
@@ -2899,42 +3026,42 @@ var todoSetsRouter = c.router({
 });
 
 // src/contract/resources/tasks/todolists.ts
-import { z as z63 } from "zod";
+import { z as z66 } from "zod";
 
 // src/contract/schemas/tasks/todolists.ts
-import { z as z62 } from "zod";
+import { z as z65 } from "zod";
 var TodoListBaseSchema = RecordingBaseSchema.extend({
-  type: z62.literal("Todolist"),
+  type: z65.literal("Todolist"),
   description: HtmlStringSchema.optional(),
-  completed: z62.boolean(),
-  completed_ratio: z62.string(),
-  name: z62.string(),
-  todos_url: z62.string().url(),
-  app_todos_url: z62.string().url()
+  completed: z65.boolean(),
+  completed_ratio: z65.string(),
+  name: z65.string(),
+  todos_url: z65.string().url(),
+  app_todos_url: z65.string().url()
 });
 var TodoTopLevelListSchema = TodoListBaseSchema.extend({
-  groups_url: z62.string().url()
+  groups_url: z65.string().url()
 });
 var TodoListGroupSchema = TodoListBaseSchema.extend({
-  group_position_url: z62.string().url()
+  group_position_url: z65.string().url()
 });
-var TodoListSchema = z62.union([TodoTopLevelListSchema, TodoListGroupSchema]);
-var TodoListsResponseSchema = z62.array(TodoTopLevelListSchema);
-var TodoListQuerySchema = z62.object({
-  status: z62.enum(["active", "archived", "trashed"]).or(z62.string()).optional(),
-  page: z62.coerce.number().int().positive().optional()
+var TodoListSchema = z65.union([TodoTopLevelListSchema, TodoListGroupSchema]);
+var TodoListsResponseSchema = z65.array(TodoTopLevelListSchema);
+var TodoListQuerySchema = z65.object({
+  status: z65.enum(["active", "archived", "trashed"]).or(z65.string()).optional(),
+  page: z65.coerce.number().int().positive().optional()
 });
-var TodoListCreateBodySchema = z62.object({
-  name: z62.string().min(1),
+var TodoListCreateBodySchema = z65.object({
+  name: z65.string().min(1),
   description: HtmlStringSchema.nullable().optional()
 });
-var TodoListUpdateBodySchema = z62.object({
-  name: z62.string().min(1),
+var TodoListUpdateBodySchema = z65.object({
+  name: z65.string().min(1),
   description: HtmlStringSchema.nullable().optional()
 });
 
 // src/contract/resources/tasks/todolists.ts
-var bucketPathParams3 = z63.object({
+var bucketPathParams3 = z66.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndTodoSetPathParams2 = bucketPathParams3.extend({
@@ -3026,31 +3153,31 @@ var todoListsRouter = c.router({
 });
 
 // src/contract/resources/tasks/todolist-groups.ts
-import { z as z65 } from "zod";
+import { z as z68 } from "zod";
 
 // src/contract/schemas/tasks/todolist-groups.ts
-import { z as z64 } from "zod";
+import { z as z67 } from "zod";
 var TodoListBaseSchema2 = RecordingBaseSchema.extend({
-  type: z64.literal("Todolist"),
+  type: z67.literal("Todolist"),
   description: HtmlStringSchema.optional(),
-  completed: z64.boolean(),
-  completed_ratio: z64.string(),
-  name: z64.string(),
-  todos_url: z64.string().url(),
-  app_todos_url: z64.string().url()
+  completed: z67.boolean(),
+  completed_ratio: z67.string(),
+  name: z67.string(),
+  todos_url: z67.string().url(),
+  app_todos_url: z67.string().url()
 });
 var TodoListGroupSchema2 = TodoListBaseSchema2.extend({
-  group_position_url: z64.string().url()
+  group_position_url: z67.string().url()
 });
 var TodoListSchema2 = TodoListGroupSchema2;
-var TodoListGroupsResponseSchema = z64.array(TodoListGroupSchema2);
-var TodoListGroupQuerySchema = z64.object({
-  status: z64.enum(["active", "archived", "trashed"]).or(z64.string()).optional(),
-  page: z64.coerce.number().int().positive().optional()
-});
-var TodoListGroupCreateBodySchema = z64.object({
-  name: z64.string().min(1),
-  color: z64.enum([
+var TodoListGroupsResponseSchema = z67.array(TodoListGroupSchema2);
+var TodoListGroupQuerySchema = z67.object({
+  status: z67.enum(["active", "archived", "trashed"]).or(z67.string()).optional(),
+  page: z67.coerce.number().int().positive().optional()
+});
+var TodoListGroupCreateBodySchema = z67.object({
+  name: z67.string().min(1),
+  color: z67.enum([
     "white",
     "red",
     "orange",
@@ -3062,14 +3189,14 @@ var TodoListGroupCreateBodySchema = z64.object({
     "gray",
     "pink",
     "brown"
-  ]).or(z64.string()).optional()
+  ]).or(z67.string()).optional()
 });
-var TodoListGroupRepositionBodySchema = z64.object({
-  position: z64.number().int().gte(1)
+var TodoListGroupRepositionBodySchema = z67.object({
+  position: z67.number().int().gte(1)
 });
 
 // src/contract/resources/tasks/todolist-groups.ts
-var bucketPathParams4 = z65.object({
+var bucketPathParams4 = z68.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndTodoListPathParams2 = bucketPathParams4.extend({
@@ -3130,56 +3257,56 @@ var todoListGroupsRouter = c.router({
 });
 
 // src/contract/resources/tasks/todos.ts
-import { z as z67 } from "zod";
+import { z as z70 } from "zod";
 
 // src/contract/schemas/tasks/todos.ts
-import { z as z66 } from "zod";
-var TodoCompletionSchema = z66.object({
+import { z as z69 } from "zod";
+var TodoCompletionSchema = z69.object({
   created_at: IsoDateTimeSchema,
   creator: PersonSummarySchema
 });
 var TodoSchema = RecordingBaseSchema.extend({
-  type: z66.literal("Todo"),
+  type: z69.literal("Todo"),
   description: HtmlStringSchema.optional(),
-  completed: z66.boolean(),
+  completed: z69.boolean(),
   completion: TodoCompletionSchema.optional(),
-  content: z66.string(),
-  starts_on: z66.string().date().nullable().optional(),
-  due_on: z66.string().date().nullable().optional(),
-  assignees: z66.array(PersonSummarySchema),
-  completion_subscribers: z66.array(PersonSummarySchema),
-  completion_url: z66.string().url()
-});
-var TodoCollectionResponseSchema = z66.array(TodoSchema);
-var TodoQuerySchema = z66.object({
-  status: z66.enum(["active", "archived", "trashed"]).or(z66.string()).optional(),
-  completed: z66.enum(["true"]).optional(),
-  page: z66.coerce.number().int().positive().optional()
-});
-var TodoCreateBodySchema = z66.object({
-  content: z66.string().min(1),
+  content: z69.string(),
+  starts_on: z69.string().date().nullable().optional(),
+  due_on: z69.string().date().nullable().optional(),
+  assignees: z69.array(PersonSummarySchema),
+  completion_subscribers: z69.array(PersonSummarySchema),
+  completion_url: z69.string().url()
+});
+var TodoCollectionResponseSchema = z69.array(TodoSchema);
+var TodoQuerySchema = z69.object({
+  status: z69.enum(["active", "archived", "trashed"]).or(z69.string()).optional(),
+  completed: z69.literal(true).optional(),
+  page: z69.coerce.number().int().positive().optional()
+});
+var TodoCreateBodySchema = z69.object({
+  content: z69.string().min(1),
   description: HtmlStringSchema.nullable().optional(),
-  assignee_ids: z66.array(BasecampIdSchema).optional(),
-  completion_subscriber_ids: z66.array(BasecampIdSchema).optional(),
-  notify: z66.boolean().optional(),
-  due_on: z66.string().date().nullable().optional(),
-  starts_on: z66.string().date().nullable().optional()
-});
-var TodoUpdateBodySchema = z66.object({
-  content: z66.string().min(1),
+  assignee_ids: z69.array(BasecampIdSchema).optional(),
+  completion_subscriber_ids: z69.array(BasecampIdSchema).optional(),
+  notify: z69.boolean().optional(),
+  due_on: z69.string().date().nullable().optional(),
+  starts_on: z69.string().date().nullable().optional()
+});
+var TodoUpdateBodySchema = z69.object({
+  content: z69.string().min(1),
   description: HtmlStringSchema.nullable().optional(),
-  assignee_ids: z66.array(BasecampIdSchema).optional(),
-  completion_subscriber_ids: z66.array(BasecampIdSchema).optional(),
-  notify: z66.boolean().optional(),
-  due_on: z66.string().date().nullable().optional(),
-  starts_on: z66.string().date().nullable().optional()
+  assignee_ids: z69.array(BasecampIdSchema).optional(),
+  completion_subscriber_ids: z69.array(BasecampIdSchema).optional(),
+  notify: z69.boolean().optional(),
+  due_on: z69.string().date().nullable().optional(),
+  starts_on: z69.string().date().nullable().optional()
 });
-var TodoRepositionBodySchema = z66.object({
-  position: z66.number().int().gte(1)
+var TodoRepositionBodySchema = z69.object({
+  position: z69.number().int().gte(1)
 });
 
 // src/contract/resources/tasks/todos.ts
-var bucketPathParams5 = z67.object({
+var bucketPathParams5 = z70.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndTodoListPathParams3 = bucketPathParams5.extend({
@@ -3350,17 +3477,19 @@ var contract = c.router(
     scheduleEntries: scheduleEntriesRouter,
     questionnaires: questionnairesRouter,
     questions: questionsRouter,
+    questionAnswers: questionAnswersRouter,
     documents: documentsRouter,
     vaults: vaultsRouter,
     uploads: uploadsRouter,
-    attachments: attachmentsRouter
+    attachments: attachmentsRouter,
+    blobs: blobsRouter
   },
   {
     strictStatusCodes: true,
-    baseHeaders: z68.object({
-      Authorization: z68.string().min(1),
-      "User-Agent": z68.string().min(1).optional(),
-      Accept: z68.literal("application/json").optional()
+    baseHeaders: z71.object({
+      Authorization: z71.string().min(1),
+      "User-Agent": z71.string().min(1).optional(),
+      Accept: z71.literal("application/json").optional()
     })
   }
 );
@@ -3397,15 +3526,35 @@ var computeBackoffDelay = (attempt, retryAfterMs) => {
 };
 async function fetcher(args) {
   const url = new URL(args.path);
-  if (!url.pathname.endsWith(".json")) {
+  const isRaw = args.route.metadata?.rawResponse === true;
+  if (!isRaw && !url.pathname.endsWith(".json")) {
     url.pathname = `${url.pathname}.json`;
   }
+  const headers = { ...args.headers };
+  if (isRaw) {
+    delete headers.accept;
+    delete headers.Accept;
+  }
   const pathWithSuffix = url.toString();
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
-    const response = await tsRestFetchApi({
-      ...args,
-      path: pathWithSuffix
-    });
+    let response;
+    if (isRaw) {
+      const result = await fetch(pathWithSuffix, {
+        method: args.method,
+        headers
+      });
+      response = {
+        status: result.status,
+        body: await result.arrayBuffer(),
+        headers: result.headers
+      };
+    } else {
+      response = await tsRestFetchApi({
+        ...args,
+        path: pathWithSuffix,
+        headers
+      });
+    }
     if (response.status !== 429) {
       return response;
     }