@doist/todoist-sdk 9.5.0 → 9.7.0

package/dist/cjs/types/sections/types.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SectionSchema = void 0;
+exports.SectionSchema = exports.SectionBaseSchema = void 0;
 const zod_1 = require("zod");
 const url_helpers_1 = require("../../utils/url-helpers");
-exports.SectionSchema = zod_1.z
-    .object({
+/**
+ * Raw section fields (the persisted shape). Exposed so schemas that extend
+ * or override a field — notably the webhook variant — can reuse the base
+ * without duplicating every field.
+ */
+exports.SectionBaseSchema = zod_1.z.object({
     id: zod_1.z.string(),
     userId: zod_1.z.string(),
     projectId: zod_1.z.string(),
@@ -16,7 +20,5 @@ exports.SectionSchema = zod_1.z
     isArchived: zod_1.z.boolean(),
     isDeleted: zod_1.z.boolean(),
     isCollapsed: zod_1.z.boolean(),
-})
-    .transform((data) => {
-    return Object.assign(Object.assign({}, data), { url: (0, url_helpers_1.getSectionUrl)(data.id, data.name) });
 });
+exports.SectionSchema = exports.SectionBaseSchema.transform((data) => (Object.assign(Object.assign({}, data), { url: (0, url_helpers_1.getSectionUrl)(data.id, data.name) })));

package/dist/cjs/types/webhooks/filters.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterDeletedPayloadSchema = exports.FilterUpdatedPayloadSchema = exports.FilterAddedPayloadSchema = exports.FILTER_WEBHOOK_EVENTS = exports.FilterWebhookEventEnum = void 0;
+const zod_1 = require("zod");
+const filters_1 = require("../sync/resources/filters");
+const envelope_1 = require("./envelope");
+/**
+ * Enum-like object of filter (`filter:*`) webhook event names. Single
+ * source of truth for the discriminator values — `FILTER_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+exports.FilterWebhookEventEnum = {
+    Added: 'filter:added',
+    Updated: 'filter:updated',
+    Deleted: 'filter:deleted',
+};
+/** Webhook events that carry a filter as their `eventData`. */
+exports.FILTER_WEBHOOK_EVENTS = [
+    exports.FilterWebhookEventEnum.Added,
+    exports.FilterWebhookEventEnum.Updated,
+    exports.FilterWebhookEventEnum.Deleted,
+];
+/**
+ * Webhook filter payloads match the shared {@link Filter} resource shape,
+ * so `eventData` reuses `FilterSchema` directly — no webhook-specific
+ * schema is needed.
+ */
+exports.FilterAddedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.FilterWebhookEventEnum.Added), eventData: filters_1.FilterSchema }));
+exports.FilterUpdatedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.FilterWebhookEventEnum.Updated), eventData: filters_1.FilterSchema }));
+exports.FilterDeletedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.FilterWebhookEventEnum.Deleted), eventData: filters_1.FilterSchema }));

package/dist/cjs/types/webhooks/index.js

@@ -16,6 +16,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./comments"), exports);
 __exportStar(require("./envelope"), exports);
+__exportStar(require("./filters"), exports);
 __exportStar(require("./labels"), exports);
+__exportStar(require("./projects"), exports);
+__exportStar(require("./reminders"), exports);
+__exportStar(require("./sections"), exports);
 __exportStar(require("./tasks"), exports);
 __exportStar(require("./types"), exports);

package/dist/cjs/types/webhooks/projects.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectUnarchivedPayloadSchema = exports.ProjectArchivedPayloadSchema = exports.ProjectDeletedPayloadSchema = exports.ProjectUpdatedPayloadSchema = exports.ProjectAddedPayloadSchema = exports.PROJECT_WEBHOOK_EVENTS = exports.ProjectWebhookEventEnum = void 0;
+const zod_1 = require("zod");
+const types_1 = require("../projects/types");
+const envelope_1 = require("./envelope");
+/**
+ * Enum-like object of project (`project:*`) webhook event names. Single
+ * source of truth for the discriminator values — `PROJECT_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+exports.ProjectWebhookEventEnum = {
+    Added: 'project:added',
+    Updated: 'project:updated',
+    Deleted: 'project:deleted',
+    Archived: 'project:archived',
+    Unarchived: 'project:unarchived',
+};
+/** Webhook events that carry a project as their `eventData`. */
+exports.PROJECT_WEBHOOK_EVENTS = [
+    exports.ProjectWebhookEventEnum.Added,
+    exports.ProjectWebhookEventEnum.Updated,
+    exports.ProjectWebhookEventEnum.Deleted,
+    exports.ProjectWebhookEventEnum.Archived,
+    exports.ProjectWebhookEventEnum.Unarchived,
+];
+/**
+ * Webhook project payloads match the shape of the shared {@link Project}
+ * resource — either a personal or a workspace project. No webhook-specific
+ * schema is needed; `ProjectSchema` already dispatches on `workspaceId`.
+ */
+exports.ProjectAddedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.ProjectWebhookEventEnum.Added), eventData: types_1.ProjectSchema }));
+exports.ProjectUpdatedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.ProjectWebhookEventEnum.Updated), eventData: types_1.ProjectSchema }));
+exports.ProjectDeletedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.ProjectWebhookEventEnum.Deleted), eventData: types_1.ProjectSchema }));
+exports.ProjectArchivedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.ProjectWebhookEventEnum.Archived), eventData: types_1.ProjectSchema }));
+exports.ProjectUnarchivedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.ProjectWebhookEventEnum.Unarchived), eventData: types_1.ProjectSchema }));

package/dist/cjs/types/webhooks/reminders.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReminderFiredPayloadSchema = exports.WebhookFiredReminderSchema = exports.REMINDER_WEBHOOK_EVENTS = exports.ReminderWebhookEventEnum = void 0;
+const zod_1 = require("zod");
+const reminders_1 = require("../sync/resources/reminders");
+const types_1 = require("../tasks/types");
+const envelope_1 = require("./envelope");
+/**
+ * Enum-like object of reminder (`reminder:*`) webhook event names. Single
+ * source of truth for the discriminator values — `REMINDER_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+exports.ReminderWebhookEventEnum = {
+    Fired: 'reminder:fired',
+};
+/** Webhook events that carry a fired-reminder as their `eventData`. */
+exports.REMINDER_WEBHOOK_EVENTS = [
+    exports.ReminderWebhookEventEnum.Fired,
+];
+/**
+ * A fired-reminder notification as delivered in a webhook payload.
+ *
+ * `reminder:fired` carries a subset of the full Reminder record (closer
+ * to a fired-notification projection), so it doesn't line up with any of
+ * the {@link Reminder} discriminated variants directly. This schema
+ * reuses {@link ReminderBaseSchema} for the common identity fields and
+ * adds the fields always present on a fired notification.
+ */
+exports.WebhookFiredReminderSchema = reminders_1.ReminderBaseSchema.extend({
+    type: zod_1.z.enum(reminders_1.REMINDER_TYPES),
+    isUrgent: zod_1.z.boolean(),
+    minuteOffset: zod_1.z.number().int().nullable(),
+    due: types_1.DueDateSchema.nullable(),
+});
+exports.ReminderFiredPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.ReminderWebhookEventEnum.Fired), eventData: exports.WebhookFiredReminderSchema }));

package/dist/cjs/types/webhooks/sections.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SectionUnarchivedPayloadSchema = exports.SectionArchivedPayloadSchema = exports.SectionDeletedPayloadSchema = exports.SectionUpdatedPayloadSchema = exports.SectionAddedPayloadSchema = exports.WebhookSectionSchema = exports.SECTION_WEBHOOK_EVENTS = exports.SectionWebhookEventEnum = void 0;
+const zod_1 = require("zod");
+const url_helpers_1 = require("../../utils/url-helpers");
+const types_1 = require("../sections/types");
+const envelope_1 = require("./envelope");
+/**
+ * Enum-like object of section (`section:*`) webhook event names. Single
+ * source of truth for the discriminator values — `SECTION_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+exports.SectionWebhookEventEnum = {
+    Added: 'section:added',
+    Updated: 'section:updated',
+    Deleted: 'section:deleted',
+    Archived: 'section:archived',
+    Unarchived: 'section:unarchived',
+};
+/** Webhook events that carry a section as their `eventData`. */
+exports.SECTION_WEBHOOK_EVENTS = [
+    exports.SectionWebhookEventEnum.Added,
+    exports.SectionWebhookEventEnum.Updated,
+    exports.SectionWebhookEventEnum.Deleted,
+    exports.SectionWebhookEventEnum.Archived,
+    exports.SectionWebhookEventEnum.Unarchived,
+];
+/**
+ * A section as delivered in a webhook payload.
+ *
+ * Reuses {@link SectionBaseSchema} and overrides `updatedAt` to tolerate
+ * payloads that deliver it as `null` or omit the key entirely — tombstones
+ * and never-updated sections come through without an `updated_at` value.
+ * The result is normalised to `Date | null` so consumers don't have to
+ * handle three shapes. Surfaces the computed `url` so the exposed shape
+ * matches {@link Section}.
+ */
+exports.WebhookSectionSchema = types_1.SectionBaseSchema.extend({
+    updatedAt: zod_1.z.coerce
+        .date()
+        .nullish()
+        .transform((value) => value !== null && value !== void 0 ? value : null),
+}).transform((data) => (Object.assign(Object.assign({}, data), { url: (0, url_helpers_1.getSectionUrl)(data.id, data.name) })));
+exports.SectionAddedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.SectionWebhookEventEnum.Added), eventData: exports.WebhookSectionSchema }));
+exports.SectionUpdatedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.SectionWebhookEventEnum.Updated), eventData: exports.WebhookSectionSchema }));
+exports.SectionDeletedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.SectionWebhookEventEnum.Deleted), eventData: exports.WebhookSectionSchema }));
+exports.SectionArchivedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.SectionWebhookEventEnum.Archived), eventData: exports.WebhookSectionSchema }));
+exports.SectionUnarchivedPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.literal(exports.SectionWebhookEventEnum.Unarchived), eventData: exports.WebhookSectionSchema }));

package/dist/cjs/types/webhooks/types.js

@@ -1,30 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebhookEventSchema = exports.WebhookPayloadSchema = exports.UntypedWebhookPayloadSchema = void 0;
+exports.WebhookEventSchema = exports.WebhookPayloadSchema = void 0;
 const zod_1 = require("zod");
 const types_1 = require("../apps/types");
 Object.defineProperty(exports, "WebhookEventSchema", { enumerable: true, get: function () { return types_1.WebhookEventSchema; } });
 const comments_1 = require("./comments");
-const envelope_1 = require("./envelope");
+const filters_1 = require("./filters");
 const labels_1 = require("./labels");
+const projects_1 = require("./projects");
+const reminders_1 = require("./reminders");
+const sections_1 = require("./sections");
 const tasks_1 = require("./tasks");
-/**
- * Events whose payloads have been narrowed per resource. Each phase adds to
- * this list; {@link UntypedWebhookPayloadSchema} below is derived by taking
- * every {@link WebhookEvent} not present here.
- */
-const TYPED_WEBHOOK_EVENTS = [
-    ...tasks_1.TASK_WEBHOOK_EVENTS,
-    ...comments_1.COMMENT_WEBHOOK_EVENTS,
-    ...labels_1.LABEL_WEBHOOK_EVENTS,
-];
-const untypedEventNames = types_1.WEBHOOK_EVENTS.filter((event) => !TYPED_WEBHOOK_EVENTS.includes(event));
-/**
- * A single branch covering every event whose payload has not yet been typed
- * per resource. Follow-up PRs will replace slices of this with dedicated
- * variants (projects, sections, filters, reminders).
- */
-exports.UntypedWebhookPayloadSchema = zod_1.z.object(Object.assign(Object.assign({}, envelope_1.BaseWebhookEnvelopeShape), { eventName: zod_1.z.enum(untypedEventNames), eventData: zod_1.z.unknown(), eventDataExtra: zod_1.z.unknown().optional() }));
 /**
  * Wrapper schema for an incoming webhook payload.
  *
@@ -32,11 +18,13 @@ exports.UntypedWebhookPayloadSchema = zod_1.z.object(Object.assign(Object.assign
  * (`item:added`) in the `event_name` field, so consumers using
  * `parseWebhookPayload` receive camelCase fields directly.
  *
- * Typed today: `item:*` events carry a parsed {@link Task}; `note:*` events
- * carry a parsed comment (item-comment or project-comment); `label:*` events
- * carry a parsed label. Other events still expose `eventData` as `unknown`;
- * they will be narrowed in follow-up PRs (projects, sections, filters,
- * reminders).
+ * Every {@link WebhookEvent} is typed today: `item:*` events carry a parsed
+ * {@link Task}; `note:*` events carry a parsed comment (item-comment or
+ * project-comment); `label:*` events carry a parsed label; `project:*`
+ * events carry a parsed {@link Project} (personal or workspace);
+ * `section:*` events carry a parsed {@link WebhookSection}; `filter:*`
+ * events carry a parsed {@link Filter}; `reminder:fired` carries a parsed
+ * {@link WebhookFiredReminder}.
  */
 exports.WebhookPayloadSchema = zod_1.z.discriminatedUnion('eventName', [
     tasks_1.TaskAddedPayloadSchema,
@@ -50,5 +38,18 @@ exports.WebhookPayloadSchema = zod_1.z.discriminatedUnion('eventName', [
     labels_1.LabelAddedPayloadSchema,
     labels_1.LabelUpdatedPayloadSchema,
     labels_1.LabelDeletedPayloadSchema,
-    exports.UntypedWebhookPayloadSchema,
+    projects_1.ProjectAddedPayloadSchema,
+    projects_1.ProjectUpdatedPayloadSchema,
+    projects_1.ProjectDeletedPayloadSchema,
+    projects_1.ProjectArchivedPayloadSchema,
+    projects_1.ProjectUnarchivedPayloadSchema,
+    sections_1.SectionAddedPayloadSchema,
+    sections_1.SectionUpdatedPayloadSchema,
+    sections_1.SectionDeletedPayloadSchema,
+    sections_1.SectionArchivedPayloadSchema,
+    sections_1.SectionUnarchivedPayloadSchema,
+    filters_1.FilterAddedPayloadSchema,
+    filters_1.FilterUpdatedPayloadSchema,
+    filters_1.FilterDeletedPayloadSchema,
+    reminders_1.ReminderFiredPayloadSchema,
 ]);

package/dist/esm/types/sections/types.js

@@ -1,7 +1,11 @@
 import { z } from 'zod';
 import { getSectionUrl } from '../../utils/url-helpers.js';
-export const SectionSchema = z
-    .object({
+/**
+ * Raw section fields (the persisted shape). Exposed so schemas that extend
+ * or override a field — notably the webhook variant — can reuse the base
+ * without duplicating every field.
+ */
+export const SectionBaseSchema = z.object({
     id: z.string(),
     userId: z.string(),
     projectId: z.string(),
@@ -13,7 +17,5 @@ export const SectionSchema = z
     isArchived: z.boolean(),
     isDeleted: z.boolean(),
     isCollapsed: z.boolean(),
-})
-    .transform((data) => {
-    return Object.assign(Object.assign({}, data), { url: getSectionUrl(data.id, data.name) });
 });
+export const SectionSchema = SectionBaseSchema.transform((data) => (Object.assign(Object.assign({}, data), { url: getSectionUrl(data.id, data.name) })));

package/dist/esm/types/webhooks/filters.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { FilterSchema } from '../sync/resources/filters.js';
+import { BaseWebhookEnvelopeShape } from './envelope.js';
+/**
+ * Enum-like object of filter (`filter:*`) webhook event names. Single
+ * source of truth for the discriminator values — `FILTER_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+export const FilterWebhookEventEnum = {
+    Added: 'filter:added',
+    Updated: 'filter:updated',
+    Deleted: 'filter:deleted',
+};
+/** Webhook events that carry a filter as their `eventData`. */
+export const FILTER_WEBHOOK_EVENTS = [
+    FilterWebhookEventEnum.Added,
+    FilterWebhookEventEnum.Updated,
+    FilterWebhookEventEnum.Deleted,
+];
+/**
+ * Webhook filter payloads match the shared {@link Filter} resource shape,
+ * so `eventData` reuses `FilterSchema` directly — no webhook-specific
+ * schema is needed.
+ */
+export const FilterAddedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(FilterWebhookEventEnum.Added), eventData: FilterSchema }));
+export const FilterUpdatedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(FilterWebhookEventEnum.Updated), eventData: FilterSchema }));
+export const FilterDeletedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(FilterWebhookEventEnum.Deleted), eventData: FilterSchema }));

package/dist/esm/types/webhooks/index.js

@@ -1,5 +1,9 @@
 export * from './comments.js';
 export * from './envelope.js';
+export * from './filters.js';
 export * from './labels.js';
+export * from './projects.js';
+export * from './reminders.js';
+export * from './sections.js';
 export * from './tasks.js';
 export * from './types.js';

package/dist/esm/types/webhooks/projects.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ProjectSchema } from '../projects/types.js';
+import { BaseWebhookEnvelopeShape } from './envelope.js';
+/**
+ * Enum-like object of project (`project:*`) webhook event names. Single
+ * source of truth for the discriminator values — `PROJECT_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+export const ProjectWebhookEventEnum = {
+    Added: 'project:added',
+    Updated: 'project:updated',
+    Deleted: 'project:deleted',
+    Archived: 'project:archived',
+    Unarchived: 'project:unarchived',
+};
+/** Webhook events that carry a project as their `eventData`. */
+export const PROJECT_WEBHOOK_EVENTS = [
+    ProjectWebhookEventEnum.Added,
+    ProjectWebhookEventEnum.Updated,
+    ProjectWebhookEventEnum.Deleted,
+    ProjectWebhookEventEnum.Archived,
+    ProjectWebhookEventEnum.Unarchived,
+];
+/**
+ * Webhook project payloads match the shape of the shared {@link Project}
+ * resource — either a personal or a workspace project. No webhook-specific
+ * schema is needed; `ProjectSchema` already dispatches on `workspaceId`.
+ */
+export const ProjectAddedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(ProjectWebhookEventEnum.Added), eventData: ProjectSchema }));
+export const ProjectUpdatedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(ProjectWebhookEventEnum.Updated), eventData: ProjectSchema }));
+export const ProjectDeletedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(ProjectWebhookEventEnum.Deleted), eventData: ProjectSchema }));
+export const ProjectArchivedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(ProjectWebhookEventEnum.Archived), eventData: ProjectSchema }));
+export const ProjectUnarchivedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(ProjectWebhookEventEnum.Unarchived), eventData: ProjectSchema }));

package/dist/esm/types/webhooks/reminders.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { REMINDER_TYPES, ReminderBaseSchema } from '../sync/resources/reminders.js';
+import { DueDateSchema } from '../tasks/types.js';
+import { BaseWebhookEnvelopeShape } from './envelope.js';
+/**
+ * Enum-like object of reminder (`reminder:*`) webhook event names. Single
+ * source of truth for the discriminator values — `REMINDER_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+export const ReminderWebhookEventEnum = {
+    Fired: 'reminder:fired',
+};
+/** Webhook events that carry a fired-reminder as their `eventData`. */
+export const REMINDER_WEBHOOK_EVENTS = [
+    ReminderWebhookEventEnum.Fired,
+];
+/**
+ * A fired-reminder notification as delivered in a webhook payload.
+ *
+ * `reminder:fired` carries a subset of the full Reminder record (closer
+ * to a fired-notification projection), so it doesn't line up with any of
+ * the {@link Reminder} discriminated variants directly. This schema
+ * reuses {@link ReminderBaseSchema} for the common identity fields and
+ * adds the fields always present on a fired notification.
+ */
+export const WebhookFiredReminderSchema = ReminderBaseSchema.extend({
+    type: z.enum(REMINDER_TYPES),
+    isUrgent: z.boolean(),
+    minuteOffset: z.number().int().nullable(),
+    due: DueDateSchema.nullable(),
+});
+export const ReminderFiredPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(ReminderWebhookEventEnum.Fired), eventData: WebhookFiredReminderSchema }));

package/dist/esm/types/webhooks/sections.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { getSectionUrl } from '../../utils/url-helpers.js';
+import { SectionBaseSchema } from '../sections/types.js';
+import { BaseWebhookEnvelopeShape } from './envelope.js';
+/**
+ * Enum-like object of section (`section:*`) webhook event names. Single
+ * source of truth for the discriminator values — `SECTION_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+export const SectionWebhookEventEnum = {
+    Added: 'section:added',
+    Updated: 'section:updated',
+    Deleted: 'section:deleted',
+    Archived: 'section:archived',
+    Unarchived: 'section:unarchived',
+};
+/** Webhook events that carry a section as their `eventData`. */
+export const SECTION_WEBHOOK_EVENTS = [
+    SectionWebhookEventEnum.Added,
+    SectionWebhookEventEnum.Updated,
+    SectionWebhookEventEnum.Deleted,
+    SectionWebhookEventEnum.Archived,
+    SectionWebhookEventEnum.Unarchived,
+];
+/**
+ * A section as delivered in a webhook payload.
+ *
+ * Reuses {@link SectionBaseSchema} and overrides `updatedAt` to tolerate
+ * payloads that deliver it as `null` or omit the key entirely — tombstones
+ * and never-updated sections come through without an `updated_at` value.
+ * The result is normalised to `Date | null` so consumers don't have to
+ * handle three shapes. Surfaces the computed `url` so the exposed shape
+ * matches {@link Section}.
+ */
+export const WebhookSectionSchema = SectionBaseSchema.extend({
+    updatedAt: z.coerce
+        .date()
+        .nullish()
+        .transform((value) => value !== null && value !== void 0 ? value : null),
+}).transform((data) => (Object.assign(Object.assign({}, data), { url: getSectionUrl(data.id, data.name) })));
+export const SectionAddedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(SectionWebhookEventEnum.Added), eventData: WebhookSectionSchema }));
+export const SectionUpdatedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(SectionWebhookEventEnum.Updated), eventData: WebhookSectionSchema }));
+export const SectionDeletedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(SectionWebhookEventEnum.Deleted), eventData: WebhookSectionSchema }));
+export const SectionArchivedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(SectionWebhookEventEnum.Archived), eventData: WebhookSectionSchema }));
+export const SectionUnarchivedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(SectionWebhookEventEnum.Unarchived), eventData: WebhookSectionSchema }));

package/dist/esm/types/webhooks/types.js

@@ -1,26 +1,12 @@
 import { z } from 'zod';
-import { WEBHOOK_EVENTS, WebhookEventSchema } from '../apps/types.js';
-import { COMMENT_WEBHOOK_EVENTS, CommentAddedPayloadSchema, CommentDeletedPayloadSchema, CommentUpdatedPayloadSchema, } from './comments.js';
-import { BaseWebhookEnvelopeShape } from './envelope.js';
-import { LABEL_WEBHOOK_EVENTS, LabelAddedPayloadSchema, LabelDeletedPayloadSchema, LabelUpdatedPayloadSchema, } from './labels.js';
-import { TASK_WEBHOOK_EVENTS, TaskAddedPayloadSchema, TaskCompletedPayloadSchema, TaskDeletedPayloadSchema, TaskUncompletedPayloadSchema, TaskUpdatedPayloadSchema, } from './tasks.js';
-/**
- * Events whose payloads have been narrowed per resource. Each phase adds to
- * this list; {@link UntypedWebhookPayloadSchema} below is derived by taking
- * every {@link WebhookEvent} not present here.
- */
-const TYPED_WEBHOOK_EVENTS = [
-    ...TASK_WEBHOOK_EVENTS,
-    ...COMMENT_WEBHOOK_EVENTS,
-    ...LABEL_WEBHOOK_EVENTS,
-];
-const untypedEventNames = WEBHOOK_EVENTS.filter((event) => !TYPED_WEBHOOK_EVENTS.includes(event));
-/**
- * A single branch covering every event whose payload has not yet been typed
- * per resource. Follow-up PRs will replace slices of this with dedicated
- * variants (projects, sections, filters, reminders).
- */
-export const UntypedWebhookPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.enum(untypedEventNames), eventData: z.unknown(), eventDataExtra: z.unknown().optional() }));
+import { WebhookEventSchema } from '../apps/types.js';
+import { CommentAddedPayloadSchema, CommentDeletedPayloadSchema, CommentUpdatedPayloadSchema, } from './comments.js';
+import { FilterAddedPayloadSchema, FilterDeletedPayloadSchema, FilterUpdatedPayloadSchema, } from './filters.js';
+import { LabelAddedPayloadSchema, LabelDeletedPayloadSchema, LabelUpdatedPayloadSchema, } from './labels.js';
+import { ProjectAddedPayloadSchema, ProjectArchivedPayloadSchema, ProjectDeletedPayloadSchema, ProjectUnarchivedPayloadSchema, ProjectUpdatedPayloadSchema, } from './projects.js';
+import { ReminderFiredPayloadSchema } from './reminders.js';
+import { SectionAddedPayloadSchema, SectionArchivedPayloadSchema, SectionDeletedPayloadSchema, SectionUnarchivedPayloadSchema, SectionUpdatedPayloadSchema, } from './sections.js';
+import { TaskAddedPayloadSchema, TaskCompletedPayloadSchema, TaskDeletedPayloadSchema, TaskUncompletedPayloadSchema, TaskUpdatedPayloadSchema, } from './tasks.js';
 /**
  * Wrapper schema for an incoming webhook payload.
  *
@@ -28,11 +14,13 @@ export const UntypedWebhookPayloadSchema = z.object(Object.assign(Object.assign(
  * (`item:added`) in the `event_name` field, so consumers using
  * `parseWebhookPayload` receive camelCase fields directly.
  *
- * Typed today: `item:*` events carry a parsed {@link Task}; `note:*` events
- * carry a parsed comment (item-comment or project-comment); `label:*` events
- * carry a parsed label. Other events still expose `eventData` as `unknown`;
- * they will be narrowed in follow-up PRs (projects, sections, filters,
- * reminders).
+ * Every {@link WebhookEvent} is typed today: `item:*` events carry a parsed
+ * {@link Task}; `note:*` events carry a parsed comment (item-comment or
+ * project-comment); `label:*` events carry a parsed label; `project:*`
+ * events carry a parsed {@link Project} (personal or workspace);
+ * `section:*` events carry a parsed {@link WebhookSection}; `filter:*`
+ * events carry a parsed {@link Filter}; `reminder:fired` carries a parsed
+ * {@link WebhookFiredReminder}.
  */
 export const WebhookPayloadSchema = z.discriminatedUnion('eventName', [
     TaskAddedPayloadSchema,
@@ -46,6 +34,19 @@ export const WebhookPayloadSchema = z.discriminatedUnion('eventName', [
     LabelAddedPayloadSchema,
     LabelUpdatedPayloadSchema,
     LabelDeletedPayloadSchema,
-    UntypedWebhookPayloadSchema,
+    ProjectAddedPayloadSchema,
+    ProjectUpdatedPayloadSchema,
+    ProjectDeletedPayloadSchema,
+    ProjectArchivedPayloadSchema,
+    ProjectUnarchivedPayloadSchema,
+    SectionAddedPayloadSchema,
+    SectionUpdatedPayloadSchema,
+    SectionDeletedPayloadSchema,
+    SectionArchivedPayloadSchema,
+    SectionUnarchivedPayloadSchema,
+    FilterAddedPayloadSchema,
+    FilterUpdatedPayloadSchema,
+    FilterDeletedPayloadSchema,
+    ReminderFiredPayloadSchema,
 ]);
 export { WebhookEventSchema };

package/dist/types/types/sections/types.d.ts

@@ -1,4 +1,22 @@
 import { z } from 'zod';
+/**
+ * Raw section fields (the persisted shape). Exposed so schemas that extend
+ * or override a field — notably the webhook variant — can reuse the base
+ * without duplicating every field.
+ */
+export declare const SectionBaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    projectId: z.ZodString;
+    addedAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+    archivedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    name: z.ZodString;
+    sectionOrder: z.ZodNumber;
+    isArchived: z.ZodBoolean;
+    isDeleted: z.ZodBoolean;
+    isCollapsed: z.ZodBoolean;
+}, z.core.$strip>;
 export declare const SectionSchema: z.ZodPipe<z.ZodObject<{
     id: z.ZodString;
     userId: z.ZodString;

package/dist/types/types/webhooks/filters.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+/**
+ * Enum-like object of filter (`filter:*`) webhook event names. Single
+ * source of truth for the discriminator values — `FILTER_WEBHOOK_EVENTS`
+ * and every `z.literal()` below derive from it.
+ */
+export declare const FilterWebhookEventEnum: {
+    readonly Added: "filter:added";
+    readonly Updated: "filter:updated";
+    readonly Deleted: "filter:deleted";
+};
+/** Webhook events that carry a filter as their `eventData`. */
+export declare const FILTER_WEBHOOK_EVENTS: readonly ["filter:added", "filter:updated", "filter:deleted"];
+/**
+ * Webhook filter payloads match the shared {@link Filter} resource shape,
+ * so `eventData` reuses `FilterSchema` directly — no webhook-specific
+ * schema is needed.
+ */
+export declare const FilterAddedPayloadSchema: z.ZodObject<{
+    eventName: z.ZodLiteral<"filter:added">;
+    eventData: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        query: z.ZodString;
+        color: z.ZodString;
+        isDeleted: z.ZodBoolean;
+        isFavorite: z.ZodBoolean;
+        isFrozen: z.ZodBoolean;
+        itemOrder: z.ZodNumber;
+    }, z.core.$loose>;
+    version: z.ZodEnum<{
+        1: "1";
+    }>;
+    userId: z.ZodString;
+    initiator: z.ZodObject<{
+        id: z.ZodString;
+        fullName: z.ZodString;
+        email: z.ZodString;
+        imageId: z.ZodNullable<z.ZodString>;
+        isPremium: z.ZodBoolean;
+    }, z.core.$strip>;
+    triggeredAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type FilterAddedPayload = z.infer<typeof FilterAddedPayloadSchema>;
+export declare const FilterUpdatedPayloadSchema: z.ZodObject<{
+    eventName: z.ZodLiteral<"filter:updated">;
+    eventData: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        query: z.ZodString;
+        color: z.ZodString;
+        isDeleted: z.ZodBoolean;
+        isFavorite: z.ZodBoolean;
+        isFrozen: z.ZodBoolean;
+        itemOrder: z.ZodNumber;
+    }, z.core.$loose>;
+    version: z.ZodEnum<{
+        1: "1";
+    }>;
+    userId: z.ZodString;
+    initiator: z.ZodObject<{
+        id: z.ZodString;
+        fullName: z.ZodString;
+        email: z.ZodString;
+        imageId: z.ZodNullable<z.ZodString>;
+        isPremium: z.ZodBoolean;
+    }, z.core.$strip>;
+    triggeredAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type FilterUpdatedPayload = z.infer<typeof FilterUpdatedPayloadSchema>;
+export declare const FilterDeletedPayloadSchema: z.ZodObject<{
+    eventName: z.ZodLiteral<"filter:deleted">;
+    eventData: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        query: z.ZodString;
+        color: z.ZodString;
+        isDeleted: z.ZodBoolean;
+        isFavorite: z.ZodBoolean;
+        isFrozen: z.ZodBoolean;
+        itemOrder: z.ZodNumber;
+    }, z.core.$loose>;
+    version: z.ZodEnum<{
+        1: "1";
+    }>;
+    userId: z.ZodString;
+    initiator: z.ZodObject<{
+        id: z.ZodString;
+        fullName: z.ZodString;
+        email: z.ZodString;
+        imageId: z.ZodNullable<z.ZodString>;
+        isPremium: z.ZodBoolean;
+    }, z.core.$strip>;
+    triggeredAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type FilterDeletedPayload = z.infer<typeof FilterDeletedPayloadSchema>;

package/dist/types/types/webhooks/index.d.ts

@@ -1,5 +1,9 @@
 export * from './comments.js';
 export * from './envelope.js';
+export * from './filters.js';
 export * from './labels.js';
+export * from './projects.js';
+export * from './reminders.js';
+export * from './sections.js';
 export * from './tasks.js';
 export * from './types.js';