@doist/todoist-sdk 9.6.0 → 9.7.0

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,8 +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/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/types.js

@@ -1,34 +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,
-    ...projects_1.PROJECT_WEBHOOK_EVENTS,
-    ...sections_1.SECTION_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 (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.
  *
@@ -36,12 +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; `project:*` events carry a parsed {@link Project}
- * (personal or workspace); `section:*` events carry a parsed
- * {@link WebhookSection}. Other events still expose `eventData` as
- * `unknown`; they will be narrowed in follow-up PRs (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,
@@ -65,5 +48,8 @@ exports.WebhookPayloadSchema = zod_1.z.discriminatedUnion('eventName', [
     sections_1.SectionDeletedPayloadSchema,
     sections_1.SectionArchivedPayloadSchema,
     sections_1.SectionUnarchivedPayloadSchema,
-    exports.UntypedWebhookPayloadSchema,
+    filters_1.FilterAddedPayloadSchema,
+    filters_1.FilterUpdatedPayloadSchema,
+    filters_1.FilterDeletedPayloadSchema,
+    reminders_1.ReminderFiredPayloadSchema,
 ]);

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,7 +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/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/types.js

@@ -1,30 +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 { PROJECT_WEBHOOK_EVENTS, ProjectAddedPayloadSchema, ProjectArchivedPayloadSchema, ProjectDeletedPayloadSchema, ProjectUnarchivedPayloadSchema, ProjectUpdatedPayloadSchema, } from './projects.js';
-import { SECTION_WEBHOOK_EVENTS, SectionAddedPayloadSchema, SectionArchivedPayloadSchema, SectionDeletedPayloadSchema, SectionUnarchivedPayloadSchema, SectionUpdatedPayloadSchema, } from './sections.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,
-    ...PROJECT_WEBHOOK_EVENTS,
-    ...SECTION_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 (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.
  *
@@ -32,12 +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; `project:*` events carry a parsed {@link Project}
- * (personal or workspace); `section:*` events carry a parsed
- * {@link WebhookSection}. Other events still expose `eventData` as
- * `unknown`; they will be narrowed in follow-up PRs (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,
@@ -61,6 +44,9 @@ export const WebhookPayloadSchema = z.discriminatedUnion('eventName', [
     SectionDeletedPayloadSchema,
     SectionArchivedPayloadSchema,
     SectionUnarchivedPayloadSchema,
-    UntypedWebhookPayloadSchema,
+    FilterAddedPayloadSchema,
+    FilterUpdatedPayloadSchema,
+    FilterDeletedPayloadSchema,
+    ReminderFiredPayloadSchema,
 ]);
 export { WebhookEventSchema };

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,7 +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/types/types/webhooks/reminders.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+/**
+ * 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 declare const ReminderWebhookEventEnum: {
+    readonly Fired: "reminder:fired";
+};
+/** Webhook events that carry a fired-reminder as their `eventData`. */
+export declare const REMINDER_WEBHOOK_EVENTS: readonly ["reminder: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 declare const WebhookFiredReminderSchema: z.ZodObject<{
+    id: z.ZodString;
+    notifyUid: z.ZodString;
+    itemId: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    isDeleted: z.ZodBoolean;
+    type: z.ZodEnum<{
+        relative: "relative";
+        absolute: "absolute";
+        location: "location";
+    }>;
+    isUrgent: z.ZodBoolean;
+    minuteOffset: z.ZodNullable<z.ZodNumber>;
+    due: z.ZodNullable<z.ZodObject<{
+        isRecurring: z.ZodBoolean;
+        string: z.ZodString;
+        date: z.ZodString;
+        datetime: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        lang: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+/** A fired-reminder notification delivered in a webhook payload. */
+export type WebhookFiredReminder = z.infer<typeof WebhookFiredReminderSchema>;
+export declare const ReminderFiredPayloadSchema: z.ZodObject<{
+    eventName: z.ZodLiteral<"reminder:fired">;
+    eventData: z.ZodObject<{
+        id: z.ZodString;
+        notifyUid: z.ZodString;
+        itemId: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        isDeleted: z.ZodBoolean;
+        type: z.ZodEnum<{
+            relative: "relative";
+            absolute: "absolute";
+            location: "location";
+        }>;
+        isUrgent: z.ZodBoolean;
+        minuteOffset: z.ZodNullable<z.ZodNumber>;
+        due: z.ZodNullable<z.ZodObject<{
+            isRecurring: z.ZodBoolean;
+            string: z.ZodString;
+            date: z.ZodString;
+            datetime: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            lang: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, 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 ReminderFiredPayload = z.infer<typeof ReminderFiredPayloadSchema>;

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

@@ -1,32 +1,5 @@
 import { z } from 'zod';
 import { WebhookEventSchema, type WebhookEvent } from '../apps/types.js';
-/**
- * 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 (filters, reminders).
- */
-export declare const UntypedWebhookPayloadSchema: z.ZodObject<{
-    eventName: z.ZodEnum<{
-        "filter:added": "filter:added";
-        "filter:updated": "filter:updated";
-        "filter:deleted": "filter:deleted";
-        "reminder:fired": "reminder:fired";
-    }>;
-    eventData: z.ZodUnknown;
-    eventDataExtra: z.ZodOptional<z.ZodUnknown>;
-    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>;
 /**
  * Wrapper schema for an incoming webhook payload.
  *
@@ -34,12 +7,13 @@ export declare const UntypedWebhookPayloadSchema: z.ZodObject<{
  * (`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; `project:*` events carry a parsed {@link Project}
- * (personal or workspace); `section:*` events carry a parsed
- * {@link WebhookSection}. Other events still expose `eventData` as
- * `unknown`; they will be narrowed in follow-up PRs (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 declare const WebhookPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     eventName: z.ZodLiteral<"item:added">;
@@ -2462,14 +2436,101 @@ export declare const WebhookPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     }, z.core.$strip>;
     triggeredAt: z.ZodCoercedDate<unknown>;
 }, z.core.$strip>, z.ZodObject<{
-    eventName: z.ZodEnum<{
-        "filter:added": "filter:added";
-        "filter:updated": "filter:updated";
-        "filter:deleted": "filter:deleted";
-        "reminder:fired": "reminder:fired";
+    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>, 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";
     }>;
-    eventData: z.ZodUnknown;
-    eventDataExtra: z.ZodOptional<z.ZodUnknown>;
+    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>, 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>, z.ZodObject<{
+    eventName: z.ZodLiteral<"reminder:fired">;
+    eventData: z.ZodObject<{
+        id: z.ZodString;
+        notifyUid: z.ZodString;
+        itemId: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        isDeleted: z.ZodBoolean;
+        type: z.ZodEnum<{
+            relative: "relative";
+            absolute: "absolute";
+            location: "location";
+        }>;
+        isUrgent: z.ZodBoolean;
+        minuteOffset: z.ZodNullable<z.ZodNumber>;
+        due: z.ZodNullable<z.ZodObject<{
+            isRecurring: z.ZodBoolean;
+            string: z.ZodString;
+            date: z.ZodString;
+            datetime: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            lang: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>;
     version: z.ZodEnum<{
         1: "1";
     }>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-sdk",
-    "version": "9.6.0",
+    "version": "9.7.0",
     "description": "The official TypeScript SDK for the Todoist REST API.",
     "author": "Doist developers",
     "repository": "https://github.com/Doist/todoist-sdk-typescript",