basecamp-client 1.0.8 → 1.0.10

package/dist/index.js

@@ -160,7 +160,7 @@ async function asyncPagedToArray(options) {
 var import_core3 = require("@ts-rest/core");
 
 // src/contract/index.ts
-var import_zod68 = require("zod");
+var import_zod71 = require("zod");
 
 // src/contract/c.ts
 var import_core = require("@ts-rest/core");
@@ -1219,28 +1219,54 @@ var clientVisibilityRouter = c.router({
   }
 });
 
+// src/contract/resources/blobs.ts
+var import_zod27 = require("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: import_zod27.z.object({
+      blobId: import_zod27.z.string().min(1),
+      filename: import_zod27.z.string().min(1)
+    }),
+    responses: {
+      200: c.otherResponse({
+        contentType: "application/octet-stream",
+        body: c.type()
+      })
+    }
+  }
+});
+
 // src/contract/resources/documents/documents.ts
-var import_zod31 = require("zod");
+var import_zod32 = require("zod");
 
 // src/contract/schemas/documents/documents.ts
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 var DocumentCoreSchema = RecordingBaseSchema.extend({
-  type: import_zod27.z.literal("Document")
+  type: import_zod28.z.literal("Document")
 });
 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 DocumentListResponseSchema = import_zod28.z.array(DocumentSchema);
+var DocumentListQuerySchema = import_zod28.z.object({
+  page: import_zod28.z.coerce.number().int().positive().optional()
 });
-var DocumentCreateBodySchema = import_zod27.z.object({
-  title: import_zod27.z.string().min(1),
+var DocumentCreateBodySchema = import_zod28.z.object({
+  title: import_zod28.z.string().min(1),
   content: HtmlStringSchema,
-  status: import_zod27.z.enum(["active", "draft"]).or(import_zod27.z.string()).optional()
+  status: import_zod28.z.enum(["active", "draft"]).or(import_zod28.z.string()).optional()
 });
-var DocumentUpdateBodySchema = import_zod27.z.object({
-  title: import_zod27.z.string().min(1).optional(),
+var DocumentUpdateBodySchema = import_zod28.z.object({
+  title: import_zod28.z.string().min(1).optional(),
   content: HtmlStringSchema.optional()
 }).refine(
   (value) => Object.keys(value).length > 0,
@@ -1248,76 +1274,76 @@ var DocumentUpdateBodySchema = import_zod27.z.object({
 );
 
 // src/contract/schemas/documents/vaults.ts
-var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 var VaultCoreSchema = RecordingBaseSchema.extend({
-  type: import_zod28.z.literal("Vault")
+  type: import_zod29.z.literal("Vault")
 });
 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()
+  documents_count: import_zod29.z.number().int().nonnegative(),
+  documents_url: import_zod29.z.string().url(),
+  uploads_count: import_zod29.z.number().int().nonnegative(),
+  uploads_url: import_zod29.z.string().url(),
+  vaults_count: import_zod29.z.number().int().nonnegative(),
+  vaults_url: import_zod29.z.string().url()
+});
+var VaultListResponseSchema = import_zod29.z.array(VaultSchema);
+var VaultListQuerySchema = import_zod29.z.object({
+  page: import_zod29.z.coerce.number().int().positive().optional()
 });
-var VaultCreateBodySchema = import_zod28.z.object({
-  title: import_zod28.z.string().min(1)
+var VaultCreateBodySchema = import_zod29.z.object({
+  title: import_zod29.z.string().min(1)
 });
-var VaultUpdateBodySchema = import_zod28.z.object({
-  title: import_zod28.z.string().min(1)
+var VaultUpdateBodySchema = import_zod29.z.object({
+  title: import_zod29.z.string().min(1)
 });
 
 // src/contract/schemas/documents/uploads.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 var UploadCoreSchema = RecordingBaseSchema.extend({
-  type: import_zod29.z.literal("Upload")
+  type: import_zod30.z.literal("Upload")
 });
 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),
+  content_type: import_zod30.z.string(),
+  byte_size: import_zod30.z.number().int().nonnegative(),
+  filename: import_zod30.z.string(),
+  download_url: import_zod30.z.string().url(),
+  app_download_url: import_zod30.z.string().url(),
+  width: import_zod30.z.number().int().nonnegative().optional(),
+  height: import_zod30.z.number().int().nonnegative().optional()
+});
+var UploadListResponseSchema = import_zod30.z.array(UploadSchema);
+var UploadListQuerySchema = import_zod30.z.object({
+  page: import_zod30.z.coerce.number().int().positive().optional()
+});
+var UploadCreateBodySchema = import_zod30.z.object({
+  attachable_sgid: import_zod30.z.string().min(1),
   description: HtmlStringSchema.optional(),
-  base_name: import_zod29.z.string().optional()
+  base_name: import_zod30.z.string().optional()
 });
-var UploadUpdateBodySchema = import_zod29.z.object({
+var UploadUpdateBodySchema = import_zod30.z.object({
   description: HtmlStringSchema.optional(),
-  base_name: import_zod29.z.string().optional()
+  base_name: import_zod30.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 import_zod31 = require("zod");
+var AttachmentResponseSchema = import_zod31.z.object({
+  attachable_sgid: import_zod31.z.string().min(1)
 });
-var AttachmentCreateQuerySchema = import_zod30.z.object({
-  name: import_zod30.z.string().min(1)
+var AttachmentCreateQuerySchema = import_zod31.z.object({
+  name: import_zod31.z.string().min(1)
 });
 
 // src/contract/resources/documents/documents.ts
-var bucketAndVaultPathParams = import_zod31.z.object({
+var bucketAndVaultPathParams = import_zod32.z.object({
   bucketId: BasecampIdParamSchema,
   vaultId: BasecampIdParamSchema
 });
-var bucketAndDocumentPathParams = import_zod31.z.object({
+var bucketAndDocumentPathParams = import_zod32.z.object({
   bucketId: BasecampIdParamSchema,
   documentId: BasecampIdParamSchema
 });
@@ -1404,12 +1430,12 @@ var documentsRouter = c.router({
 });
 
 // src/contract/resources/documents/vaults.ts
-var import_zod32 = require("zod");
-var bucketAndVaultPathParams2 = import_zod32.z.object({
+var import_zod33 = require("zod");
+var bucketAndVaultPathParams2 = import_zod33.z.object({
   bucketId: BasecampIdParamSchema,
   vaultId: BasecampIdParamSchema
 });
-var bucketAndParentVaultPathParams = import_zod32.z.object({
+var bucketAndParentVaultPathParams = import_zod33.z.object({
   bucketId: BasecampIdParamSchema,
   parentVaultId: BasecampIdParamSchema
 });
@@ -1496,12 +1522,12 @@ var vaultsRouter = c.router({
 });
 
 // src/contract/resources/documents/uploads.ts
-var import_zod33 = require("zod");
-var bucketAndVaultPathParams3 = import_zod33.z.object({
+var import_zod34 = require("zod");
+var bucketAndVaultPathParams3 = import_zod34.z.object({
   bucketId: BasecampIdParamSchema,
   vaultId: BasecampIdParamSchema
 });
-var bucketAndUploadPathParams = import_zod33.z.object({
+var bucketAndUploadPathParams = import_zod34.z.object({
   bucketId: BasecampIdParamSchema,
   uploadId: BasecampIdParamSchema
 });
@@ -1569,6 +1595,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: import_zod34.z.object({
+      bucketId: BasecampIdParamSchema,
+      uploadId: BasecampIdParamSchema,
+      filename: import_zod34.z.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.",
@@ -1608,26 +1657,26 @@ var attachmentsRouter = c.router({
 });
 
 // src/contract/resources/events.ts
-var import_zod35 = require("zod");
+var import_zod36 = 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({
+var import_zod35 = require("zod");
+var EventDetailsSchema = import_zod35.z.object({}).passthrough();
+var RecordingEventSchema = import_zod35.z.object({
   id: BasecampIdSchema,
   recording_id: BasecampIdSchema,
-  action: import_zod34.z.string(),
+  action: import_zod35.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()
+var RecordingEventListResponseSchema = import_zod35.z.array(RecordingEventSchema);
+var RecordingEventListQuerySchema = import_zod35.z.object({
+  page: import_zod35.z.coerce.number().int().positive().optional()
 });
 
 // src/contract/resources/events.ts
-var RecordingEventsPathParamsSchema = import_zod35.z.object({
+var RecordingEventsPathParamsSchema = import_zod36.z.object({
   bucketId: BasecampIdParamSchema,
   recordingId: BasecampIdParamSchema
 });
@@ -1651,23 +1700,23 @@ var eventsRouter = c.router({
 });
 
 // src/contract/resources/lineup-markers.ts
-var import_zod37 = require("zod");
+var import_zod38 = 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),
+var import_zod37 = require("zod");
+var LineupMarkerCreateBodySchema = import_zod37.z.object({
+  name: import_zod37.z.string().min(1),
   date: IsoDateSchema
 });
-var LineupMarkerUpdateBodySchema = import_zod36.z.object({
-  name: import_zod36.z.string().min(1).optional(),
+var LineupMarkerUpdateBodySchema = import_zod37.z.object({
+  name: import_zod37.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({
+var LineupMarkerPathParamsSchema = import_zod38.z.object({
   markerId: BasecampIdParamSchema
 });
 var lineupMarkersRouter = c.router({
@@ -1721,25 +1770,25 @@ var lineupMarkersRouter = c.router({
 });
 
 // src/contract/resources/people.ts
-var import_zod39 = require("zod");
+var import_zod40 = require("zod");
 
 // src/contract/schemas/people.ts
-var import_zod38 = require("zod");
+var import_zod39 = 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()
+var PeopleListQuerySchema = import_zod39.z.object({
+  page: import_zod39.z.coerce.number().int().positive().optional()
+});
+var PeopleListResponseSchema = import_zod39.z.array(PersonSchema);
+var ProjectAccessCreateEntrySchema = import_zod39.z.object({
+  name: import_zod39.z.string().min(1),
+  email_address: import_zod39.z.string().email(),
+  title: import_zod39.z.string().optional(),
+  company_name: import_zod39.z.string().optional()
+});
+var ProjectPeopleAccessBodySchema = import_zod39.z.object({
+  grant: import_zod39.z.array(BasecampIdSchema).min(1).optional(),
+  revoke: import_zod39.z.array(BasecampIdSchema).min(1).optional(),
+  create: import_zod39.z.array(ProjectAccessCreateEntrySchema).min(1).optional()
 }).refine(
   (value) => value.grant !== void 0 || value.revoke !== void 0 || value.create !== void 0,
   {
@@ -1747,16 +1796,16 @@ var ProjectPeopleAccessBodySchema = import_zod38.z.object({
     path: ["grant"]
   }
 );
-var ProjectPeopleAccessResponseSchema = import_zod38.z.object({
-  granted: import_zod38.z.array(PersonSchema),
-  revoked: import_zod38.z.array(PersonSchema)
+var ProjectPeopleAccessResponseSchema = import_zod39.z.object({
+  granted: import_zod39.z.array(PersonSchema),
+  revoked: import_zod39.z.array(PersonSchema)
 });
 
 // src/contract/resources/people.ts
-var ProjectPathParamsSchema = import_zod39.z.object({
+var ProjectPathParamsSchema = import_zod40.z.object({
   projectId: BasecampIdParamSchema
 });
-var PersonPathParamsSchema = import_zod39.z.object({
+var PersonPathParamsSchema = import_zod40.z.object({
   personId: BasecampIdParamSchema
 });
 var peopleRouter = c.router({
@@ -1852,59 +1901,59 @@ var peopleRouter = c.router({
 });
 
 // src/contract/resources/projects.ts
-var import_zod41 = require("zod");
+var import_zod42 = require("zod");
 
 // src/contract/schemas/projects.ts
-var import_zod40 = require("zod");
-var ProjectDockEntrySchema = import_zod40.z.object({
+var import_zod41 = require("zod");
+var ProjectDockEntrySchema = import_zod41.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({
+  title: import_zod41.z.string(),
+  name: import_zod41.z.string(),
+  enabled: import_zod41.z.boolean(),
+  position: import_zod41.z.number().int().nullable(),
+  url: import_zod41.z.string().url(),
+  app_url: import_zod41.z.string().url()
+});
+var ProjectClientCompanySchema = import_zod41.z.object({
   id: BasecampIdSchema,
-  name: import_zod40.z.string()
+  name: import_zod41.z.string()
 });
-var ProjectClientsideSchema = import_zod40.z.object({
-  url: import_zod40.z.string().url(),
-  app_url: import_zod40.z.string().url()
+var ProjectClientsideSchema = import_zod41.z.object({
+  url: import_zod41.z.string().url(),
+  app_url: import_zod41.z.string().url()
 });
-var ProjectStatusSchema = import_zod40.z.enum(["active", "archived", "trashed"]).or(import_zod40.z.string());
-var ProjectCoreSchema = import_zod40.z.object({
+var ProjectStatusSchema = import_zod41.z.enum(["active", "archived", "trashed"]).or(import_zod41.z.string());
+var ProjectCoreSchema = import_zod41.z.object({
   id: BasecampIdSchema,
   status: ProjectStatusSchema,
   created_at: IsoDateTimeSchema,
   updated_at: IsoDateTimeSchema,
-  name: import_zod40.z.string(),
+  name: import_zod41.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),
+  purpose: import_zod41.z.string(),
+  clients_enabled: import_zod41.z.boolean(),
+  bookmark_url: import_zod41.z.string().url(),
+  url: import_zod41.z.string().url(),
+  app_url: import_zod41.z.string().url(),
+  dock: import_zod41.z.array(ProjectDockEntrySchema),
   client_company: ProjectClientCompanySchema.optional(),
   clientside: ProjectClientsideSchema.optional()
 });
 var ProjectSchema = ProjectCoreSchema.extend({
-  bookmarked: import_zod40.z.boolean().optional()
+  bookmarked: import_zod41.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 ProjectListResponseSchema = import_zod41.z.array(ProjectSchema);
+var ProjectListQuerySchema = import_zod41.z.object({
+  status: import_zod41.z.enum(["active", "archived", "trashed"]).or(import_zod41.z.string()).optional(),
+  page: import_zod41.z.coerce.number().int().positive().optional()
 });
-var ProjectCreateBodySchema = import_zod40.z.object({
-  name: import_zod40.z.string().min(1),
+var ProjectCreateBodySchema = import_zod41.z.object({
+  name: import_zod41.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()
+var ScheduleAttributesSchema = import_zod41.z.object({
+  start_date: import_zod41.z.string().date().optional(),
+  end_date: import_zod41.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,
   {
@@ -1912,15 +1961,15 @@ var ScheduleAttributesSchema = import_zod40.z.object({
     path: ["end_date"]
   }
 );
-var ProjectUpdateBodySchema = import_zod40.z.object({
-  name: import_zod40.z.string().min(1),
+var ProjectUpdateBodySchema = import_zod41.z.object({
+  name: import_zod41.z.string().min(1),
   description: HtmlStringSchema.nullable().optional(),
-  admissions: import_zod40.z.enum(["invite", "employee", "team"]).or(import_zod40.z.string()).optional(),
+  admissions: import_zod41.z.enum(["invite", "employee", "team"]).or(import_zod41.z.string()).optional(),
   schedule_attributes: ScheduleAttributesSchema.optional()
 });
 
 // src/contract/resources/projects.ts
-var ProjectPathParamsSchema2 = import_zod41.z.object({
+var ProjectPathParamsSchema2 = import_zod42.z.object({
   projectId: BasecampIdParamSchema
 });
 var projectsRouter = c.router({
@@ -1967,8 +2016,8 @@ var projectsRouter = c.router({
     body: ProjectCreateBodySchema,
     responses: {
       201: ProjectSchema,
-      507: import_zod41.z.object({
-        error: import_zod41.z.string()
+      507: import_zod42.z.object({
+        error: import_zod42.z.string()
       })
     }
   },
@@ -2007,8 +2056,8 @@ var projectsRouter = c.router({
 });
 
 // src/contract/resources/recordings.ts
-var import_zod42 = require("zod");
-var BucketRecordingPathParamsSchema = import_zod42.z.object({
+var import_zod43 = require("zod");
+var BucketRecordingPathParamsSchema = import_zod43.z.object({
   bucketId: BasecampIdParamSchema,
   recordingId: BasecampIdParamSchema
 });
@@ -2079,14 +2128,14 @@ var recordingsRouter = c.router({
 });
 
 // src/contract/resources/kanban/card-tables.ts
-var import_zod48 = require("zod");
+var import_zod49 = require("zod");
 
 // src/contract/schemas/kanban/card-tables.ts
-var import_zod45 = require("zod");
+var import_zod46 = require("zod");
 
 // src/contract/schemas/kanban/common.ts
-var import_zod43 = require("zod");
-var KanbanColumnColorSchema = import_zod43.z.enum([
+var import_zod44 = require("zod");
+var KanbanColumnColorSchema = import_zod44.z.enum([
   "white",
   "red",
   "orange",
@@ -2098,22 +2147,22 @@ var KanbanColumnColorSchema = import_zod43.z.enum([
   "gray",
   "pink",
   "brown"
-]).or(import_zod43.z.string());
+]).or(import_zod44.z.string());
 
 // src/contract/schemas/kanban/columns.ts
-var import_zod44 = require("zod");
+var import_zod45 = require("zod");
 var CardTableColumnSchema = RecordingBaseSchema.extend({
-  type: import_zod44.z.enum(["Kanban::Column", "Kanban::Triage", "Kanban::NotNowColumn", "Kanban::DoneColumn"]),
+  type: import_zod45.z.enum(["Kanban::Column", "Kanban::Triage", "Kanban::NotNowColumn", "Kanban::DoneColumn"]),
   description: HtmlStringSchema.nullable().optional(),
-  subscribers: import_zod44.z.array(PersonSummarySchema),
+  subscribers: import_zod45.z.array(PersonSummarySchema),
   color: KanbanColumnColorSchema.nullable().optional(),
-  cards_count: import_zod44.z.number().int().nonnegative().optional(),
-  comment_count: import_zod44.z.number().int().nonnegative().optional(),
-  cards_url: import_zod44.z.string().url(),
-  on_hold: import_zod44.z.unknown().optional()
+  cards_count: import_zod45.z.number().int().nonnegative().optional(),
+  comment_count: import_zod45.z.number().int().nonnegative().optional(),
+  cards_url: import_zod45.z.string().url(),
+  on_hold: import_zod45.z.unknown().optional()
 });
-var CardTableColumnCreateBodySchema = import_zod44.z.object({
-  title: import_zod44.z.string().min(1),
+var CardTableColumnCreateBodySchema = import_zod45.z.object({
+  title: import_zod45.z.string().min(1),
   description: HtmlStringSchema.nullable().optional()
 });
 var CardTableColumnUpdateBodySchema = CardTableColumnCreateBodySchema.partial().refine(
@@ -2122,41 +2171,41 @@ var CardTableColumnUpdateBodySchema = CardTableColumnCreateBodySchema.partial().
     message: "At least one field must be provided to update a column."
   }
 );
-var CardTableColumnMoveBodySchema = import_zod44.z.object({
+var CardTableColumnMoveBodySchema = import_zod45.z.object({
   source_id: BasecampIdSchema,
   target_id: BasecampIdSchema,
-  position: import_zod44.z.number().int().positive().optional()
+  position: import_zod45.z.number().int().positive().optional()
 });
-var CardTableColumnColorBodySchema = import_zod44.z.object({
+var CardTableColumnColorBodySchema = import_zod45.z.object({
   color: KanbanColumnColorSchema
 });
 
 // src/contract/schemas/kanban/card-tables.ts
 var CardTableSchema = RecordingBaseSchema.extend({
-  type: import_zod45.z.literal("Kanban::Board"),
-  subscribers: import_zod45.z.array(PersonSummarySchema),
-  public_link_url: import_zod45.z.string().url().optional(),
-  lists: import_zod45.z.array(CardTableColumnSchema)
+  type: import_zod46.z.literal("Kanban::Board"),
+  subscribers: import_zod46.z.array(PersonSummarySchema),
+  public_link_url: import_zod46.z.string().url().optional(),
+  lists: import_zod46.z.array(CardTableColumnSchema)
 });
 
 // src/contract/schemas/kanban/cards.ts
-var import_zod47 = require("zod");
+var import_zod48 = require("zod");
 
 // src/contract/schemas/kanban/steps.ts
-var import_zod46 = require("zod");
+var import_zod47 = require("zod");
 var CardTableStepSchema = RecordingBaseSchema.extend({
-  type: import_zod46.z.literal("Kanban::Step"),
-  completed: import_zod46.z.boolean(),
+  type: import_zod47.z.literal("Kanban::Step"),
+  completed: import_zod47.z.boolean(),
   due_on: IsoDateSchema.nullable().optional(),
-  assignees: import_zod46.z.array(PersonSummarySchema),
-  completion_url: import_zod46.z.string().min(1),
-  completion_subscribers: import_zod46.z.array(PersonSummarySchema).optional(),
+  assignees: import_zod47.z.array(PersonSummarySchema),
+  completion_url: import_zod47.z.string().min(1),
+  completion_subscribers: import_zod47.z.array(PersonSummarySchema).optional(),
   description: HtmlStringSchema.nullable().optional()
 });
-var CardTableStepCreateBodySchema = import_zod46.z.object({
-  title: import_zod46.z.string().min(1),
+var CardTableStepCreateBodySchema = import_zod47.z.object({
+  title: import_zod47.z.string().min(1),
   due_on: IsoDateSchema.optional(),
-  assignees: import_zod46.z.string().optional()
+  assignees: import_zod47.z.string().optional()
 });
 var CardTableStepUpdateBodySchema = CardTableStepCreateBodySchema.partial().refine(
   (value) => value.title !== void 0 || value.due_on !== void 0 || value.assignees !== void 0,
@@ -2164,57 +2213,57 @@ var CardTableStepUpdateBodySchema = CardTableStepCreateBodySchema.partial().refi
     message: "At least one field must be provided to update a step."
   }
 );
-var CardTableStepCompletionBodySchema = import_zod46.z.object({
-  completion: import_zod46.z.enum(["on", "off"])
+var CardTableStepCompletionBodySchema = import_zod47.z.object({
+  completion: import_zod47.z.enum(["on", "off"])
 });
-var CardTableStepRepositionBodySchema = import_zod46.z.object({
+var CardTableStepRepositionBodySchema = import_zod47.z.object({
   source_id: BasecampIdSchema,
-  position: import_zod46.z.number().int().nonnegative()
+  position: import_zod47.z.number().int().nonnegative()
 });
 
 // src/contract/schemas/kanban/cards.ts
 var CardTableCardSchema = RecordingBaseSchema.extend({
-  type: import_zod47.z.literal("Kanban::Card"),
+  type: import_zod48.z.literal("Kanban::Card"),
   description: HtmlStringSchema.nullable().optional(),
-  completed: import_zod47.z.boolean(),
+  completed: import_zod48.z.boolean(),
   content: HtmlStringSchema.nullable().optional(),
   due_on: IsoDateSchema.nullable().optional(),
-  comment_count: import_zod47.z.number().int().nonnegative().optional(),
-  assignees: import_zod47.z.array(PersonSummarySchema),
-  completion_subscribers: import_zod47.z.array(PersonSummarySchema),
-  completion_url: import_zod47.z.string().min(1),
-  steps: import_zod47.z.array(CardTableStepSchema).optional()
-});
-var CardTableCardListResponseSchema = import_zod47.z.array(CardTableCardSchema);
-var CardTableCardListQuerySchema = import_zod47.z.object({
-  page: import_zod47.z.coerce.number().int().positive().optional()
-});
-var CardTableCardCreateBodySchema = import_zod47.z.object({
-  title: import_zod47.z.string().min(1),
+  comment_count: import_zod48.z.number().int().nonnegative().optional(),
+  assignees: import_zod48.z.array(PersonSummarySchema),
+  completion_subscribers: import_zod48.z.array(PersonSummarySchema),
+  completion_url: import_zod48.z.string().min(1),
+  steps: import_zod48.z.array(CardTableStepSchema).optional()
+});
+var CardTableCardListResponseSchema = import_zod48.z.array(CardTableCardSchema);
+var CardTableCardListQuerySchema = import_zod48.z.object({
+  page: import_zod48.z.coerce.number().int().positive().optional()
+});
+var CardTableCardCreateBodySchema = import_zod48.z.object({
+  title: import_zod48.z.string().min(1),
   content: HtmlStringSchema.nullable().optional(),
   due_on: IsoDateSchema.optional(),
-  notify: import_zod47.z.boolean().optional(),
-  assignee_ids: import_zod47.z.array(BasecampIdSchema).optional()
+  notify: import_zod48.z.boolean().optional(),
+  assignee_ids: import_zod48.z.array(BasecampIdSchema).optional()
 });
-var CardTableCardUpdateBodySchema = import_zod47.z.object({
-  title: import_zod47.z.string().min(1).optional(),
+var CardTableCardUpdateBodySchema = import_zod48.z.object({
+  title: import_zod48.z.string().min(1).optional(),
   content: HtmlStringSchema.nullable().optional(),
   due_on: IsoDateSchema.nullable().optional(),
-  assignee_ids: import_zod47.z.array(BasecampIdSchema).optional(),
-  notify: import_zod47.z.boolean().optional()
+  assignee_ids: import_zod48.z.array(BasecampIdSchema).optional(),
+  notify: import_zod48.z.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 = import_zod47.z.object({
+var CardTableCardMoveBodySchema = import_zod48.z.object({
   column_id: BasecampIdSchema,
-  position: import_zod47.z.number().int().nonnegative().optional()
+  position: import_zod48.z.number().int().positive().optional()
 });
 
 // src/contract/resources/kanban/card-tables.ts
-var cardTablePathParams = import_zod48.z.object({
+var cardTablePathParams = import_zod49.z.object({
   bucketId: BasecampIdParamSchema,
   cardTableId: BasecampIdParamSchema
 });
@@ -2237,8 +2286,8 @@ var cardTablesRouter = c.router({
 });
 
 // src/contract/resources/kanban/columns.ts
-var import_zod49 = require("zod");
-var bucketParams = import_zod49.z.object({
+var import_zod50 = require("zod");
+var bucketParams = import_zod50.z.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndCardTableParams = bucketParams.extend({
@@ -2394,8 +2443,8 @@ var cardTableColumnsRouter = c.router({
 });
 
 // src/contract/resources/kanban/cards.ts
-var import_zod50 = require("zod");
-var bucketParams2 = import_zod50.z.object({
+var import_zod51 = require("zod");
+var bucketParams2 = import_zod51.z.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndColumnParams2 = bucketParams2.extend({
@@ -2487,8 +2536,8 @@ var cardTableCardsRouter = c.router({
 });
 
 // src/contract/resources/kanban/steps.ts
-var import_zod51 = require("zod");
-var bucketParams3 = import_zod51.z.object({
+var import_zod52 = require("zod");
+var bucketParams3 = import_zod52.z.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndCardParams2 = bucketParams3.extend({
@@ -2565,22 +2614,22 @@ var cardTableStepsRouter = c.router({
 });
 
 // src/contract/resources/scheduling/schedules.ts
-var import_zod53 = require("zod");
+var import_zod54 = require("zod");
 
 // src/contract/schemas/scheduling/schedules.ts
-var import_zod52 = require("zod");
+var import_zod53 = require("zod");
 var ScheduleSchema = RecordingBaseSchema.extend({
-  type: import_zod52.z.literal("Schedule"),
-  include_due_assignments: import_zod52.z.boolean(),
-  entries_count: import_zod52.z.number().int(),
-  entries_url: import_zod52.z.string().url()
+  type: import_zod53.z.literal("Schedule"),
+  include_due_assignments: import_zod53.z.boolean(),
+  entries_count: import_zod53.z.number().int(),
+  entries_url: import_zod53.z.string().url()
 });
-var ScheduleUpdateBodySchema = import_zod52.z.object({
-  include_due_assignments: import_zod52.z.boolean()
+var ScheduleUpdateBodySchema = import_zod53.z.object({
+  include_due_assignments: import_zod53.z.boolean()
 });
 
 // src/contract/resources/scheduling/schedules.ts
-var bucketAndSchedulePathParams = import_zod53.z.object({
+var bucketAndSchedulePathParams = import_zod54.z.object({
   bucketId: BasecampIdParamSchema,
   scheduleId: BasecampIdParamSchema
 });
@@ -2619,68 +2668,68 @@ var schedulesRouter = c.router({
 });
 
 // src/contract/resources/scheduling/schedule-entries.ts
-var import_zod55 = require("zod");
+var import_zod56 = require("zod");
 
 // src/contract/schemas/scheduling/schedule-entries.ts
-var import_zod54 = require("zod");
-var RecurrenceScheduleSchema = import_zod54.z.object({
-  frequency: import_zod54.z.string(),
-  days: import_zod54.z.array(import_zod54.z.number().int()),
-  hour: import_zod54.z.number().int(),
-  minute: import_zod54.z.number().int(),
-  week_instance: import_zod54.z.number().int().nullable(),
-  week_interval: import_zod54.z.number().int().nullable(),
-  month_interval: import_zod54.z.number().int().nullable(),
-  start_date: import_zod54.z.string(),
-  end_date: import_zod54.z.string().nullable()
+var import_zod55 = require("zod");
+var RecurrenceScheduleSchema = import_zod55.z.object({
+  frequency: import_zod55.z.string(),
+  days: import_zod55.z.array(import_zod55.z.number().int()),
+  hour: import_zod55.z.number().int(),
+  minute: import_zod55.z.number().int(),
+  week_instance: import_zod55.z.number().int().nullable(),
+  week_interval: import_zod55.z.number().int().nullable(),
+  month_interval: import_zod55.z.number().int().nullable(),
+  start_date: import_zod55.z.string(),
+  end_date: import_zod55.z.string().nullable()
 });
 var ScheduleEntrySchema = RecordingBaseSchema.extend({
-  type: import_zod54.z.literal("Schedule::Entry"),
+  type: import_zod55.z.literal("Schedule::Entry"),
   description: HtmlStringSchema,
-  summary: import_zod54.z.string(),
-  all_day: import_zod54.z.boolean(),
-  starts_at: import_zod54.z.string(),
-  ends_at: import_zod54.z.string(),
-  participants: import_zod54.z.array(PersonSummarySchema),
+  summary: import_zod55.z.string(),
+  all_day: import_zod55.z.boolean(),
+  starts_at: import_zod55.z.string(),
+  ends_at: import_zod55.z.string(),
+  participants: import_zod55.z.array(PersonSummarySchema),
   recurrence_schedule: RecurrenceScheduleSchema.optional()
 });
-var ScheduleEntryListResponseSchema = import_zod54.z.array(ScheduleEntrySchema);
-var ScheduleEntryListQuerySchema = import_zod54.z.object({
+var ScheduleEntryListResponseSchema = import_zod55.z.array(ScheduleEntrySchema);
+var ScheduleEntryListQuerySchema = import_zod55.z.object({
   status: RecordingStatusSchema.optional(),
-  page: import_zod54.z.coerce.number().int().positive().optional()
+  page: import_zod55.z.coerce.number().int().positive().optional()
 });
-var ScheduleEntryCreateBodySchema = import_zod54.z.object({
-  summary: import_zod54.z.string(),
-  starts_at: import_zod54.z.string(),
-  ends_at: import_zod54.z.string(),
+var ScheduleEntryCreateBodySchema = import_zod55.z.object({
+  summary: import_zod55.z.string(),
+  starts_at: import_zod55.z.string(),
+  ends_at: import_zod55.z.string(),
   description: HtmlStringSchema.optional(),
-  participant_ids: import_zod54.z.array(BasecampIdSchema).optional(),
-  all_day: import_zod54.z.boolean().optional(),
-  notify: import_zod54.z.boolean().optional()
-});
-var ScheduleEntryUpdateBodySchema = import_zod54.z.object({
-  summary: import_zod54.z.string().optional(),
-  starts_at: import_zod54.z.string().optional(),
-  ends_at: import_zod54.z.string().optional(),
+  participant_ids: import_zod55.z.array(BasecampIdSchema).optional(),
+  all_day: import_zod55.z.boolean().optional(),
+  notify: import_zod55.z.boolean().optional()
+});
+var ScheduleEntryUpdateBodySchema = import_zod55.z.object({
+  summary: import_zod55.z.string().optional(),
+  starts_at: import_zod55.z.string().optional(),
+  ends_at: import_zod55.z.string().optional(),
   description: HtmlStringSchema.optional(),
-  participant_ids: import_zod54.z.array(BasecampIdSchema).optional(),
-  all_day: import_zod54.z.boolean().optional(),
-  notify: import_zod54.z.boolean().optional()
+  participant_ids: import_zod55.z.array(BasecampIdSchema).optional(),
+  all_day: import_zod55.z.boolean().optional(),
+  notify: import_zod55.z.boolean().optional()
 });
 
 // src/contract/resources/scheduling/schedule-entries.ts
-var bucketAndSchedulePathParams2 = import_zod55.z.object({
+var bucketAndSchedulePathParams2 = import_zod56.z.object({
   bucketId: BasecampIdParamSchema,
   scheduleId: BasecampIdParamSchema
 });
-var bucketAndEntryPathParams = import_zod55.z.object({
+var bucketAndEntryPathParams = import_zod56.z.object({
   bucketId: BasecampIdParamSchema,
   scheduleEntryId: BasecampIdParamSchema
 });
-var bucketEntryOccurrencePathParams = import_zod55.z.object({
+var bucketEntryOccurrencePathParams = import_zod56.z.object({
   bucketId: BasecampIdParamSchema,
   scheduleEntryId: BasecampIdParamSchema,
-  occurrenceDate: import_zod55.z.string()
+  occurrenceDate: import_zod56.z.string()
 });
 var scheduleEntriesRouter = c.router({
   list: {
@@ -2780,19 +2829,19 @@ var scheduleEntriesRouter = c.router({
 });
 
 // src/contract/resources/scheduling/questionnaires.ts
-var import_zod57 = require("zod");
+var import_zod58 = require("zod");
 
 // src/contract/schemas/scheduling/questionnaires.ts
-var import_zod56 = require("zod");
+var import_zod57 = require("zod");
 var QuestionnaireSchema = RecordingBaseSchema.extend({
-  type: import_zod56.z.literal("Questionnaire"),
-  name: import_zod56.z.string(),
-  questions_count: import_zod56.z.number().int(),
-  questions_url: import_zod56.z.string().url()
+  type: import_zod57.z.literal("Questionnaire"),
+  name: import_zod57.z.string(),
+  questions_count: import_zod57.z.number().int(),
+  questions_url: import_zod57.z.string().url()
 });
 
 // src/contract/resources/scheduling/questionnaires.ts
-var bucketAndQuestionnairePathParams = import_zod57.z.object({
+var bucketAndQuestionnairePathParams = import_zod58.z.object({
   bucketId: BasecampIdParamSchema,
   questionnaireId: BasecampIdParamSchema
 });
@@ -2815,39 +2864,39 @@ var questionnairesRouter = c.router({
 });
 
 // src/contract/resources/scheduling/questions.ts
-var import_zod59 = require("zod");
+var import_zod60 = require("zod");
 
 // src/contract/schemas/scheduling/questions.ts
-var import_zod58 = require("zod");
-var QuestionScheduleSchema = import_zod58.z.object({
-  frequency: import_zod58.z.string(),
-  days: import_zod58.z.array(import_zod58.z.number().int()),
-  hour: import_zod58.z.number().int(),
-  minute: import_zod58.z.number().int(),
-  week_instance: import_zod58.z.number().int().nullable(),
-  week_interval: import_zod58.z.number().int().nullable(),
-  month_interval: import_zod58.z.number().int().nullable(),
-  start_date: import_zod58.z.string(),
-  end_date: import_zod58.z.string().nullable()
+var import_zod59 = require("zod");
+var QuestionScheduleSchema = import_zod59.z.object({
+  frequency: import_zod59.z.string(),
+  days: import_zod59.z.array(import_zod59.z.number().int()),
+  hour: import_zod59.z.number().int(),
+  minute: import_zod59.z.number().int(),
+  week_instance: import_zod59.z.number().int().nullable(),
+  week_interval: import_zod59.z.number().int().nullable(),
+  month_interval: import_zod59.z.number().int().nullable(),
+  start_date: import_zod59.z.string(),
+  end_date: import_zod59.z.string().nullable()
 });
 var QuestionSchema = RecordingBaseSchema.extend({
-  type: import_zod58.z.literal("Question"),
-  paused: import_zod58.z.boolean(),
+  type: import_zod59.z.literal("Question"),
+  paused: import_zod59.z.boolean(),
   schedule: QuestionScheduleSchema,
-  answers_count: import_zod58.z.number().int(),
-  answers_url: import_zod58.z.string().url()
+  answers_count: import_zod59.z.number().int(),
+  answers_url: import_zod59.z.string().url()
 });
-var QuestionListResponseSchema = import_zod58.z.array(QuestionSchema);
-var QuestionListQuerySchema = import_zod58.z.object({
-  page: import_zod58.z.coerce.number().int().positive().optional()
+var QuestionListResponseSchema = import_zod59.z.array(QuestionSchema);
+var QuestionListQuerySchema = import_zod59.z.object({
+  page: import_zod59.z.coerce.number().int().positive().optional()
 });
 
 // src/contract/resources/scheduling/questions.ts
-var bucketAndQuestionnairePathParams2 = import_zod59.z.object({
+var bucketAndQuestionnairePathParams2 = import_zod60.z.object({
   bucketId: BasecampIdParamSchema,
   questionnaireId: BasecampIdParamSchema
 });
-var bucketAndQuestionPathParams = import_zod59.z.object({
+var bucketAndQuestionPathParams = import_zod60.z.object({
   bucketId: BasecampIdParamSchema,
   questionId: BasecampIdParamSchema
 });
@@ -2885,26 +2934,104 @@ var questionsRouter = c.router({
   }
 });
 
-// src/contract/resources/tasks/todosets.ts
+// src/contract/resources/scheduling/question-answers.ts
+var import_zod62 = require("zod");
+
+// src/contract/schemas/scheduling/question-answers.ts
 var import_zod61 = require("zod");
+var QuestionAnswerSchema = RecordingBaseSchema.extend({
+  type: import_zod61.z.literal("Question::Answer"),
+  content: HtmlStringSchema,
+  group_on: import_zod61.z.string()
+});
+var QuestionAnswerListResponseSchema = import_zod61.z.array(QuestionAnswerSchema);
+var QuestionAnswerListQuerySchema = import_zod61.z.object({
+  page: import_zod61.z.coerce.number().int().positive().optional()
+});
+var QuestionAnswerCreateBodySchema = import_zod61.z.object({
+  content: HtmlStringSchema.min(1),
+  group_on: import_zod61.z.string()
+});
+
+// src/contract/resources/scheduling/question-answers.ts
+var bucketAndQuestionPathParams2 = import_zod62.z.object({
+  bucketId: BasecampIdParamSchema,
+  questionId: BasecampIdParamSchema
+});
+var bucketAndAnswerPathParams = import_zod62.z.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
+var import_zod64 = require("zod");
 
 // src/contract/schemas/tasks/todosets.ts
-var import_zod60 = require("zod");
+var import_zod63 = require("zod");
 var TodoSetSchema = RecordingBaseSchema.omit({
   subscription_url: true,
   comments_count: true,
   comments_url: true
 }).extend({
-  completed: import_zod60.z.boolean(),
-  completed_ratio: import_zod60.z.string(),
-  name: import_zod60.z.string(),
-  todolists_count: import_zod60.z.number().int().nonnegative(),
-  todolists_url: import_zod60.z.string().url(),
-  app_todoslists_url: import_zod60.z.string().url()
+  completed: import_zod63.z.boolean(),
+  completed_ratio: import_zod63.z.string(),
+  name: import_zod63.z.string(),
+  todolists_count: import_zod63.z.number().int().nonnegative(),
+  todolists_url: import_zod63.z.string().url(),
+  app_todoslists_url: import_zod63.z.string().url()
 });
 
 // src/contract/resources/tasks/todosets.ts
-var bucketPathParams2 = import_zod61.z.object({
+var bucketPathParams2 = import_zod64.z.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndTodoSetPathParams = bucketPathParams2.extend({
@@ -2929,42 +3056,42 @@ var todoSetsRouter = c.router({
 });
 
 // src/contract/resources/tasks/todolists.ts
-var import_zod63 = require("zod");
+var import_zod66 = require("zod");
 
 // src/contract/schemas/tasks/todolists.ts
-var import_zod62 = require("zod");
+var import_zod65 = require("zod");
 var TodoListBaseSchema = RecordingBaseSchema.extend({
-  type: import_zod62.z.literal("Todolist"),
+  type: import_zod65.z.literal("Todolist"),
   description: HtmlStringSchema.optional(),
-  completed: import_zod62.z.boolean(),
-  completed_ratio: import_zod62.z.string(),
-  name: import_zod62.z.string(),
-  todos_url: import_zod62.z.string().url(),
-  app_todos_url: import_zod62.z.string().url()
+  completed: import_zod65.z.boolean(),
+  completed_ratio: import_zod65.z.string(),
+  name: import_zod65.z.string(),
+  todos_url: import_zod65.z.string().url(),
+  app_todos_url: import_zod65.z.string().url()
 });
 var TodoTopLevelListSchema = TodoListBaseSchema.extend({
-  groups_url: import_zod62.z.string().url()
+  groups_url: import_zod65.z.string().url()
 });
 var TodoListGroupSchema = TodoListBaseSchema.extend({
-  group_position_url: import_zod62.z.string().url()
+  group_position_url: import_zod65.z.string().url()
 });
-var TodoListSchema = import_zod62.z.union([TodoTopLevelListSchema, TodoListGroupSchema]);
-var TodoListsResponseSchema = import_zod62.z.array(TodoTopLevelListSchema);
-var TodoListQuerySchema = import_zod62.z.object({
-  status: import_zod62.z.enum(["active", "archived", "trashed"]).or(import_zod62.z.string()).optional(),
-  page: import_zod62.z.coerce.number().int().positive().optional()
+var TodoListSchema = import_zod65.z.union([TodoTopLevelListSchema, TodoListGroupSchema]);
+var TodoListsResponseSchema = import_zod65.z.array(TodoTopLevelListSchema);
+var TodoListQuerySchema = import_zod65.z.object({
+  status: import_zod65.z.enum(["active", "archived", "trashed"]).or(import_zod65.z.string()).optional(),
+  page: import_zod65.z.coerce.number().int().positive().optional()
 });
-var TodoListCreateBodySchema = import_zod62.z.object({
-  name: import_zod62.z.string().min(1),
+var TodoListCreateBodySchema = import_zod65.z.object({
+  name: import_zod65.z.string().min(1),
   description: HtmlStringSchema.nullable().optional()
 });
-var TodoListUpdateBodySchema = import_zod62.z.object({
-  name: import_zod62.z.string().min(1),
+var TodoListUpdateBodySchema = import_zod65.z.object({
+  name: import_zod65.z.string().min(1),
   description: HtmlStringSchema.nullable().optional()
 });
 
 // src/contract/resources/tasks/todolists.ts
-var bucketPathParams3 = import_zod63.z.object({
+var bucketPathParams3 = import_zod66.z.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndTodoSetPathParams2 = bucketPathParams3.extend({
@@ -3056,31 +3183,31 @@ var todoListsRouter = c.router({
 });
 
 // src/contract/resources/tasks/todolist-groups.ts
-var import_zod65 = require("zod");
+var import_zod68 = require("zod");
 
 // src/contract/schemas/tasks/todolist-groups.ts
-var import_zod64 = require("zod");
+var import_zod67 = require("zod");
 var TodoListBaseSchema2 = RecordingBaseSchema.extend({
-  type: import_zod64.z.literal("Todolist"),
+  type: import_zod67.z.literal("Todolist"),
   description: HtmlStringSchema.optional(),
-  completed: import_zod64.z.boolean(),
-  completed_ratio: import_zod64.z.string(),
-  name: import_zod64.z.string(),
-  todos_url: import_zod64.z.string().url(),
-  app_todos_url: import_zod64.z.string().url()
+  completed: import_zod67.z.boolean(),
+  completed_ratio: import_zod67.z.string(),
+  name: import_zod67.z.string(),
+  todos_url: import_zod67.z.string().url(),
+  app_todos_url: import_zod67.z.string().url()
 });
 var TodoListGroupSchema2 = TodoListBaseSchema2.extend({
-  group_position_url: import_zod64.z.string().url()
+  group_position_url: import_zod67.z.string().url()
 });
 var TodoListSchema2 = TodoListGroupSchema2;
-var TodoListGroupsResponseSchema = import_zod64.z.array(TodoListGroupSchema2);
-var TodoListGroupQuerySchema = import_zod64.z.object({
-  status: import_zod64.z.enum(["active", "archived", "trashed"]).or(import_zod64.z.string()).optional(),
-  page: import_zod64.z.coerce.number().int().positive().optional()
-});
-var TodoListGroupCreateBodySchema = import_zod64.z.object({
-  name: import_zod64.z.string().min(1),
-  color: import_zod64.z.enum([
+var TodoListGroupsResponseSchema = import_zod67.z.array(TodoListGroupSchema2);
+var TodoListGroupQuerySchema = import_zod67.z.object({
+  status: import_zod67.z.enum(["active", "archived", "trashed"]).or(import_zod67.z.string()).optional(),
+  page: import_zod67.z.coerce.number().int().positive().optional()
+});
+var TodoListGroupCreateBodySchema = import_zod67.z.object({
+  name: import_zod67.z.string().min(1),
+  color: import_zod67.z.enum([
     "white",
     "red",
     "orange",
@@ -3092,14 +3219,14 @@ var TodoListGroupCreateBodySchema = import_zod64.z.object({
     "gray",
     "pink",
     "brown"
-  ]).or(import_zod64.z.string()).optional()
+  ]).or(import_zod67.z.string()).optional()
 });
-var TodoListGroupRepositionBodySchema = import_zod64.z.object({
-  position: import_zod64.z.number().int().gte(1)
+var TodoListGroupRepositionBodySchema = import_zod67.z.object({
+  position: import_zod67.z.number().int().gte(1)
 });
 
 // src/contract/resources/tasks/todolist-groups.ts
-var bucketPathParams4 = import_zod65.z.object({
+var bucketPathParams4 = import_zod68.z.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndTodoListPathParams2 = bucketPathParams4.extend({
@@ -3160,56 +3287,56 @@ var todoListGroupsRouter = c.router({
 });
 
 // src/contract/resources/tasks/todos.ts
-var import_zod67 = require("zod");
+var import_zod70 = require("zod");
 
 // src/contract/schemas/tasks/todos.ts
-var import_zod66 = require("zod");
-var TodoCompletionSchema = import_zod66.z.object({
+var import_zod69 = require("zod");
+var TodoCompletionSchema = import_zod69.z.object({
   created_at: IsoDateTimeSchema,
   creator: PersonSummarySchema
 });
 var TodoSchema = RecordingBaseSchema.extend({
-  type: import_zod66.z.literal("Todo"),
+  type: import_zod69.z.literal("Todo"),
   description: HtmlStringSchema.optional(),
-  completed: import_zod66.z.boolean(),
+  completed: import_zod69.z.boolean(),
   completion: TodoCompletionSchema.optional(),
-  content: import_zod66.z.string(),
-  starts_on: import_zod66.z.string().date().nullable().optional(),
-  due_on: import_zod66.z.string().date().nullable().optional(),
-  assignees: import_zod66.z.array(PersonSummarySchema),
-  completion_subscribers: import_zod66.z.array(PersonSummarySchema),
-  completion_url: import_zod66.z.string().url()
-});
-var TodoCollectionResponseSchema = import_zod66.z.array(TodoSchema);
-var TodoQuerySchema = import_zod66.z.object({
-  status: import_zod66.z.enum(["active", "archived", "trashed"]).or(import_zod66.z.string()).optional(),
-  completed: import_zod66.z.enum(["true"]).optional(),
-  page: import_zod66.z.coerce.number().int().positive().optional()
-});
-var TodoCreateBodySchema = import_zod66.z.object({
-  content: import_zod66.z.string().min(1),
+  content: import_zod69.z.string(),
+  starts_on: import_zod69.z.string().date().nullable().optional(),
+  due_on: import_zod69.z.string().date().nullable().optional(),
+  assignees: import_zod69.z.array(PersonSummarySchema),
+  completion_subscribers: import_zod69.z.array(PersonSummarySchema),
+  completion_url: import_zod69.z.string().url()
+});
+var TodoCollectionResponseSchema = import_zod69.z.array(TodoSchema);
+var TodoQuerySchema = import_zod69.z.object({
+  status: import_zod69.z.enum(["active", "archived", "trashed"]).or(import_zod69.z.string()).optional(),
+  completed: import_zod69.z.literal(true).optional(),
+  page: import_zod69.z.coerce.number().int().positive().optional()
+});
+var TodoCreateBodySchema = import_zod69.z.object({
+  content: import_zod69.z.string().min(1),
   description: HtmlStringSchema.nullable().optional(),
-  assignee_ids: import_zod66.z.array(BasecampIdSchema).optional(),
-  completion_subscriber_ids: import_zod66.z.array(BasecampIdSchema).optional(),
-  notify: import_zod66.z.boolean().optional(),
-  due_on: import_zod66.z.string().date().nullable().optional(),
-  starts_on: import_zod66.z.string().date().nullable().optional()
-});
-var TodoUpdateBodySchema = import_zod66.z.object({
-  content: import_zod66.z.string().min(1),
+  assignee_ids: import_zod69.z.array(BasecampIdSchema).optional(),
+  completion_subscriber_ids: import_zod69.z.array(BasecampIdSchema).optional(),
+  notify: import_zod69.z.boolean().optional(),
+  due_on: import_zod69.z.string().date().nullable().optional(),
+  starts_on: import_zod69.z.string().date().nullable().optional()
+});
+var TodoUpdateBodySchema = import_zod69.z.object({
+  content: import_zod69.z.string().min(1),
   description: HtmlStringSchema.nullable().optional(),
-  assignee_ids: import_zod66.z.array(BasecampIdSchema).optional(),
-  completion_subscriber_ids: import_zod66.z.array(BasecampIdSchema).optional(),
-  notify: import_zod66.z.boolean().optional(),
-  due_on: import_zod66.z.string().date().nullable().optional(),
-  starts_on: import_zod66.z.string().date().nullable().optional()
+  assignee_ids: import_zod69.z.array(BasecampIdSchema).optional(),
+  completion_subscriber_ids: import_zod69.z.array(BasecampIdSchema).optional(),
+  notify: import_zod69.z.boolean().optional(),
+  due_on: import_zod69.z.string().date().nullable().optional(),
+  starts_on: import_zod69.z.string().date().nullable().optional()
 });
-var TodoRepositionBodySchema = import_zod66.z.object({
-  position: import_zod66.z.number().int().gte(1)
+var TodoRepositionBodySchema = import_zod69.z.object({
+  position: import_zod69.z.number().int().gte(1)
 });
 
 // src/contract/resources/tasks/todos.ts
-var bucketPathParams5 = import_zod67.z.object({
+var bucketPathParams5 = import_zod70.z.object({
   bucketId: BasecampIdParamSchema
 });
 var bucketAndTodoListPathParams3 = bucketPathParams5.extend({
@@ -3380,17 +3507,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: import_zod68.z.object({
-      Authorization: import_zod68.z.string().min(1),
-      "User-Agent": import_zod68.z.string().min(1).optional(),
-      Accept: import_zod68.z.literal("application/json").optional()
+    baseHeaders: import_zod71.z.object({
+      Authorization: import_zod71.z.string().min(1),
+      "User-Agent": import_zod71.z.string().min(1).optional(),
+      Accept: import_zod71.z.literal("application/json").optional()
     })
   }
 );
@@ -3427,15 +3556,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 (0, import_core2.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 (0, import_core2.tsRestFetchApi)({
+        ...args,
+        path: pathWithSuffix,
+        headers
+      });
+    }
     if (response.status !== 429) {
       return response;
     }