@todoist/sdk 0.0.1 → 18.0.0

package/dist/esm/types/ui-extensions/types.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { StringOrNumberSchema } from '../common.js';
+/**
+ * Discriminator values for the UI extension variants.
+ * Exposed as an enum-like object because the values are used in `z.literal()`
+ * across multiple variant schemas (see AGENTS.md "Discriminated unions" exception).
+ */
+export const UiExtensionTypeEnum = {
+    ContextMenu: 'context-menu',
+    Composer: 'composer',
+    Settings: 'settings',
+};
+/**
+ * All UI extension type values.
+ */
+export const UI_EXTENSION_TYPES = [
+    UiExtensionTypeEnum.ContextMenu,
+    UiExtensionTypeEnum.Composer,
+    UiExtensionTypeEnum.Settings,
+];
+/**
+ * Context locations where a context-menu extension can appear.
+ */
+export const CONTEXT_MENU_EXTENSION_CONTEXTS = ['project', 'task'];
+export const ContextMenuExtensionContextSchema = z.enum(CONTEXT_MENU_EXTENSION_CONTEXTS);
+/**
+ * Composer locations where a composer extension can appear.
+ */
+export const COMPOSER_EXTENSION_CONTEXTS = ['task', 'comment'];
+export const ComposerExtensionContextSchema = z.enum(COMPOSER_EXTENSION_CONTEXTS);
+/**
+ * Shared fields across all UI extension variants.
+ */
+export const UiExtensionBaseSchema = z.object({
+    id: StringOrNumberSchema,
+    integrationId: StringOrNumberSchema,
+    extensionId: z.string(),
+    url: z.string(),
+    icon: z.string().nullable(),
+    name: z.string(),
+    description: z.string(),
+    width: z.number().int().nullable(),
+    height: z.number().int().nullable(),
+    defVersion: z.number().int(),
+    minimumCardistVersion: z.string(),
+});
+/**
+ * Schema for a context-menu UI extension.
+ */
+export const ContextMenuExtensionSchema = UiExtensionBaseSchema.extend({
+    extensionType: z.literal(UiExtensionTypeEnum.ContextMenu),
+    contextType: ContextMenuExtensionContextSchema,
+});
+/**
+ * Schema for a composer UI extension.
+ */
+export const ComposerExtensionSchema = UiExtensionBaseSchema.extend({
+    extensionType: z.literal(UiExtensionTypeEnum.Composer),
+    composerType: ComposerExtensionContextSchema,
+});
+/**
+ * Schema for a settings UI extension.
+ */
+export const SettingsExtensionSchema = UiExtensionBaseSchema.extend({
+    extensionType: z.literal(UiExtensionTypeEnum.Settings),
+});
+/**
+ * Discriminated union of all UI extension variants.
+ */
+export const UiExtensionSchema = z.discriminatedUnion('extensionType', [
+    ContextMenuExtensionSchema,
+    ComposerExtensionSchema,
+    SettingsExtensionSchema,
+]);

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

@@ -0,0 +1 @@
+export * from './requests.js';

package/dist/esm/types/uploads/requests.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export * from './types.js';

package/dist/esm/types/users/types.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+export const UserSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string(),
+});
+export const TimezoneInfoSchema = z.object({
+    gmtString: z.string(),
+    hours: z.number().int(),
+    isDst: z.number().int(),
+    minutes: z.number().int(),
+    timezone: z.string(),
+});
+/** Available user premium statuses. */
+export const PREMIUM_STATUSES = [
+    'not_premium',
+    'current_personal_plan',
+    'legacy_personal_plan',
+    'teams_business_member',
+];
+export const CurrentUserSchema = z.object({
+    id: z.string(),
+    email: z.string(),
+    fullName: z.string(),
+    avatarBig: z.string().nullish(),
+    avatarMedium: z.string().nullish(),
+    avatarS640: z.string().nullish(),
+    avatarSmall: z.string().nullish(),
+    businessAccountId: z.string().nullable(),
+    isPremium: z.boolean(),
+    premiumStatus: z.enum(PREMIUM_STATUSES),
+    dateFormat: z.number().int(),
+    timeFormat: z.number().int(),
+    weeklyGoal: z.number().int(),
+    dailyGoal: z.number().int(),
+    completedCount: z.number().int(),
+    completedToday: z.number().int(),
+    karma: z.number(),
+    karmaTrend: z.string(),
+    lang: z.string(),
+    nextWeek: z.number().int(),
+    startDay: z.number().int(),
+    startPage: z.string(),
+    tzInfo: TimezoneInfoSchema,
+    inboxProjectId: z.string(),
+    daysOff: z.array(z.number().int()),
+    weekendStartDay: z.number().int(),
+    websocketUrl: z.string().optional(),
+});

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

@@ -0,0 +1,93 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { z } from 'zod';
+import { AttachmentSchema } from '../comments/types.js';
+import { TaskSchema } from '../tasks/types.js';
+import { BaseWebhookEnvelopeShape } from './envelope.js';
+/**
+ * Enum-like object of comment (`note:*`) webhook event names. Single source
+ * of truth for the discriminator values — `COMMENT_WEBHOOK_EVENTS` and every
+ * `z.literal()` below derive from it.
+ *
+ * The on-the-wire event names remain `note:*` for historical reasons; the
+ * SDK types use `Comment*` to match the rest of the public API where the
+ * resource is named `Comment`.
+ */
+export const CommentWebhookEventEnum = {
+    Added: 'note:added',
+    Updated: 'note:updated',
+    Deleted: 'note:deleted',
+};
+/**
+ * Webhook events that carry a comment as their `eventData`.
+ */
+export const COMMENT_WEBHOOK_EVENTS = [
+    CommentWebhookEventEnum.Added,
+    CommentWebhookEventEnum.Updated,
+    CommentWebhookEventEnum.Deleted,
+];
+/**
+ * Fields common to both item and project comment payloads.
+ *
+ * `postedAt` and `postedUid` are nullable here (unlike
+ * {@link RawCommentSchema}) because webhook payloads may omit them — for
+ * example when the poster could not be resolved, or on a deleted-note
+ * tombstone.
+ */
+const WebhookCommentBaseSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    postedAt: z.coerce.date().nullable(),
+    postedUid: z.string().nullable(),
+    fileAttachment: AttachmentSchema.nullable(),
+    uidsToNotify: z.array(z.string()).nullable(),
+    reactions: z.record(z.string(), z.array(z.string())).nullable(),
+    isDeleted: z.boolean(),
+});
+/**
+ * A comment attached to a task, delivered in a webhook payload.
+ *
+ * Webhook item-comment payloads carry two fields that don't appear on the
+ * REST comment resource: `url` (the direct task URL) and `item` (the full
+ * embedded {@link Task}). Both are parsed here so consumers handling a
+ * `note:added` event also get the task it belongs to.
+ *
+ * `itemId` is exposed as `taskId` to match the rest of the SDK surface.
+ */
+export const WebhookItemCommentSchema = WebhookCommentBaseSchema.extend({
+    itemId: z.string(),
+    url: z.string(),
+    item: TaskSchema,
+})
+    .strict()
+    .transform((_a) => {
+    var { itemId } = _a, rest = __rest(_a, ["itemId"]);
+    return (Object.assign(Object.assign({}, rest), { taskId: itemId }));
+});
+/**
+ * A comment attached to a project, delivered in a webhook payload.
+ *
+ * Project comments do not carry the extra `url` or embedded project fields
+ * that item comments carry for the parent task.
+ */
+export const WebhookProjectCommentSchema = WebhookCommentBaseSchema.extend({
+    projectId: z.string(),
+}).strict();
+/**
+ * The `eventData` of a `note:*` webhook payload — either an item comment
+ * (includes `taskId` and an embedded {@link Task}) or a project comment
+ * (includes `projectId`). Narrow with `'taskId' in eventData`.
+ */
+export const WebhookCommentSchema = z.union([WebhookItemCommentSchema, WebhookProjectCommentSchema]);
+export const CommentAddedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(CommentWebhookEventEnum.Added), eventData: WebhookCommentSchema }));
+export const CommentUpdatedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(CommentWebhookEventEnum.Updated), eventData: WebhookCommentSchema }));
+export const CommentDeletedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(CommentWebhookEventEnum.Deleted), eventData: WebhookCommentSchema }));

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { WebhookVersionSchema } from '../apps/types.js';
+/**
+ * Collaborator info for the user that triggered a webhook event.
+ * @see https://developer.todoist.com/sync/v1/#webhooks
+ */
+export const WebhookInitiatorSchema = z.object({
+    id: z.string(),
+    fullName: z.string(),
+    email: z.string(),
+    imageId: z.string().nullable(),
+    isPremium: z.boolean(),
+});
+/**
+ * Fields common to every webhook payload, regardless of `eventName`.
+ * Meant to be spread into per-event variant schemas.
+ */
+export const BaseWebhookEnvelopeShape = {
+    version: WebhookVersionSchema,
+    userId: z.string(),
+    initiator: WebhookInitiatorSchema,
+    triggeredAt: z.coerce.date(),
+};

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

@@ -0,0 +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/labels.js

@@ -0,0 +1,51 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { z } from 'zod';
+import { LabelSchema } from '../labels/types.js';
+import { BaseWebhookEnvelopeShape } from './envelope.js';
+/**
+ * Enum-like object of label (`label:*`) webhook event names. Single source
+ * of truth for the discriminator values — `LABEL_WEBHOOK_EVENTS` and every
+ * `z.literal()` below derive from it.
+ */
+export const LabelWebhookEventEnum = {
+    Added: 'label:added',
+    Updated: 'label:updated',
+    Deleted: 'label:deleted',
+};
+/** Webhook events that carry a label as their `eventData`. */
+export const LABEL_WEBHOOK_EVENTS = [
+    LabelWebhookEventEnum.Added,
+    LabelWebhookEventEnum.Updated,
+    LabelWebhookEventEnum.Deleted,
+];
+/**
+ * A label as delivered in a webhook payload.
+ *
+ * Webhook label payloads differ from the REST label shape in two ways:
+ * they use `item_order` (not `order`) and always include `is_deleted`. This
+ * schema reuses {@link LabelSchema}, swapping `order` for `itemOrder` on
+ * the input side and renaming it back after validation, and surfaces
+ * `isDeleted` for downstream filtering.
+ */
+export const WebhookLabelSchema = LabelSchema.omit({ order: true })
+    .extend({
+    itemOrder: z.number().int().nullable(),
+    isDeleted: z.boolean(),
+})
+    .transform((_a) => {
+    var { itemOrder } = _a, rest = __rest(_a, ["itemOrder"]);
+    return (Object.assign(Object.assign({}, rest), { order: itemOrder }));
+});
+export const LabelAddedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(LabelWebhookEventEnum.Added), eventData: WebhookLabelSchema }));
+export const LabelUpdatedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(LabelWebhookEventEnum.Updated), eventData: WebhookLabelSchema }));
+export const LabelDeletedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(LabelWebhookEventEnum.Deleted), eventData: WebhookLabelSchema }));

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,50 @@
+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. `description` is similarly tolerated (older webhook
+ * payloads may omit it) and normalised to `string | null`. 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),
+    description: z
+        .string()
+        .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/tasks.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { TaskSchema } from '../tasks/types.js';
+import { BaseWebhookEnvelopeShape } from './envelope.js';
+/**
+ * Enum-like object of task (`item:*`) webhook event names. Single source of
+ * truth for the discriminator values — `TASK_WEBHOOK_EVENTS` and every
+ * `z.literal()` below derive from it.
+ */
+export const TaskWebhookEventEnum = {
+    Added: 'item:added',
+    Updated: 'item:updated',
+    Completed: 'item:completed',
+    Uncompleted: 'item:uncompleted',
+    Deleted: 'item:deleted',
+};
+/**
+ * Webhook events that carry a {@link Task} as their `eventData`.
+ *
+ * The on-the-wire event names remain `item:*` for historical reasons; the
+ * SDK types call them `Task*` to match the rest of the public API where the
+ * resource is named `Task`.
+ */
+export const TASK_WEBHOOK_EVENTS = [
+    TaskWebhookEventEnum.Added,
+    TaskWebhookEventEnum.Updated,
+    TaskWebhookEventEnum.Completed,
+    TaskWebhookEventEnum.Uncompleted,
+    TaskWebhookEventEnum.Deleted,
+];
+/**
+ * Possible values for the `updateIntent` field on `item:updated`'s
+ * `eventDataExtra`. `item_updated` is the default; the others narrow the
+ * reason for the update (for example, a recurring completion or a change of
+ * assignee).
+ *
+ * @see https://developer.todoist.com/sync/v1/#webhooks (Events Extra)
+ */
+export const UPDATE_INTENTS = [
+    'item_updated',
+    'item_completed',
+    'item_uncompleted',
+    'responsible_uid_changed',
+];
+/**
+ * An unrecognised value from a future backend release degrades gracefully to
+ * `'item_updated'` rather than crashing the whole payload parse.
+ */
+export const UpdateIntentSchema = z.enum(UPDATE_INTENTS).catch('item_updated');
+/**
+ * Extra info delivered alongside an `item:updated` event when the initiator
+ * is the acting user. Contains the pre-update task state plus the reason for
+ * the update — useful for diffing or for distinguishing manual edits from
+ * recurring-task completions.
+ *
+ * @see https://developer.todoist.com/sync/v1/#webhooks (Events Extra)
+ */
+export const TaskUpdatedExtraSchema = z.object({
+    oldItem: TaskSchema,
+    updateIntent: UpdateIntentSchema,
+});
+export const TaskAddedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(TaskWebhookEventEnum.Added), eventData: TaskSchema }));
+export const TaskUpdatedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(TaskWebhookEventEnum.Updated), eventData: TaskSchema, eventDataExtra: TaskUpdatedExtraSchema.optional() }));
+export const TaskCompletedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(TaskWebhookEventEnum.Completed), eventData: TaskSchema }));
+export const TaskUncompletedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(TaskWebhookEventEnum.Uncompleted), eventData: TaskSchema }));
+export const TaskDeletedPayloadSchema = z.object(Object.assign(Object.assign({}, BaseWebhookEnvelopeShape), { eventName: z.literal(TaskWebhookEventEnum.Deleted), eventData: TaskSchema }));

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+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.
+ *
+ * The backend sends snake_case keys and uses the public event form
+ * (`item:added`) in the `event_name` field, so consumers using
+ * `parseWebhookPayload` receive camelCase fields directly.
+ *
+ * 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,
+    TaskUpdatedPayloadSchema,
+    TaskCompletedPayloadSchema,
+    TaskUncompletedPayloadSchema,
+    TaskDeletedPayloadSchema,
+    CommentAddedPayloadSchema,
+    CommentUpdatedPayloadSchema,
+    CommentDeletedPayloadSchema,
+    LabelAddedPayloadSchema,
+    LabelUpdatedPayloadSchema,
+    LabelDeletedPayloadSchema,
+    ProjectAddedPayloadSchema,
+    ProjectUpdatedPayloadSchema,
+    ProjectDeletedPayloadSchema,
+    ProjectArchivedPayloadSchema,
+    ProjectUnarchivedPayloadSchema,
+    SectionAddedPayloadSchema,
+    SectionUpdatedPayloadSchema,
+    SectionDeletedPayloadSchema,
+    SectionArchivedPayloadSchema,
+    SectionUnarchivedPayloadSchema,
+    FilterAddedPayloadSchema,
+    FilterUpdatedPayloadSchema,
+    FilterDeletedPayloadSchema,
+    ReminderFiredPayloadSchema,
+]);
+export { WebhookEventSchema };

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

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/workspaces/requests.js

@@ -0,0 +1 @@
+export {};