@doist/todoist-api-typescript 6.5.0 → 6.6.0

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+const NavigationFeatureSchema = z.object({
+    name: z.string(),
+    shown: z.boolean(),
+});
+const QuickAddFeatureSchema = z.object({
+    name: z.string(),
+    shown: z.boolean(),
+});
+/**
+ * Sync API user settings resource.
+ */
+export const UserSettingsSchema = z
+    .object({
+    completedSoundDesktop: z.boolean(),
+    completedSoundMobile: z.boolean(),
+    debugLogSendingEnabledUntil: z.string().nullable(),
+    legacyPricing: z.boolean(),
+    navigation: z
+        .object({
+        countsShown: z.boolean(),
+        features: z.array(NavigationFeatureSchema),
+    })
+        .passthrough(),
+    reminderDesktop: z.boolean(),
+    reminderEmail: z.boolean(),
+    reminderPush: z.boolean(),
+    resetRecurringSubtasks: z.boolean(),
+    aiEmailAssist: z.boolean(),
+    theme: z.string().nullable().optional(),
+    syncTheme: z.boolean().optional(),
+    quickAdd: z
+        .object({
+        labelsShown: z.boolean(),
+        features: z.array(QuickAddFeatureSchema),
+    })
+        .passthrough(),
+})
+    .passthrough();

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

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+const FeaturesSchema = z
+    .object({
+    karmaDisabled: z.boolean(),
+    restriction: z.number().int(),
+    karmaVacation: z.boolean(),
+    dateistLang: z.any(),
+    beta: z.union([z.literal(0), z.literal(1)]),
+    hasPushReminders: z.boolean(),
+    dateistInlineDisabled: z.boolean(),
+    autoInviteDisabled: z.boolean().optional(),
+    goldTheme: z.boolean().optional(),
+    migratedFromTdb: z.boolean().optional(),
+})
+    .passthrough();
+const TzInfoSchema = z
+    .object({
+    timezone: z.string(),
+    hours: z.number().int(),
+    minutes: z.number().int(),
+    isDst: z.union([z.literal(0), z.literal(1)]),
+    gmtString: z.string(),
+})
+    .passthrough();
+const JoinableWorkspaceSchema = z
+    .object({
+    workspaceId: z.string(),
+    workspaceName: z.string(),
+    memberCount: z.number().int(),
+})
+    .passthrough();
+const GettingStartedGuideProjectSchema = z
+    .object({
+    onboardingUseCase: z.string(),
+    projectId: z.string(),
+    completed: z.boolean(),
+    closed: z.boolean(),
+})
+    .passthrough();
+/**
+ * Sync API user resource.
+ *
+ * This is a superset of the REST `CurrentUserSchema` — the Sync API returns
+ * many additional fields for features, onboarding state, and account details.
+ */
+export const SyncUserSchema = z
+    .object({
+    id: z.string(),
+    email: z.string(),
+    fullName: z.string(),
+    activatedUser: z.boolean(),
+    autoReminder: z.number().int(),
+    avatarBig: z.string().optional(),
+    avatarMedium: z.string().optional(),
+    avatarS640: z.string().optional(),
+    avatarSmall: z.string().optional(),
+    businessAccountId: z.string().nullable(),
+    dailyGoal: z.number().int(),
+    dateFormat: z.number().int(),
+    dateistLang: z.string().nullable(),
+    daysOff: z.array(z.number().int()),
+    featureIdentifier: z.string(),
+    features: FeaturesSchema,
+    freeTrailExpires: z.string().optional(),
+    hasMagicNumber: z.boolean(),
+    hasPassword: z.boolean(),
+    hasStartedATrial: z.boolean().optional(),
+    imageId: z.string().nullable(),
+    inboxProjectId: z.string(),
+    isCelebrationsEnabled: z.boolean(),
+    isPremium: z.boolean(),
+    joinableWorkspace: JoinableWorkspaceSchema.nullable(),
+    joinedAt: z.string(),
+    gettingStartedGuideProjects: z.array(GettingStartedGuideProjectSchema).nullable(),
+    karma: z.number(),
+    karmaTrend: z.string(),
+    lang: z.string(),
+    mfaEnabled: z.boolean().optional(),
+    mobileHost: z.string().nullable(),
+    mobileNumber: z.string().nullable(),
+    nextWeek: z.number().int(),
+    onboardingLevel: z.string().nullable().optional(),
+    onboardingRole: z.string().nullable().optional(),
+    onboardingPersona: z.string().nullable().optional(),
+    onboardingInitiated: z.boolean().nullable().optional(),
+    onboardingCompleted: z.boolean().nullable().optional(),
+    onboardingSkipped: z.boolean().optional(),
+    onboardingTeamMode: z.boolean().nullable().optional(),
+    onboardingUseCases: z.array(z.string()).nullable().optional(),
+    premiumStatus: z.enum([
+        'not_premium',
+        'current_personal_plan',
+        'legacy_personal_plan',
+        'teams_business_member',
+    ]),
+    premiumUntil: z.string().nullable(),
+    rambleSessionsUsage: z
+        .object({
+        currentCount: z.number().int(),
+        limit: z.number().int(),
+        remaining: z.number().int(),
+        resetDate: z.string(),
+    })
+        .nullable()
+        .optional(),
+    shareLimit: z.number().int(),
+    sortOrder: z.number().int(),
+    startDay: z.number().int(),
+    startPage: z.string(),
+    themeId: z.string(),
+    timeFormat: z.number().int(),
+    token: z.string(),
+    tzInfo: TzInfoSchema,
+    uniquePrefix: z.number().int(),
+    verificationStatus: z.string(),
+    websocketUrl: z.string(),
+    weekendStartDay: z.number().int(),
+    weeklyGoal: z.number().int(),
+})
+    .passthrough();

package/dist/esm/types/sync/resources/view-options.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+const ViewTypeSchema = z.enum([
+    'TODAY',
+    'UPCOMING',
+    'PROJECT',
+    'LABEL',
+    'FILTER',
+    'WORKSPACE_FILTER',
+    'SEARCH',
+    'TEMPLATE_PREVIEW',
+    'TASK_DETAIL',
+    'AUTOMATION',
+    'ASSIGNED',
+    'OVERDUE',
+    'WORKSPACE_OVERVIEW',
+]);
+const ViewModeSchema = z.enum(['LIST', 'BOARD', 'CALENDAR']);
+const GroupedBySchema = z
+    .enum([
+    'ASSIGNEE',
+    'ADDED_DATE',
+    'DUE_DATE',
+    'DEADLINE',
+    'LABEL',
+    'PRIORITY',
+    'PROJECT',
+    'WORKSPACE',
+])
+    .nullable();
+const SortedBySchema = z
+    .enum([
+    'MANUAL',
+    'ALPHABETICALLY',
+    'ASSIGNEE',
+    'DUE_DATE',
+    'DEADLINE',
+    'ADDED_DATE',
+    'PRIORITY',
+    'PROJECT',
+    'WORKSPACE',
+])
+    .nullable();
+const SortOrderSchema = z.enum(['ASC', 'DESC']).nullable();
+const CalendarSettingsSchema = z
+    .object({
+    layout: z.enum(['WEEK', 'MONTH']).optional(),
+})
+    .passthrough();
+export const ViewOptionsSchema = z
+    .object({
+    viewType: ViewTypeSchema,
+    objectId: z.string().optional(),
+    groupedBy: GroupedBySchema.optional(),
+    filteredBy: z.string().nullable().optional(),
+    viewMode: ViewModeSchema.optional(),
+    showCompletedTasks: z.boolean().optional(),
+    sortedBy: SortedBySchema.optional(),
+    sortOrder: SortOrderSchema.optional(),
+})
+    .passthrough();
+export const ProjectViewOptionsDefaultsSchema = z
+    .object({
+    projectId: z.string(),
+    viewMode: ViewModeSchema.nullable().optional(),
+    groupedBy: GroupedBySchema.optional(),
+    sortedBy: SortedBySchema.optional(),
+    sortOrder: SortOrderSchema.optional(),
+    showCompletedTasks: z.boolean().optional(),
+    filteredBy: z.string().nullable().optional(),
+    calendarSettings: CalendarSettingsSchema.nullable().optional(),
+})
+    .passthrough();

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export const WorkspaceFilterSchema = z
+    .object({
+    id: z.string(),
+    workspaceId: z.string(),
+    name: z.string(),
+    query: z.string(),
+    color: z.string(),
+    itemOrder: z.number().int(),
+    isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
+    isFrozen: z.boolean(),
+    creatorUid: z.string(),
+    updaterUid: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+})
+    .passthrough();

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export const WorkspaceGoalMilestoneSchema = z
+    .object({
+    id: z.string(),
+    title: z.string(),
+    isCompleted: z.boolean(),
+})
+    .passthrough();
+export const WorkspaceGoalProgressSchema = z
+    .object({
+    completedItems: z.number().int(),
+    totalItems: z.number().int(),
+})
+    .passthrough();
+export const WorkspaceGoalSchema = z
+    .object({
+    id: z.string(),
+    workspaceId: z.string(),
+    title: z.string(),
+    description: z.string().nullable(),
+    deadline: z.string().nullable(),
+    isDeleted: z.boolean(),
+    projectIds: z.array(z.string()),
+    progress: WorkspaceGoalProgressSchema.nullable(),
+    creatorUid: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+})
+    .passthrough();

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { WorkspaceRoleSchema, WorkspacePlanSchema, WorkspaceLimitsSchema, WorkspacePropertiesSchema, } from '../../entities.js';
+/**
+ * Sync API workspace resource.
+ *
+ * This is a superset of the REST `WorkspaceSchema` — the Sync API returns
+ * additional fields like description, isDeleted, isCollapsed, member counts,
+ * domain settings, and sorting preferences.
+ */
+export const SyncWorkspaceSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    logoBig: z.string().optional(),
+    logoMedium: z.string().optional(),
+    logoSmall: z.string().optional(),
+    logoS640: z.string().optional(),
+    creatorId: z.string(),
+    createdAt: z.string(),
+    isDeleted: z.boolean(),
+    isCollapsed: z.boolean(),
+    role: WorkspaceRoleSchema,
+    plan: WorkspacePlanSchema,
+    limits: WorkspaceLimitsSchema,
+    inviteCode: z.string().nullable().optional(),
+    isLinkSharingEnabled: z.boolean().nullable().optional(),
+    isGuestAllowed: z.boolean().nullable().optional(),
+    currentActiveProjects: z.number().nullable(),
+    currentMemberCount: z.number().nullable(),
+    currentTemplateCount: z.number().nullable(),
+    pendingInvitations: z.array(z.string()).nullable().optional(),
+    domainName: z.string().optional(),
+    domainDiscovery: z.boolean().optional(),
+    restrictEmailDomains: z.boolean().optional(),
+    adminSortingApplied: z.boolean(),
+    projectSortPreference: z.string().optional(),
+    defaultCollaborators: z
+        .object({
+        predefinedGroupIds: z.array(z.string()),
+        userIds: z.array(z.number()),
+    })
+        .optional(),
+    properties: WorkspacePropertiesSchema.optional(),
+})
+    .passthrough();

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

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

package/dist/esm/utils/index.js

@@ -1,3 +1,4 @@
 export * from './colors.js';
 export * from './sanitization.js';
 export { getTaskUrl, getProjectUrl, getSectionUrl } from './url-helpers.js';
+export { createCommand } from './sync-helpers.js';

package/dist/esm/utils/multipart-upload.js

@@ -1,6 +1,3 @@
-import FormData from 'form-data';
-import { createReadStream } from 'fs';
-import { basename } from 'path';
 import { fetchWithRetry } from './fetch-with-retry.js';
 /**
  * Helper function to determine content-type from filename extension.
@@ -31,11 +28,13 @@ function getContentTypeFromFileName(fileName) {
  * This is a shared utility for uploading files to Todoist endpoints that require
  * multipart/form-data content type (e.g., file uploads, workspace logo uploads).
  *
+ * Supports both browser (Blob/File) and Node.js (Buffer/ReadableStream/path) environments.
+ *
  * @param baseUrl - The base API URL (e.g., https://api.todoist.com/api/v1/)
  * @param authToken - The authentication token
  * @param endpoint - The relative endpoint path (e.g., 'uploads', 'workspaces/logo')
- * @param file - The file content (Buffer, ReadableStream, or file system path)
- * @param fileName - Optional file name (required for Buffer/Stream, optional for paths)
+ * @param file - The file content (Blob/File for browser, or Buffer/ReadableStream/path for Node)
+ * @param fileName - Optional file name (required for Buffer/Stream, optional for paths and File objects)
  * @param additionalFields - Additional form fields to include (e.g., project_id, workspace_id)
  * @param requestId - Optional request ID for idempotency
  * @returns The response data from the server
@@ -66,52 +65,74 @@ function getContentTypeFromFileName(fileName) {
  */
 export async function uploadMultipartFile(args) {
     const { baseUrl, authToken, endpoint, file, fileName, additionalFields, requestId, customFetch, } = args;
-    const form = new FormData();
-    // Determine file type and add to form data
-    if (typeof file === 'string') {
-        // File path - create read stream
-        const filePath = file;
-        const resolvedFileName = fileName || basename(filePath);
-        form.append('file', createReadStream(filePath), resolvedFileName);
+    // Build the full URL
+    const url = `${baseUrl}${endpoint}`;
+    let body;
+    const headers = {
+        Authorization: `Bearer ${authToken}`,
+    };
+    if (requestId) {
+        headers['X-Request-Id'] = requestId;
     }
-    else if (Buffer.isBuffer(file)) {
-        // Buffer - require fileName
-        if (!fileName) {
-            throw new Error('fileName is required when uploading from a Buffer');
+    if (file instanceof Blob) {
+        // Browser path: use native FormData
+        const form = new globalThis.FormData();
+        const resolvedFileName = fileName || (file instanceof File ? file.name : undefined) || 'upload';
+        form.append('file', file, resolvedFileName);
+        for (const [key, value] of Object.entries(additionalFields)) {
+            if (value !== undefined && value !== null) {
+                form.append(key, value.toString());
+            }
         }
-        // Detect content-type from filename extension
-        const contentType = getContentTypeFromFileName(fileName);
-        form.append('file', file, {
-            filename: fileName,
-            contentType: contentType,
-        });
+        // Don't set Content-Type — let fetch set it with the correct multipart boundary
+        body = form;
     }
     else {
-        // Stream - require fileName
-        if (!fileName) {
-            throw new Error('fileName is required when uploading from a stream');
+        // Node path: dynamically import Node-only modules
+        const [FormDataModule, fsModule, pathModule] = await Promise.all([
+            import('form-data'),
+            import('fs'),
+            import('path'),
+        ]);
+        const FormData = FormDataModule.default;
+        const form = new FormData();
+        if (typeof file === 'string') {
+            // File path - create read stream
+            const resolvedFileName = fileName || pathModule.basename(file);
+            form.append('file', fsModule.createReadStream(file), resolvedFileName);
         }
-        form.append('file', file, fileName);
-    }
-    // Add additional fields to the form
-    for (const [key, value] of Object.entries(additionalFields)) {
-        if (value !== undefined && value !== null) {
-            form.append(key, value.toString());
+        else if (Buffer.isBuffer(file)) {
+            // Buffer - require fileName
+            if (!fileName) {
+                throw new Error('fileName is required when uploading from a Buffer');
+            }
+            const contentType = getContentTypeFromFileName(fileName);
+            form.append('file', file, {
+                filename: fileName,
+                contentType: contentType,
+            });
         }
-    }
-    // Build the full URL
-    const url = `${baseUrl}${endpoint}`;
-    // Prepare headers
-    const headers = Object.assign({ Authorization: `Bearer ${authToken}` }, form.getHeaders());
-    if (requestId) {
-        headers['X-Request-Id'] = requestId;
+        else {
+            // Stream - require fileName
+            if (!fileName) {
+                throw new Error('fileName is required when uploading from a stream');
+            }
+            form.append('file', file, fileName);
+        }
+        for (const [key, value] of Object.entries(additionalFields)) {
+            if (value !== undefined && value !== null) {
+                form.append(key, value.toString());
+            }
+        }
+        Object.assign(headers, form.getHeaders());
+        body = form;
     }
     // Make the request using fetch
     const response = await fetchWithRetry({
         url,
         options: {
             method: 'POST',
-            body: form, // FormData from 'form-data' package is compatible with fetch
+            body,
             headers,
             timeout: 30000, // 30 second timeout for file uploads
         },

package/dist/esm/utils/sync-helpers.js

@@ -0,0 +1,19 @@
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Creates a strongly-typed Sync API command with an auto-generated UUID.
+ *
+ * @param type - The command type (e.g. `'item_add'`, `'project_update'`).
+ * @param args - The command arguments, constrained by the command type.
+ * @param tempId - Optional temporary ID for referencing the created resource in subsequent commands.
+ * @returns A fully formed `SyncCommand` ready to include in a sync request.
+ *
+ * @example
+ * ```typescript
+ * const cmd = createCommand('item_add', { content: 'Buy milk', priority: 2 })
+ * // cmd.type === 'item_add'
+ * // cmd.args is typed as TaskAddArgs
+ * ```
+ */
+export function createCommand(type, args, tempId) {
+    return Object.assign({ type, uuid: uuidv4(), args: args }, (tempId !== undefined ? { tempId } : {}));
+}

package/dist/esm/utils/validators.js

@@ -1,10 +1,14 @@
 import { AttachmentSchema, SectionSchema, LabelSchema, CommentSchema, UserSchema, CurrentUserSchema, TaskSchema, PersonalProjectSchema, WorkspaceProjectSchema, ProductivityStatsSchema, ActivityEventSchema, WorkspaceUserSchema, WorkspaceInvitationSchema, WorkspacePlanDetailsSchema, JoinWorkspaceResultSchema, WorkspaceSchema, } from '../types/entities.js';
-export function validateTask(input) {
-    return TaskSchema.parse(input);
+import { FilterSchema, CollaboratorSchema, CollaboratorStateSchema, FolderSchema, NoteSchema, TooltipsSchema, WorkspaceFilterSchema, WorkspaceGoalSchema, CalendarSchema, CalendarAccountSchema, ReminderSchema, CompletedInfoSchema, ViewOptionsSchema, ProjectViewOptionsDefaultsSchema, UserPlanLimitsSchema, LiveNotificationSchema, SyncWorkspaceSchema, SyncUserSchema, UserSettingsSchema, SuggestionSchema, } from '../types/sync/resources/index.js';
+function createValidator(schema) {
+    return (input) => schema.parse(input);
 }
-export function validateTaskArray(input) {
-    return input.map(validateTask);
+function createArrayValidator(validateItem) {
+    return (input) => input.map(validateItem);
 }
+// Entity validators
+export const validateTask = createValidator(TaskSchema);
+export const validateTaskArray = createArrayValidator(validateTask);
 /**
  * Type guard to check if a project is a workspace project.
  * @param project The project to check
@@ -35,69 +39,66 @@ export function validateProject(input) {
 export function validateProjectArray(input) {
     return input.map(validateProject);
 }
-export function validateSection(input) {
-    return SectionSchema.parse(input);
-}
-export function validateSectionArray(input) {
-    return input.map(validateSection);
-}
-export function validateLabel(input) {
-    return LabelSchema.parse(input);
-}
-export function validateLabelArray(input) {
-    return input.map(validateLabel);
-}
-export function validateComment(input) {
-    return CommentSchema.parse(input);
-}
-export function validateCommentArray(input) {
-    return input.map(validateComment);
-}
-export function validateUser(input) {
-    return UserSchema.parse(input);
-}
-export function validateUserArray(input) {
-    return input.map(validateUser);
-}
-export function validateProductivityStats(input) {
-    return ProductivityStatsSchema.parse(input);
-}
-export function validateCurrentUser(input) {
-    return CurrentUserSchema.parse(input);
-}
-export function validateActivityEvent(input) {
-    return ActivityEventSchema.parse(input);
-}
-export function validateActivityEventArray(input) {
-    return input.map(validateActivityEvent);
-}
-export function validateAttachment(input) {
-    return AttachmentSchema.parse(input);
-}
-export function validateWorkspaceUser(input) {
-    return WorkspaceUserSchema.parse(input);
-}
+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 function validateWorkspaceInvitation(input) {
-    return WorkspaceInvitationSchema.parse(input);
-}
-export function validateWorkspaceInvitationArray(input) {
-    return input.map(validateWorkspaceInvitation);
-}
-export function validateWorkspacePlanDetails(input) {
-    return WorkspacePlanDetailsSchema.parse(input);
-}
-export function validateJoinWorkspaceResult(input) {
-    return JoinWorkspaceResultSchema.parse(input);
-}
-export function validateWorkspace(input) {
-    return WorkspaceSchema.parse(input);
-}
-export function validateWorkspaceArray(input) {
-    return input.map(validateWorkspace);
-}
+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);
+// 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 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);