@todoist/sdk 0.0.0-stage → 18.0.0

package/dist/esm/utils/task-sorting.js

@@ -0,0 +1,280 @@
+/** Todoist's default task-ordering hierarchies. */
+export const DEFAULT_TASK_ORDERS = ['PRIORITY_FIRST', 'DATE_FIRST'];
+const DEFAULT_TIMEZONE = 'UTC';
+const DEFAULT_LOCALE = 'en';
+const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const DATE_TIME_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?$/;
+const EXPLICIT_TIMEZONE_PATTERN = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+const DATE_TIME_FORMATTERS = new Map();
+function compareNumber(a, b) {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+function isValidDateParts(year, month, day) {
+    const date = new Date(0);
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCFullYear(year, month - 1, day);
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+function dateSortValue({ year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0, isAllDay = false, }) {
+    if (!isValidDateParts(year, month, day) ||
+        hour < 0 ||
+        hour > 23 ||
+        minute < 0 ||
+        minute > 59 ||
+        second < 0 ||
+        second > 59 ||
+        millisecond < 0 ||
+        millisecond > 999) {
+        return null;
+    }
+    return {
+        day: year * 10000 + month * 100 + day,
+        kind: isAllDay ? 0 : 1,
+        time: ((hour * 60 + minute) * 60 + second) * 1000 + millisecond,
+    };
+}
+function parseDateOnly(value) {
+    const match = DATE_ONLY_PATTERN.exec(value);
+    if (!match)
+        return null;
+    return dateSortValue({
+        year: Number(match[1]),
+        month: Number(match[2]),
+        day: Number(match[3]),
+        isAllDay: true,
+    });
+}
+function parseDateTimeComponents(value) {
+    var _a, _b;
+    const match = DATE_TIME_PATTERN.exec(value);
+    if (!match)
+        return null;
+    const milliseconds = Number(((_a = match[7]) !== null && _a !== void 0 ? _a : '').padEnd(3, '0').slice(0, 3));
+    const components = {
+        year: Number(match[1]),
+        month: Number(match[2]),
+        day: Number(match[3]),
+        hour: Number(match[4]),
+        minute: Number(match[5]),
+        second: Number((_b = match[6]) !== null && _b !== void 0 ? _b : 0),
+        millisecond: milliseconds,
+    };
+    return dateSortValue(components) === null ? null : components;
+}
+function createDateTimeFormatter(timezone, fallback) {
+    const cached = DATE_TIME_FORMATTERS.get(timezone);
+    if (cached)
+        return cached;
+    try {
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone: timezone,
+            calendar: 'iso8601',
+            numberingSystem: 'latn',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hourCycle: 'h23',
+        });
+        DATE_TIME_FORMATTERS.set(timezone, formatter);
+        return formatter;
+    }
+    catch (_a) {
+        return fallback !== null && fallback !== void 0 ? fallback : createDateTimeFormatter(DEFAULT_TIMEZONE);
+    }
+}
+function componentsAt(timestamp, formatter) {
+    const parts = formatter.formatToParts(new Date(timestamp));
+    function part(type) {
+        var _a;
+        return Number((_a = parts.find((entry) => entry.type === type)) === null || _a === void 0 ? void 0 : _a.value);
+    }
+    return {
+        year: part('year'),
+        month: part('month'),
+        day: part('day'),
+        hour: part('hour'),
+        minute: part('minute'),
+        second: part('second'),
+        millisecond: new Date(timestamp).getUTCMilliseconds(),
+    };
+}
+function componentsAsUtcTimestamp({ year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0, }) {
+    const date = new Date(0);
+    date.setUTCFullYear(year, month - 1, day);
+    date.setUTCHours(hour, minute, second, millisecond);
+    return date.getTime();
+}
+/** Resolves a zoned wall clock to an instant, including daylight-saving offsets. */
+function timestampForWallClock(components, formatter) {
+    const target = componentsAsUtcTimestamp(components);
+    let timestamp = target;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const adjustment = target - componentsAsUtcTimestamp(componentsAt(timestamp, formatter));
+        if (adjustment === 0)
+            return timestamp;
+        timestamp += adjustment;
+    }
+    return null;
+}
+function dateSortValueAt(timestamp, formatter) {
+    const value = dateSortValue(componentsAt(timestamp, formatter));
+    return value ? Object.assign(Object.assign({}, value), { time: timestamp }) : null;
+}
+function parseFixedDateTime(value, formatter) {
+    if (parseDateTimeComponents(value.replace(EXPLICIT_TIMEZONE_PATTERN, '')) === null)
+        return null;
+    const timestamp = Date.parse(value);
+    return Number.isNaN(timestamp) ? null : dateSortValueAt(timestamp, formatter);
+}
+function parseZonedFloatingDateTime(value, sourceFormatter, accountFormatter) {
+    const components = parseDateTimeComponents(value);
+    if (!components)
+        return null;
+    const timestamp = timestampForWallClock(components, sourceFormatter);
+    return timestamp === null ? null : dateSortValueAt(timestamp, accountFormatter);
+}
+function parseTaskDate(value, formatter, timezone) {
+    var _a;
+    return ((_a = parseDateOnly(value)) !== null && _a !== void 0 ? _a : (EXPLICIT_TIMEZONE_PATTERN.test(value)
+        ? parseFixedDateTime(value, formatter)
+        : parseZonedFloatingDateTime(value, timezone ? createDateTimeFormatter(timezone, formatter) : formatter, formatter)));
+}
+function compareNullable(a, b, compare) {
+    if (a === null || b === null) {
+        if (a === b)
+            return 0;
+        return a === null ? 1 : -1;
+    }
+    return compare(a, b);
+}
+function compareDateValues(left, right) {
+    return (compareNumber(left.day, right.day) ||
+        compareNumber(left.kind, right.kind) ||
+        compareNumber(left.time, right.time));
+}
+function compareDate(a, b) {
+    return compareNullable(a, b, compareDateValues);
+}
+function compareOptionalNumber(a, b) {
+    return compareNullable(a, b, compareNumber);
+}
+function compareOptionalText(a, b, collator) {
+    return compareNullable(a, b, (left, right) => collator.compare(left, right));
+}
+function prepareTasks(tasks, context, { formatter, resolveAssignee }) {
+    return tasks.map((task, index) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const due = task.due
+            ? parseTaskDate((_a = task.due.datetime) !== null && _a !== void 0 ? _a : task.due.date, formatter, task.due.timezone)
+            : null;
+        const deadline = task.deadline ? parseTaskDate(task.deadline.date, formatter) : null;
+        return {
+            task,
+            index,
+            due,
+            deadline,
+            schedule: due !== null && due !== void 0 ? due : deadline,
+            added: task.addedAt && !Number.isNaN(task.addedAt.getTime())
+                ? task.addedAt.getTime()
+                : null,
+            project: (_c = (_b = context.projectOrder) === null || _b === void 0 ? void 0 : _b.get(task.projectId)) !== null && _c !== void 0 ? _c : null,
+            workspace: (_e = (_d = context.workspaceOrder) === null || _d === void 0 ? void 0 : _d.get(task.projectId)) !== null && _e !== void 0 ? _e : null,
+            assignee: resolveAssignee ? ((_g = (_f = context.assigneeName) === null || _f === void 0 ? void 0 : _f.call(context, task)) !== null && _g !== void 0 ? _g : null) : null,
+        };
+    });
+}
+function comparePriorityFirst(a, b) {
+    const common = compareNumber(b.task.priority, a.task.priority) ||
+        compareDate(a.due, b.due) ||
+        compareDate(a.deadline, b.deadline);
+    if (common !== 0)
+        return common;
+    const project = compareOptionalNumber(a.project, b.project);
+    if (project !== 0)
+        return project;
+    if (a.task.projectId === b.task.projectId) {
+        return compareNumber(a.task.childOrder, b.task.childOrder);
+    }
+    return 0;
+}
+function compareDateFirst(a, b) {
+    return (compareDate(a.schedule, b.schedule) ||
+        compareNumber(b.task.priority, a.task.priority) ||
+        compareDate(a.deadline, b.deadline) ||
+        compareNumber(a.task.dayOrder, b.task.dayOrder) ||
+        compareOptionalNumber(a.added, b.added));
+}
+function compareDefault(a, b, defaultOrder) {
+    return defaultOrder === 'DATE_FIRST' ? compareDateFirst(a, b) : comparePriorityFirst(a, b);
+}
+function comparePrimary({ sortedBy, a, b, collator, }) {
+    switch (sortedBy) {
+        case 'ALPHABETICALLY':
+            return collator.compare(a.task.content, b.task.content);
+        case 'ASSIGNEE':
+            return compareOptionalText(a.assignee, b.assignee, collator);
+        case 'DUE_DATE':
+            return compareDate(a.due, b.due);
+        case 'DEADLINE':
+            return compareDate(a.deadline, b.deadline);
+        case 'ADDED_DATE':
+            return compareOptionalNumber(a.added, b.added);
+        case 'PRIORITY':
+            return compareNumber(a.task.priority, b.task.priority);
+        case 'PROJECT':
+            return compareOptionalNumber(a.project, b.project);
+        case 'WORKSPACE':
+            return compareOptionalNumber(a.workspace, b.workspace);
+        default:
+            // MANUAL, LABEL, and fields added after this SDK version keep the default order.
+            return 0;
+    }
+}
+function defaultSortOrder(sortedBy) {
+    return sortedBy === 'PRIORITY' ? 'DESC' : 'ASC';
+}
+/**
+ * Sorts the supplied tasks using Todoist view-ordering rules.
+ *
+ * The function performs no I/O and always returns a new array. Exact project,
+ * workspace, assignee, localized text, and due-time ordering requires the
+ * corresponding context. Callers must sort each independent view section or
+ * group separately and preserve any subtask structure they render.
+ *
+ * This function sorts only the tasks supplied to it. Fetch every page first
+ * when globally correct ordering is required for a paginated query.
+ *
+ * @see isDateDrivenQuery
+ */
+export function sortTasks(tasks, options, context = {}) {
+    var _a, _b, _c;
+    const locale = Array.isArray(context.locale)
+        ? [...context.locale]
+        : ((_a = context.locale) !== null && _a !== void 0 ? _a : DEFAULT_LOCALE);
+    const collator = new Intl.Collator(locale, { sensitivity: 'base', numeric: true });
+    const formatter = createDateTimeFormatter((_b = context.timezone) !== null && _b !== void 0 ? _b : DEFAULT_TIMEZONE);
+    const sortedBy = options.sortedBy;
+    const prepared = prepareTasks(tasks, context, {
+        formatter,
+        resolveAssignee: sortedBy === 'ASSIGNEE',
+    });
+    const direction = sortedBy && sortedBy !== 'MANUAL' ? ((_c = options.sortOrder) !== null && _c !== void 0 ? _c : defaultSortOrder(sortedBy)) : null;
+    const directionMultiplier = direction === 'DESC' ? -1 : 1;
+    return prepared
+        .sort((a, b) => {
+        if (sortedBy && sortedBy !== 'MANUAL') {
+            const primary = comparePrimary({ sortedBy, a, b, collator }) * directionMultiplier;
+            if (primary !== 0)
+                return primary;
+        }
+        return compareDefault(a, b, options.defaultOrder) || compareNumber(a.index, b.index);
+    })
+        .map(({ task }) => task);
+}

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

@@ -0,0 +1,54 @@
+const UNCOMPLETABLE_PREFIX = '* ';
+/**
+ * Adds the uncompletable prefix (* ) to task content if not already present
+ * @param content - The task content
+ * @returns Content with uncompletable prefix added
+ */
+export function addUncompletablePrefix(content) {
+    if (content.startsWith(UNCOMPLETABLE_PREFIX)) {
+        return content;
+    }
+    return UNCOMPLETABLE_PREFIX + content;
+}
+/**
+ * Removes the uncompletable prefix (* ) from task content if present
+ * @param content - The task content
+ * @returns Content with uncompletable prefix removed
+ */
+export function removeUncompletablePrefix(content) {
+    if (content.startsWith(UNCOMPLETABLE_PREFIX)) {
+        return content.slice(UNCOMPLETABLE_PREFIX.length);
+    }
+    return content;
+}
+/**
+ * Checks if task content has the uncompletable prefix (* )
+ * @param content - The task content
+ * @returns True if content starts with uncompletable prefix
+ */
+export function hasUncompletablePrefix(content) {
+    return content.startsWith(UNCOMPLETABLE_PREFIX);
+}
+/**
+ * Processes task content based on isUncompletable flag, with content prefix taking precedence
+ * @param content - The original task content
+ * @param isUncompletable - Optional flag to make task uncompletable
+ * @returns Processed content
+ *
+ * Logic:
+ * - If content already has * prefix, task is uncompletable regardless of flag
+ * - If content doesn't have * prefix and isUncompletable is true, add the prefix
+ * - If isUncompletable is undefined or false (and no prefix), leave content unchanged
+ */
+export function processTaskContent(content, isUncompletable) {
+    // Content prefix takes precedence - if already has prefix, keep it
+    if (hasUncompletablePrefix(content)) {
+        return content;
+    }
+    // If content doesn't have prefix and user wants uncompletable, add it
+    if (isUncompletable === true) {
+        return addUncompletablePrefix(content);
+    }
+    // Otherwise, leave content unchanged
+    return content;
+}

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

@@ -0,0 +1,196 @@
+import { LinkEnvironment } from '@doist/sdk-kmp/common';
+import { parseTodoistLink, todoistFilterUrl, todoistLabelUrl, todoistProjectCommentsUrl, todoistProjectCommentUrl, todoistProjectUrl, todoistSectionUrl, todoistTaskCommentsUrl, todoistTaskCommentUrl, todoistTaskUrl, todoistWorkspaceFilterUrl, todoistWorkspaceUrl, } from '@doist/sdk-kmp/todoist';
+import { TODOIST_WEB_URI } from '../consts/endpoints.js';
+/**
+ * Formats a Date object to YYYY-MM-DD string format.
+ *
+ * @internal
+ * @param date The Date object to format.
+ * @returns The formatted date string in YYYY-MM-DD format.
+ */
+export function formatDateToYYYYMMDD(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+/**
+ * Builds a URL, falling back to a bare-id URL when the link builder rejects the
+ * given id. These helpers are called while parsing API responses, so generating
+ * a URL must never fail the parse.
+ *
+ * @param build Builds the URL.
+ * @param fallbackPath The path to fall back to, relative to the Todoist web app.
+ * @returns The built URL, or a bare-id URL if the id was rejected.
+ */
+function buildUrl(build, fallbackPath) {
+    try {
+        return build();
+    }
+    catch (_a) {
+        return `${TODOIST_WEB_URI}/${fallbackPath}`;
+    }
+}
+/**
+ * Generate the URL for a given task.
+ *
+ * @param taskId The ID of the task.
+ * @param content The content of the task.
+ * @returns The URL string for the task view.
+ */
+export function getTaskUrl(taskId, content) {
+    return buildUrl(() => todoistTaskUrl(taskId, content !== null && content !== void 0 ? content : '', LinkEnvironment.Production), `task/${taskId}`);
+}
+/**
+ * Generate the URL for a given project.
+ *
+ * @param projectId The ID of the project.
+ * @param name The name of the project.
+ * @returns The URL string for the project view.
+ */
+export function getProjectUrl(projectId, name) {
+    return buildUrl(() => todoistProjectUrl(projectId, name !== null && name !== void 0 ? name : '', LinkEnvironment.Production), `project/${projectId}`);
+}
+/**
+ * Generate the URL for a given section.
+ *
+ * @param sectionId The ID of the section.
+ * @param name The name of the section.
+ * @returns The URL string for the section view.
+ */
+export function getSectionUrl(sectionId, name) {
+    return buildUrl(() => todoistSectionUrl(sectionId, name !== null && name !== void 0 ? name : '', LinkEnvironment.Production), `section/${sectionId}`);
+}
+/**
+ * Generate the URL for a given label.
+ *
+ * @param labelId The ID of the label.
+ * @param name The name of the label.
+ * @returns The URL string for the label view.
+ */
+export function getLabelUrl(labelId, name) {
+    return buildUrl(() => todoistLabelUrl(labelId, name !== null && name !== void 0 ? name : '', LinkEnvironment.Production), `label/${labelId}`);
+}
+/**
+ * Generate the URL for a given filter.
+ *
+ * @param filterId The ID of the filter.
+ * @param name The name of the filter.
+ * @returns The URL string for the filter view.
+ */
+export function getFilterUrl(filterId, name) {
+    return buildUrl(() => todoistFilterUrl(filterId, name !== null && name !== void 0 ? name : '', LinkEnvironment.Production), `filter/${filterId}`);
+}
+/**
+ * Generate the URL for a filter belonging to a workspace.
+ *
+ * @param workspaceId The ID of the workspace the filter belongs to.
+ * @param filterId The ID of the filter.
+ * @param name The name of the filter.
+ * @returns The URL string for the workspace filter view.
+ */
+export function getWorkspaceFilterUrl(workspaceId, filterId, name) {
+    return buildUrl(() => todoistWorkspaceFilterUrl(workspaceId, filterId, name !== null && name !== void 0 ? name : '', LinkEnvironment.Production), `${workspaceId}/filter/${filterId}`);
+}
+/**
+ * Generate the URL for a given workspace.
+ *
+ * @param workspaceId The ID of the workspace.
+ * @returns The URL string for the workspace view.
+ */
+export function getWorkspaceUrl(workspaceId) {
+    return buildUrl(() => todoistWorkspaceUrl(workspaceId, LinkEnvironment.Production), workspaceId);
+}
+/**
+ * Generate the URL for the comments on a given task.
+ *
+ * @param taskId The ID of the task.
+ * @param content The content of the task.
+ * @returns The URL string for the task's comments.
+ */
+export function getTaskCommentsUrl(taskId, content) {
+    return buildUrl(() => todoistTaskCommentsUrl(taskId, content !== null && content !== void 0 ? content : '', LinkEnvironment.Production), `task/${taskId}/comments`);
+}
+/**
+ * Generate the URL for the comments on a given project.
+ *
+ * @param projectId The ID of the project.
+ * @param name The name of the project.
+ * @returns The URL string for the project's comments.
+ */
+export function getProjectCommentsUrl(projectId, name) {
+    return buildUrl(() => todoistProjectCommentsUrl(projectId, name !== null && name !== void 0 ? name : '', LinkEnvironment.Production), `project/${projectId}/comments`);
+}
+/**
+ * Generate the URL for a single comment on a given task.
+ *
+ * @param taskId The ID of the task.
+ * @param commentId The ID of the comment.
+ * @param content The content of the task.
+ * @returns The URL string for the comment.
+ */
+export function getTaskCommentUrl(taskId, commentId, content) {
+    return buildUrl(() => todoistTaskCommentUrl(taskId, content !== null && content !== void 0 ? content : '', commentId, LinkEnvironment.Production), `task/${taskId}#comment-${commentId}`);
+}
+/**
+ * Generate the URL for a single comment on a given project.
+ *
+ * @param projectId The ID of the project.
+ * @param commentId The ID of the comment.
+ * @param name The name of the project.
+ * @returns The URL string for the comment.
+ */
+export function getProjectCommentUrl(projectId, commentId, name) {
+    return buildUrl(() => todoistProjectCommentUrl(projectId, name !== null && name !== void 0 ? name : '', commentId, LinkEnvironment.Production), `project/${projectId}#comment-${commentId}`);
+}
+/** The kinds of Todoist entity a URL can point at. */
+export const TODOIST_LINK_TYPES = [
+    'task',
+    'project',
+    'filter',
+    'label',
+    'section',
+    'workspace',
+    'template',
+    'comment',
+    'label_by_name',
+];
+/**
+ * Maps the link parser's type names onto the types this SDK exposes. A name
+ * that is missing here is one this SDK does not know about, and is treated as
+ * an unrecognised URL rather than surfaced as a value outside the union.
+ */
+const LINK_TYPE_BY_PARSED_NAME = {
+    Task: 'task',
+    Project: 'project',
+    Filter: 'filter',
+    Label: 'label',
+    Section: 'section',
+    Workspace: 'workspace',
+    Template: 'template',
+    Comment: 'comment',
+    LabelByName: 'label_by_name',
+};
+/**
+ * Parse a Todoist URL into the entity it points at.
+ *
+ * @param url The URL to parse.
+ * @returns The entity the URL points at, or `null` if it is not a Todoist URL.
+ */
+export function parseTodoistUrl(url) {
+    var _a, _b;
+    const link = parseTodoistLink(url);
+    if (!link) {
+        return null;
+    }
+    const type = LINK_TYPE_BY_PARSED_NAME[link.type.name];
+    if (!type) {
+        return null;
+    }
+    return {
+        type,
+        id: link.id,
+        workspaceId: (_a = link.workspaceId) !== null && _a !== void 0 ? _a : null,
+        commentId: (_b = link.commentId) !== null && _b !== void 0 ? _b : null,
+    };
+}

package/dist/esm/utils/validators.js

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { ActivityEventSchema } from '../types/activity/types.js';
+import { AppSchema, AppWithUserCountSchema, AppSecretsSchema, AppVerificationTokenSchema, AppTestTokenSchema, AppDistributionTokenSchema, AppByDistributionTokenSchema, AppWebhookSchema, AppInstallationSchema, UserAuthorizationSchema, } from '../types/apps/types.js';
+import { BackupSchema } from '../types/backups/types.js';
+import { SubscriptionInfoSchema, ProPlanDetailsSchema, PricesResponseSchema, PricingResponseSchema, } from '../types/billing/types.js';
+import { AttachmentSchema, CommentSchema } from '../types/comments/types.js';
+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 { 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 { UiExtensionSchema } from '../types/ui-extensions/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, CalendarSchema, CalendarAccountSchema, ReminderSchema, LocationReminderSchema, CompletedInfoSchema, ViewOptionsSchema, ProjectViewOptionsDefaultsSchema, UserPlanLimitsSchema, LiveNotificationSchema, SyncWorkspaceSchema, SyncUserSchema, UserSettingsSchema, SuggestionSchema, } from '../types/sync/resources/index.js';
+function createValidator(schema) {
+    return {
+        validate: (input) => schema.parse(input),
+        validateArray: (input) => z.array(schema).parse(input),
+    };
+}
+const TMP_ID_MESSAGE = 'This looks like a client-side placeholder — wait for sync to complete before calling the API.';
+export const IdSchema = z
+    .string()
+    .min(1)
+    .refine((id) => !id.startsWith('tmp-'), { message: TMP_ID_MESSAGE });
+// Entity validators
+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 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 { 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);
+// Billing validators
+export const { validate: validateSubscriptionInfo } = createValidator(SubscriptionInfoSchema);
+export const { validate: validateProPlanDetails } = createValidator(ProPlanDetailsSchema);
+export const { validate: validatePrices } = createValidator(PricesResponseSchema);
+export const { validate: validatePricing } = createValidator(PricingResponseSchema);
+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: 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 SyncResponseSchema.parse(raw);
+}
+// App management validators
+export const { validate: validateApp, validateArray: validateAppArray } = createValidator(AppSchema);
+export const { validate: validateAppWithUserCount } = createValidator(AppWithUserCountSchema);
+export const { validate: validateAppSecrets } = createValidator(AppSecretsSchema);
+export const { validate: validateAppVerificationToken } = createValidator(AppVerificationTokenSchema);
+export const { validate: validateAppTestToken } = createValidator(AppTestTokenSchema);
+export const { validate: validateAppDistributionToken } = createValidator(AppDistributionTokenSchema);
+export const { validate: validateAppByDistributionToken } = createValidator(AppByDistributionTokenSchema);
+export const { validate: validateAppWebhook } = createValidator(AppWebhookSchema);
+export const { validate: validateAppInstallation, validateArray: validateAppInstallationArray } = createValidator(AppInstallationSchema);
+export const { validate: validateUserAuthorization, validateArray: validateUserAuthorizationArray, } = createValidator(UserAuthorizationSchema);
+export const { validate: validateUiExtension, validateArray: validateUiExtensionArray } = createValidator(UiExtensionSchema);

package/dist/esm/utils/view-options.js

@@ -0,0 +1,15 @@
+/** Returns whether saved view options are active rather than a deletion tombstone. */
+export function isActiveViewOption(options) {
+    return options.isDeleted !== true;
+}
+/** Finds the active saved options for one logical view. */
+export function findViewOptions(options, args) {
+    var _a;
+    const targetObjectId = (_a = args.objectId) !== null && _a !== void 0 ? _a : null;
+    return options.find((entry) => {
+        var _a;
+        return isActiveViewOption(entry) &&
+            ((_a = entry.objectId) !== null && _a !== void 0 ? _a : null) === targetObjectId &&
+            args.viewTypes.some((viewType) => viewType === entry.viewType);
+    });
+}