@doist/todoist-sdk 8.4.0 → 9.0.0

package/dist/esm/test-utils/test-defaults.js

@@ -15,6 +15,9 @@ const DEFAULT_PARENT_ID = '5678';
 const DEFAULT_ASSIGNEE = '1234';
 const DEFAULT_CREATOR = '1234';
 const DEFAULT_DATE = '2020-09-08T12:00:00Z';
+function defaultDate() {
+    return new Date(DEFAULT_DATE);
+}
 const DEFAULT_ENTITY_COLOR = 'berry_red';
 const DEFAULT_LABELS = ['personal', 'work', 'hobby'];
 const DEFAULT_USER_ID = '5';
@@ -64,9 +67,9 @@ export const DEFAULT_TASK = {
     duration: DEFAULT_DURATION,
     checked: false,
     isDeleted: DEFAULT_IS_DELETED,
-    addedAt: DEFAULT_DATE,
+    addedAt: defaultDate(),
     completedAt: null,
-    updatedAt: DEFAULT_DATE,
+    updatedAt: defaultDate(),
     due: DEFAULT_DUE_DATE,
     priority: DEFAULT_TASK_PRIORITY,
     childOrder: DEFAULT_ORDER,
@@ -92,9 +95,9 @@ export const TASK_WITH_OPTIONALS_AS_NULL = {
     duration: null,
     checked: false,
     isDeleted: DEFAULT_IS_DELETED,
-    addedAt: DEFAULT_DATE,
+    addedAt: defaultDate(),
     completedAt: null,
-    updatedAt: DEFAULT_DATE,
+    updatedAt: defaultDate(),
     due: null,
     priority: DEFAULT_TASK_PRIORITY,
     childOrder: DEFAULT_ORDER,
@@ -119,8 +122,8 @@ export const DEFAULT_PROJECT = {
     isArchived: DEFAULT_IS_ARCHIVED,
     isDeleted: DEFAULT_IS_DELETED,
     isFrozen: DEFAULT_IS_FROZEN,
-    createdAt: DEFAULT_DATE,
-    updatedAt: DEFAULT_DATE,
+    createdAt: defaultDate(),
+    updatedAt: defaultDate(),
     defaultOrder: DEFAULT_ORDER,
     description: '',
     isCollapsed: DEFAULT_IS_COLLAPSED,
@@ -140,8 +143,8 @@ export const DEFAULT_WORKSPACE_PROJECT = {
     isArchived: DEFAULT_IS_ARCHIVED,
     isDeleted: DEFAULT_IS_DELETED,
     isFrozen: DEFAULT_IS_FROZEN,
-    createdAt: DEFAULT_DATE,
-    updatedAt: DEFAULT_DATE,
+    createdAt: defaultDate(),
+    updatedAt: defaultDate(),
     defaultOrder: DEFAULT_ORDER,
     description: '',
     isCollapsed: DEFAULT_IS_COLLAPSED,
@@ -158,8 +161,8 @@ export const DEFAULT_SECTION = {
     id: DEFAULT_SECTION_ID,
     userId: DEFAULT_USER_ID,
     projectId: DEFAULT_PROJECT_ID,
-    addedAt: '2025-03-28T14:01:23.334881Z',
-    updatedAt: '2025-03-28T14:01:23.334885Z',
+    addedAt: new Date('2025-03-28T14:01:23.334881Z'),
+    updatedAt: new Date('2025-03-28T14:01:23.334885Z'),
     archivedAt: null,
     name: DEFAULT_SECTION_NAME,
     sectionOrder: DEFAULT_ORDER,
@@ -197,7 +200,7 @@ export const DEFAULT_RAW_COMMENT = {
     fileAttachment: DEFAULT_ATTACHMENT,
     uidsToNotify: null,
     isDeleted: false,
-    postedAt: DEFAULT_DATE,
+    postedAt: defaultDate(),
     reactions: DEFAULT_COMMENT_REACTIONS,
     itemId: DEFAULT_TASK_ID,
 };
@@ -278,7 +281,7 @@ export const DEFAULT_NOTE = {
     id: DEFAULT_COMMENT_ID,
     projectId: DEFAULT_PROJECT_ID,
     content: DEFAULT_COMMENT_CONTENT,
-    postedAt: DEFAULT_DATE,
+    postedAt: defaultDate(),
     fileAttachment: DEFAULT_ATTACHMENT,
     postedUid: DEFAULT_USER_ID,
     uidsToNotify: null,

package/dist/esm/types/activity/types.js

@@ -12,7 +12,7 @@ export const ActivityEventSchema = z
     objectType: z.string(),
     objectId: z.string(),
     eventType: z.string(),
-    eventDate: z.string(),
+    eventDate: z.coerce.date(),
     id: z
         .union([z.string(), z.number()])
         .transform((val) => { var _a; return (_a = val === null || val === void 0 ? void 0 : val.toString()) !== null && _a !== void 0 ? _a : null; })

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

@@ -35,7 +35,7 @@ export const RawCommentSchema = z
     itemId: z.string().optional(),
     projectId: z.string().optional(),
     content: z.string(),
-    postedAt: z.string(),
+    postedAt: z.coerce.date(),
     fileAttachment: AttachmentSchema.nullable(),
     postedUid: z.string(),
     uidsToNotify: z.array(z.string()).nullable(),

package/dist/esm/types/insights/types.js

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 export const DayActivitySchema = z.object({
+    // Kept as string: this is a calendar-day bucket (e.g. '2025-01-13'), not a timestamp.
+    // Coercing to Date would create UTC midnight, causing day-shift for non-UTC consumers.
     date: z.string(),
     totalCount: z.number().int(),
 });
@@ -31,7 +33,7 @@ export const ProjectHealthSchema = z.object({
     descriptionSummary: z.string().nullable().optional(),
     taskRecommendations: z.array(TaskRecommendationSchema).nullable().optional(),
     projectId: z.string().nullable().optional(),
-    updatedAt: z.string().nullable().optional(),
+    updatedAt: z.coerce.date().nullable().optional(),
     isStale: z.boolean().default(false),
     updateInProgress: z.boolean().default(false),
 });
@@ -50,9 +52,9 @@ export const TaskContextSchema = z.object({
     deadline: z.string().nullable().optional(),
     priority: z.string(),
     isCompleted: z.boolean(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
-    completedAt: z.string().nullable(),
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+    completedAt: z.coerce.date().nullable(),
     completedByUid: z.string().nullable(),
     labels: z.array(z.string()),
 });

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

@@ -9,13 +9,13 @@ export const BaseProjectSchema = z.object({
     canAssignTasks: z.boolean(),
     childOrder: z.number().int(),
     color: z.string(),
-    createdAt: z.string().nullable(),
+    createdAt: z.coerce.date().nullable(),
     isArchived: z.boolean(),
     isDeleted: z.boolean(),
     isFavorite: z.boolean(),
     isFrozen: z.boolean(),
     name: z.string(),
-    updatedAt: z.string().nullable(),
+    updatedAt: z.coerce.date().nullable(),
     viewStyle: z.string(),
     defaultOrder: z.number().int(),
     description: z.string(),
@@ -49,5 +49,15 @@ export const WorkspaceProjectSchema = BaseProjectSchema.extend({
 }).transform((data) => {
     return Object.assign(Object.assign({}, data), { url: getProjectUrl(data.id, data.name) });
 });
+/**
+ * Schema for any project type in Todoist (personal or workspace).
+ * Dispatches to WorkspaceProjectSchema when workspaceId is present, PersonalProjectSchema otherwise.
+ */
+export const ProjectSchema = z.unknown().transform((val) => {
+    if (typeof val === 'object' && val !== null && 'workspaceId' in val) {
+        return WorkspaceProjectSchema.parse(val);
+    }
+    return PersonalProjectSchema.parse(val);
+});
 /** Available project view styles. */
 export const PROJECT_VIEW_STYLES = ['list', 'board', 'calendar'];

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

@@ -5,9 +5,9 @@ export const SectionSchema = z
     id: z.string(),
     userId: z.string(),
     projectId: z.string(),
-    addedAt: z.string(),
-    updatedAt: z.string(),
-    archivedAt: z.string().nullable(),
+    addedAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+    archivedAt: z.coerce.date().nullable(),
     name: z.string(),
     sectionOrder: z.number().int(),
     isArchived: z.boolean(),

package/dist/esm/types/sync/resources/live-notifications.js

@@ -9,7 +9,7 @@ import { z } from 'zod';
  */
 export const LiveNotificationSchema = z.looseObject({
     id: z.string(),
-    createdAt: z.string(),
+    createdAt: z.coerce.date(),
     fromUid: z.string(),
     notificationType: z.string(),
     isUnread: z.boolean(),

package/dist/esm/types/sync/resources/notes.js

@@ -9,7 +9,7 @@ export const NoteSchema = z.looseObject({
     itemId: z.string().optional(),
     projectId: z.string().optional(),
     content: z.string(),
-    postedAt: z.string(),
+    postedAt: z.coerce.date(),
     fileAttachment: AttachmentSchema.nullable(),
     postedUid: z.string(),
     uidsToNotify: z.array(z.string()).nullable(),

package/dist/esm/types/sync/resources/user.js

@@ -54,7 +54,7 @@ export const SyncUserSchema = z.looseObject({
     daysOff: z.array(z.number().int()),
     featureIdentifier: z.string(),
     features: FeaturesSchema,
-    freeTrailExpires: z.string().optional(),
+    freeTrailExpires: z.coerce.date().optional(),
     hasMagicNumber: z.boolean(),
     hasPassword: z.boolean(),
     hasStartedATrial: z.boolean().optional(),
@@ -63,7 +63,7 @@ export const SyncUserSchema = z.looseObject({
     isCelebrationsEnabled: z.boolean(),
     isPremium: z.boolean(),
     joinableWorkspace: JoinableWorkspaceSchema.nullable(),
-    joinedAt: z.string(),
+    joinedAt: z.coerce.date(),
     gettingStartedGuideProjects: z.array(GettingStartedGuideProjectSchema).nullable(),
     karma: z.number(),
     karmaTrend: z.string(),
@@ -81,13 +81,13 @@ export const SyncUserSchema = z.looseObject({
     onboardingTeamMode: z.boolean().nullable().optional(),
     onboardingUseCases: z.array(z.string()).nullable().optional(),
     premiumStatus: z.enum(PREMIUM_STATUSES),
-    premiumUntil: z.string().nullable(),
+    premiumUntil: z.coerce.date().nullable(),
     rambleSessionsUsage: z
         .object({
         currentCount: z.number().int(),
         limit: z.number().int(),
         remaining: z.number().int(),
-        resetDate: z.string(),
+        resetDate: z.coerce.date(),
     })
         .nullable()
         .optional(),

package/dist/esm/types/sync/resources/workspace-filters.js

@@ -11,6 +11,6 @@ export const WorkspaceFilterSchema = z.looseObject({
     isFrozen: z.boolean(),
     creatorUid: z.string(),
     updaterUid: z.string(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
 });

package/dist/esm/types/sync/resources/workspace-goals.js

@@ -18,6 +18,6 @@ export const WorkspaceGoalSchema = z.looseObject({
     projectIds: z.array(z.string()),
     progress: WorkspaceGoalProgressSchema.nullable(),
     creatorUid: z.string(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
 });

package/dist/esm/types/sync/resources/workspaces.js

@@ -29,8 +29,8 @@ export const SyncWorkspaceSchema = z
     logoSmall: z.string().optional(),
     logoS640: z.string().optional(),
     creatorId: StringOrNumberSchema,
-    createdAt: z.string().optional(),
-    dateCreated: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    dateCreated: z.coerce.date().optional(),
     isDeleted: z.boolean(),
     isCollapsed: z.boolean(),
     role: WorkspaceRoleSchema.optional(),
@@ -58,7 +58,7 @@ export const SyncWorkspaceSchema = z
     defaultCollaborators: z
         .object({
         predefinedGroupIds: z.array(z.string()),
-        userIds: z.array(z.number()),
+        userIds: z.array(StringOrNumberSchema),
     })
         .optional(),
     properties: WorkspacePropertiesSchema.optional(),

package/dist/esm/types/sync/response.js

@@ -1 +1,52 @@
-export {};
+import { z } from 'zod';
+import { LabelSchema } from '../labels/types.js';
+import { ProjectSchema } from '../projects/types.js';
+import { SectionSchema } from '../sections/types.js';
+import { TaskSchema } from '../tasks/types.js';
+import { WorkspaceUserSchema } from '../workspaces/types.js';
+import { FilterSchema, CollaboratorSchema, CollaboratorStateSchema, FolderSchema, NoteSchema, TooltipsSchema, WorkspaceFilterSchema, WorkspaceGoalSchema, CalendarSchema, CalendarAccountSchema, ReminderSchema, LocationReminderSchema, CompletedInfoSchema, ViewOptionsSchema, ProjectViewOptionsDefaultsSchema, UserPlanLimitsSchema, LiveNotificationSchema, SyncWorkspaceSchema, SyncUserSchema, UserSettingsSchema, SuggestionSchema, } from './resources/index.js';
+export const SyncErrorSchema = z.object({
+    error: z.string(),
+    errorCode: z.number(),
+    errorExtra: z.record(z.string(), z.unknown()),
+    errorTag: z.string(),
+    httpCode: z.number(),
+});
+export const SyncResponseSchema = z.looseObject({
+    syncToken: z.string().optional(),
+    fullSync: z.boolean().optional(),
+    syncStatus: z.record(z.string(), z.union([z.literal('ok'), SyncErrorSchema])).optional(),
+    tempIdMapping: z.record(z.string(), z.string()).optional(),
+    items: z.array(TaskSchema).optional(),
+    projects: z.array(ProjectSchema).optional(),
+    sections: z.array(SectionSchema).optional(),
+    labels: z.array(LabelSchema).optional(),
+    notes: z.array(NoteSchema).optional(),
+    projectNotes: z.array(NoteSchema).optional(),
+    filters: z.array(FilterSchema).optional(),
+    reminders: z.array(ReminderSchema).optional(),
+    remindersLocation: z.array(LocationReminderSchema).optional(),
+    locations: z.array(z.record(z.string(), z.unknown())).optional(),
+    user: SyncUserSchema.optional(),
+    liveNotifications: z.array(LiveNotificationSchema).optional(),
+    collaborators: z.array(CollaboratorSchema).optional(),
+    collaboratorStates: z.array(CollaboratorStateSchema).optional(),
+    userSettings: UserSettingsSchema.optional(),
+    notificationSettings: z.record(z.string(), z.boolean()).optional(),
+    userPlanLimits: UserPlanLimitsSchema.optional(),
+    completedInfo: z.array(CompletedInfoSchema).optional(),
+    stats: z.record(z.string(), z.unknown()).optional(),
+    workspaces: z.array(SyncWorkspaceSchema).optional(),
+    workspaceUsers: z.array(WorkspaceUserSchema).optional(),
+    workspaceFilters: z.array(WorkspaceFilterSchema).optional(),
+    viewOptions: z.array(ViewOptionsSchema).optional(),
+    projectViewOptionsDefaults: z.array(ProjectViewOptionsDefaultsSchema).optional(),
+    roleActions: z.array(z.record(z.string(), z.unknown())).optional(),
+    folders: z.array(FolderSchema).optional(),
+    workspaceGoals: z.array(WorkspaceGoalSchema).optional(),
+    dayOrders: z.record(z.string(), z.number()).optional(),
+    calendars: z.array(CalendarSchema).optional(),
+    calendarAccounts: z.array(CalendarAccountSchema).optional(),
+    suggestions: z.array(SuggestionSchema).optional(),
+    tooltips: TooltipsSchema.optional(),
+});

package/dist/esm/types/tasks/types.js

@@ -37,9 +37,9 @@ export const TaskSchema = z
     duration: DurationSchema.nullable(),
     checked: z.boolean(),
     isDeleted: z.boolean(),
-    addedAt: z.string().nullable(),
-    completedAt: z.string().nullable(),
-    updatedAt: z.string().nullable(),
+    addedAt: z.coerce.date().nullable(),
+    completedAt: z.coerce.date().nullable(),
+    updatedAt: z.coerce.date().nullable(),
     due: DueDateSchema.nullable(),
     priority: z.number().int(),
     childOrder: z.number().int(),

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

@@ -71,7 +71,7 @@ export const WorkspacePlanDetailsSchema = z.object({
     currentActiveProjects: z.number(),
     maximumActiveProjects: z.number(),
     priceList: z.array(FormattedPriceListingSchema),
-    workspaceId: z.number(),
+    workspaceId: StringOrNumberSchema,
     isTrialing: z.boolean(),
     trialEndsAt: z.string().nullable(),
     cancelAtPeriodEnd: z.boolean(),
@@ -122,8 +122,8 @@ export const WorkspaceSchema = z
     logoMedium: z.string().nullish(),
     logoSmall: z.string().nullish(),
     logoS640: z.string().nullish(),
-    createdAt: z.string().optional(),
-    dateCreated: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    dateCreated: z.coerce.date().optional(),
     creatorId: StringOrNumberSchema,
     properties: WorkspacePropertiesSchema,
 })

package/dist/esm/utils/validators.js

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { ActivityEventSchema } from '../types/activity/types.js';
 import { BackupSchema } from '../types/backups/types.js';
 import { AttachmentSchema, CommentSchema } from '../types/comments/types.js';
@@ -5,149 +6,73 @@ import { IdMappingSchema, MovedIdSchema } from '../types/id-mappings/types.js';
 import { ProjectActivityStatsSchema, ProjectHealthSchema, ProjectHealthContextSchema, ProjectProgressSchema, WorkspaceInsightsSchema, } from '../types/insights/types.js';
 import { LabelSchema } from '../types/labels/types.js';
 import { ProductivityStatsSchema } from '../types/productivity/types.js';
-import { PersonalProjectSchema, WorkspaceProjectSchema, } from '../types/projects/types.js';
+import { WorkspaceProjectSchema, ProjectSchema } from '../types/projects/types.js';
 import { SectionSchema } from '../types/sections/types.js';
+import { SyncResponseSchema } from '../types/sync/response.js';
 import { TaskSchema } from '../types/tasks/types.js';
 import { UserSchema, CurrentUserSchema } from '../types/users/types.js';
 import { WorkspaceUserSchema, WorkspaceInvitationSchema, WorkspacePlanDetailsSchema, JoinWorkspaceResultSchema, WorkspaceSchema, MemberActivityInfoSchema, WorkspaceUserTaskSchema, } from '../types/workspaces/types.js';
 import { FilterSchema, CollaboratorSchema, CollaboratorStateSchema, FolderSchema, NoteSchema, TooltipsSchema, WorkspaceFilterSchema, WorkspaceGoalSchema, CalendarSchema, CalendarAccountSchema, ReminderSchema, LocationReminderSchema, CompletedInfoSchema, ViewOptionsSchema, ProjectViewOptionsDefaultsSchema, UserPlanLimitsSchema, LiveNotificationSchema, SyncWorkspaceSchema, SyncUserSchema, UserSettingsSchema, SuggestionSchema, } from '../types/sync/resources/index.js';
 function createValidator(schema) {
-    return (input) => schema.parse(input);
-}
-function createArrayValidator(validateItem) {
-    return (input) => {
-        if (!Array.isArray(input)) {
-            throw new TypeError(`Expected array, got ${typeof input}`);
-        }
-        return input.map(validateItem);
+    return {
+        validate: (input) => schema.parse(input),
+        validateArray: (input) => z.array(schema).parse(input),
     };
 }
 // Entity validators
-export const validateTask = createValidator(TaskSchema);
-export const validateTaskArray = createArrayValidator(validateTask);
+export const { validate: validateTask, validateArray: validateTaskArray } = createValidator(TaskSchema);
 /**
  * Validates and parses a project input.
  * @param input The input to validate
  * @returns A validated project (either PersonalProject or WorkspaceProject)
  */
-export function validateProject(input) {
-    if ('workspaceId' in input) {
-        return WorkspaceProjectSchema.parse(input);
-    }
-    return PersonalProjectSchema.parse(input);
-}
-export function validateProjectArray(input) {
-    if (!Array.isArray(input)) {
-        throw new TypeError(`Expected array, got ${typeof input}`);
-    }
-    return input.map(validateProject);
-}
-export const validateWorkspaceProject = createValidator(WorkspaceProjectSchema);
-export const validateWorkspaceProjectArray = createArrayValidator(validateWorkspaceProject);
-export const validateSection = createValidator(SectionSchema);
-export const validateSectionArray = createArrayValidator(validateSection);
-export const validateLabel = createValidator(LabelSchema);
-export const validateLabelArray = createArrayValidator(validateLabel);
-export const validateComment = createValidator(CommentSchema);
-export const validateCommentArray = createArrayValidator(validateComment);
-export const validateUser = createValidator(UserSchema);
-export const validateUserArray = createArrayValidator(validateUser);
-export const validateProductivityStats = createValidator(ProductivityStatsSchema);
-export const validateCurrentUser = createValidator(CurrentUserSchema);
-export const validateActivityEvent = createValidator(ActivityEventSchema);
-export const validateActivityEventArray = createArrayValidator(validateActivityEvent);
-export const validateAttachment = createValidator(AttachmentSchema);
-export const validateWorkspaceUser = createValidator(WorkspaceUserSchema);
-export function validateWorkspaceUserArray(input) {
-    if (!Array.isArray(input)) {
-        throw new Error(`Expected array for workspace users, got ${typeof input}`);
-    }
-    return input.map(validateWorkspaceUser);
-}
-export const validateWorkspaceInvitation = createValidator(WorkspaceInvitationSchema);
-export const validateWorkspaceInvitationArray = createArrayValidator(validateWorkspaceInvitation);
-export const validateWorkspacePlanDetails = createValidator(WorkspacePlanDetailsSchema);
-export const validateJoinWorkspaceResult = createValidator(JoinWorkspaceResultSchema);
-export const validateWorkspace = createValidator(WorkspaceSchema);
-export const validateWorkspaceArray = createArrayValidator(validateWorkspace);
-export const validateMemberActivityInfo = createValidator(MemberActivityInfoSchema);
-export const validateMemberActivityInfoArray = createArrayValidator(validateMemberActivityInfo);
-export const validateWorkspaceUserTask = createValidator(WorkspaceUserTaskSchema);
-export const validateWorkspaceUserTaskArray = createArrayValidator(validateWorkspaceUserTask);
-export const validateProjectActivityStats = createValidator(ProjectActivityStatsSchema);
-export const validateProjectHealth = createValidator(ProjectHealthSchema);
-export const validateProjectHealthContext = createValidator(ProjectHealthContextSchema);
-export const validateProjectProgress = createValidator(ProjectProgressSchema);
-export const validateWorkspaceInsights = createValidator(WorkspaceInsightsSchema);
-export const validateBackup = createValidator(BackupSchema);
-export const validateBackupArray = createArrayValidator(validateBackup);
-export const validateIdMapping = createValidator(IdMappingSchema);
-export const validateIdMappingArray = createArrayValidator(validateIdMapping);
-export const validateMovedId = createValidator(MovedIdSchema);
-export const validateMovedIdArray = createArrayValidator(validateMovedId);
+export const { validate: validateProject, validateArray: validateProjectArray } = createValidator(ProjectSchema);
+export const { validate: validateWorkspaceProject, validateArray: validateWorkspaceProjectArray } = createValidator(WorkspaceProjectSchema);
+export const { validate: validateSection, validateArray: validateSectionArray } = createValidator(SectionSchema);
+export const { validate: validateLabel, validateArray: validateLabelArray } = createValidator(LabelSchema);
+export const { validate: validateComment, validateArray: validateCommentArray } = createValidator(CommentSchema);
+export const { validate: validateUser, validateArray: validateUserArray } = createValidator(UserSchema);
+export const { validate: validateProductivityStats } = createValidator(ProductivityStatsSchema);
+export const { validate: validateCurrentUser } = createValidator(CurrentUserSchema);
+export const { validate: validateActivityEvent, validateArray: validateActivityEventArray } = createValidator(ActivityEventSchema);
+export const { validate: validateAttachment } = createValidator(AttachmentSchema);
+export const { validate: validateWorkspaceUser, validateArray: validateWorkspaceUserArray } = createValidator(WorkspaceUserSchema);
+export const { validate: validateWorkspaceInvitation, validateArray: validateWorkspaceInvitationArray, } = createValidator(WorkspaceInvitationSchema);
+export const { validate: validateWorkspacePlanDetails } = createValidator(WorkspacePlanDetailsSchema);
+export const { validate: validateJoinWorkspaceResult } = createValidator(JoinWorkspaceResultSchema);
+export const { validate: validateWorkspace, validateArray: validateWorkspaceArray } = createValidator(WorkspaceSchema);
+export const { validate: validateMemberActivityInfo, validateArray: validateMemberActivityInfoArray, } = createValidator(MemberActivityInfoSchema);
+export const { validate: validateWorkspaceUserTask, validateArray: validateWorkspaceUserTaskArray, } = createValidator(WorkspaceUserTaskSchema);
+export const { validate: validateProjectActivityStats } = createValidator(ProjectActivityStatsSchema);
+export const { validate: validateProjectHealth } = createValidator(ProjectHealthSchema);
+export const { validate: validateProjectHealthContext } = createValidator(ProjectHealthContextSchema);
+export const { validate: validateProjectProgress } = createValidator(ProjectProgressSchema);
+export const { validate: validateWorkspaceInsights } = createValidator(WorkspaceInsightsSchema);
+export const { validate: validateBackup, validateArray: validateBackupArray } = createValidator(BackupSchema);
+export const { validate: validateIdMapping, validateArray: validateIdMappingArray } = createValidator(IdMappingSchema);
+export const { validate: validateMovedId, validateArray: validateMovedIdArray } = createValidator(MovedIdSchema);
 // Sync resource validators
-export const validateFilter = createValidator(FilterSchema);
-export const validateFilterArray = createArrayValidator(validateFilter);
-export const validateCollaborator = createValidator(CollaboratorSchema);
-export const validateCollaboratorArray = createArrayValidator(validateCollaborator);
-export const validateCollaboratorState = createValidator(CollaboratorStateSchema);
-export const validateCollaboratorStateArray = createArrayValidator(validateCollaboratorState);
-export const validateFolder = createValidator(FolderSchema);
-export const validateFolderArray = createArrayValidator(validateFolder);
-export const validateNote = createValidator(NoteSchema);
-export const validateNoteArray = createArrayValidator(validateNote);
-export const validateTooltips = createValidator(TooltipsSchema);
-export const validateWorkspaceFilter = createValidator(WorkspaceFilterSchema);
-export const validateWorkspaceFilterArray = createArrayValidator(validateWorkspaceFilter);
-export const validateWorkspaceGoal = createValidator(WorkspaceGoalSchema);
-export const validateWorkspaceGoalArray = createArrayValidator(validateWorkspaceGoal);
-export const validateCalendar = createValidator(CalendarSchema);
-export const validateCalendarArray = createArrayValidator(validateCalendar);
-export const validateCalendarAccount = createValidator(CalendarAccountSchema);
-export const validateCalendarAccountArray = createArrayValidator(validateCalendarAccount);
-export const validateReminder = createValidator(ReminderSchema);
-export const validateReminderArray = createArrayValidator(validateReminder);
-export const validateLocationReminder = createValidator(LocationReminderSchema);
-export const validateLocationReminderArray = createArrayValidator(validateLocationReminder);
-export const validateCompletedInfo = createValidator(CompletedInfoSchema);
-export const validateCompletedInfoArray = createArrayValidator(validateCompletedInfo);
-export const validateViewOptions = createValidator(ViewOptionsSchema);
-export const validateViewOptionsArray = createArrayValidator(validateViewOptions);
-export const validateProjectViewOptionsDefaults = createValidator(ProjectViewOptionsDefaultsSchema);
-export const validateProjectViewOptionsDefaultsArray = createArrayValidator(validateProjectViewOptionsDefaults);
-export const validateUserPlanLimits = createValidator(UserPlanLimitsSchema);
-export const validateLiveNotification = createValidator(LiveNotificationSchema);
-export const validateLiveNotificationArray = createArrayValidator(validateLiveNotification);
-export const validateSyncWorkspace = createValidator(SyncWorkspaceSchema);
-export const validateSyncWorkspaceArray = createArrayValidator(validateSyncWorkspace);
-export const validateSyncUser = createValidator(SyncUserSchema);
-export const validateUserSettings = createValidator(UserSettingsSchema);
-export const validateSuggestion = createValidator(SuggestionSchema);
-export const validateSuggestionArray = createArrayValidator(validateSuggestion);
+export const { validate: validateFilter, validateArray: validateFilterArray } = createValidator(FilterSchema);
+export const { validate: validateCollaborator, validateArray: validateCollaboratorArray } = createValidator(CollaboratorSchema);
+export const { validate: validateCollaboratorState, validateArray: validateCollaboratorStateArray, } = createValidator(CollaboratorStateSchema);
+export const { validate: validateFolder, validateArray: validateFolderArray } = createValidator(FolderSchema);
+export const { validate: validateNote, validateArray: validateNoteArray } = createValidator(NoteSchema);
+export const { validate: validateTooltips } = createValidator(TooltipsSchema);
+export const { validate: validateWorkspaceFilter, validateArray: validateWorkspaceFilterArray } = createValidator(WorkspaceFilterSchema);
+export const { validate: validateWorkspaceGoal, validateArray: validateWorkspaceGoalArray } = createValidator(WorkspaceGoalSchema);
+export const { validate: validateCalendar, validateArray: validateCalendarArray } = createValidator(CalendarSchema);
+export const { validate: validateCalendarAccount, validateArray: validateCalendarAccountArray } = createValidator(CalendarAccountSchema);
+export const { validate: validateReminder, validateArray: validateReminderArray } = createValidator(ReminderSchema);
+export const { validate: validateLocationReminder, validateArray: validateLocationReminderArray } = createValidator(LocationReminderSchema);
+export const { validate: validateCompletedInfo, validateArray: validateCompletedInfoArray } = createValidator(CompletedInfoSchema);
+export const { validate: validateViewOptions, validateArray: validateViewOptionsArray } = createValidator(ViewOptionsSchema);
+export const { validate: validateProjectViewOptionsDefaults, validateArray: validateProjectViewOptionsDefaultsArray, } = createValidator(ProjectViewOptionsDefaultsSchema);
+export const { validate: validateUserPlanLimits } = createValidator(UserPlanLimitsSchema);
+export const { validate: validateLiveNotification, validateArray: validateLiveNotificationArray } = createValidator(LiveNotificationSchema);
+export const { validate: validateSyncWorkspace, validateArray: validateSyncWorkspaceArray } = createValidator(SyncWorkspaceSchema);
+export const { validate: validateSyncUser } = createValidator(SyncUserSchema);
+export const { validate: validateUserSettings } = createValidator(UserSettingsSchema);
+export const { validate: validateSuggestion, validateArray: validateSuggestionArray } = createValidator(SuggestionSchema);
 export function parseSyncResponse(raw) {
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, raw), ('items' in raw ? { items: validateTaskArray(raw.items) } : {})), ('projects' in raw ? { projects: validateProjectArray(raw.projects) } : {})), ('sections' in raw ? { sections: validateSectionArray(raw.sections) } : {})), ('labels' in raw ? { labels: validateLabelArray(raw.labels) } : {})), ('notes' in raw ? { notes: validateNoteArray(raw.notes) } : {})), ('projectNotes' in raw ? { projectNotes: validateNoteArray(raw.projectNotes) } : {})), ('filters' in raw ? { filters: validateFilterArray(raw.filters) } : {})), ('reminders' in raw ? { reminders: validateReminderArray(raw.reminders) } : {})), ('remindersLocation' in raw
-        ? { remindersLocation: validateLocationReminderArray(raw.remindersLocation) }
-        : {})), ('user' in raw ? { user: validateSyncUser(raw.user) } : {})), ('liveNotifications' in raw
-        ? { liveNotifications: validateLiveNotificationArray(raw.liveNotifications) }
-        : {})), ('collaborators' in raw
-        ? { collaborators: validateCollaboratorArray(raw.collaborators) }
-        : {})), ('collaboratorStates' in raw
-        ? { collaboratorStates: validateCollaboratorStateArray(raw.collaboratorStates) }
-        : {})), ('userSettings' in raw ? { userSettings: validateUserSettings(raw.userSettings) } : {})), ('userPlanLimits' in raw
-        ? { userPlanLimits: validateUserPlanLimits(raw.userPlanLimits) }
-        : {})), ('completedInfo' in raw
-        ? { completedInfo: validateCompletedInfoArray(raw.completedInfo) }
-        : {})), ('workspaces' in raw ? { workspaces: validateSyncWorkspaceArray(raw.workspaces) } : {})), ('workspaceUsers' in raw
-        ? { workspaceUsers: validateWorkspaceUserArray(raw.workspaceUsers) }
-        : {})), ('workspaceFilters' in raw
-        ? { workspaceFilters: validateWorkspaceFilterArray(raw.workspaceFilters) }
-        : {})), ('viewOptions' in raw ? { viewOptions: validateViewOptionsArray(raw.viewOptions) } : {})), ('projectViewOptionsDefaults' in raw
-        ? {
-            projectViewOptionsDefaults: validateProjectViewOptionsDefaultsArray(raw.projectViewOptionsDefaults),
-        }
-        : {})), ('folders' in raw ? { folders: validateFolderArray(raw.folders) } : {})), ('workspaceGoals' in raw
-        ? { workspaceGoals: validateWorkspaceGoalArray(raw.workspaceGoals) }
-        : {})), ('calendars' in raw ? { calendars: validateCalendarArray(raw.calendars) } : {})), ('calendarAccounts' in raw
-        ? { calendarAccounts: validateCalendarAccountArray(raw.calendarAccounts) }
-        : {})), ('suggestions' in raw ? { suggestions: validateSuggestionArray(raw.suggestions) } : {})), ('tooltips' in raw ? { tooltips: validateTooltips(raw.tooltips) } : {}));
+    return SyncResponseSchema.parse(raw);
 }

package/dist/types/consts/endpoints.d.ts

@@ -78,5 +78,5 @@ export declare const ENDPOINT_WORKSPACE_MEMBERS = "workspaces/members";
 export declare function getWorkspaceUserTasksEndpoint(workspaceId: string, userId: string): string;
 export declare function getWorkspaceInviteUsersEndpoint(workspaceId: string): string;
 export declare function getWorkspaceUserEndpoint(workspaceId: string, userId: string): string;
-export declare function getWorkspaceActiveProjectsEndpoint(workspaceId: number): string;
-export declare function getWorkspaceArchivedProjectsEndpoint(workspaceId: number): string;
+export declare function getWorkspaceActiveProjectsEndpoint(workspaceId: string): string;
+export declare function getWorkspaceArchivedProjectsEndpoint(workspaceId: string): string;