@doist/todoist-sdk 9.1.0-next.1 → 9.1.0-next.2

package/dist/cjs/transport/sync-request.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performSyncRequest = performSyncRequest;
+const endpoints_1 = require("../consts/endpoints");
+const types_1 = require("../types");
+const sync_1 = require("../types/sync");
+const request_helpers_1 = require("../utils/request-helpers");
+const validators_1 = require("../utils/validators");
+const http_client_1 = require("./http-client");
+function serializeUserUpdateArgs(args) {
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, args), (0, request_helpers_1.spreadIfDefined)(args.dateFormat, (v) => ({
+        dateFormat: sync_1.DATE_FORMAT_TO_API[v],
+    }))), (0, request_helpers_1.spreadIfDefined)(args.timeFormat, (v) => ({
+        timeFormat: sync_1.TIME_FORMAT_TO_API[v],
+    }))), (0, request_helpers_1.spreadIfDefined)(args.startDay, (v) => ({
+        startDay: sync_1.DAY_OF_WEEK_TO_API[v],
+    }))), (0, request_helpers_1.spreadIfDefined)(args.nextWeek, (v) => ({
+        nextWeek: sync_1.DAY_OF_WEEK_TO_API[v],
+    })));
+}
+function serializeTaskUpdateDateCompleteArgs(args) {
+    return Object.assign(Object.assign(Object.assign({}, args), { isForward: args.isForward ? 1 : 0 }), (0, request_helpers_1.spreadIfDefined)(args.resetSubtasks, (v) => ({
+        resetSubtasks: v ? 1 : 0,
+    })));
+}
+function serializeUpdateGoalsArgs(args) {
+    return Object.assign(Object.assign(Object.assign({}, args), (0, request_helpers_1.spreadIfDefined)(args.vacationMode, (v) => ({ vacationMode: v ? 1 : 0 }))), (0, request_helpers_1.spreadIfDefined)(args.karmaDisabled, (v) => ({
+        karmaDisabled: v ? 1 : 0,
+    })));
+}
+function preprocessSyncCommands(commands) {
+    return commands.map((cmd) => {
+        if (cmd.type === 'user_update')
+            return Object.assign(Object.assign({}, cmd), { args: serializeUserUpdateArgs(cmd.args) });
+        if (cmd.type === 'item_update_date_complete')
+            return Object.assign(Object.assign({}, cmd), { args: serializeTaskUpdateDateCompleteArgs(cmd.args) });
+        if (cmd.type === 'update_goals')
+            return Object.assign(Object.assign({}, cmd), { args: serializeUpdateGoalsArgs(cmd.args) });
+        return cmd;
+    });
+}
+/**
+ * Makes a request to the Sync API and handles error checking.
+ *
+ * @param ctx - HTTP identity (auth token, sync API base URI, optional custom fetch).
+ * @param syncRequest - The sync request payload.
+ * @param options - Optional request identifier and commands flag.
+ * @returns The sync response data.
+ * @throws TodoistRequestError if sync status contains errors.
+ */
+async function performSyncRequest(ctx, syncRequest, options = {}) {
+    var _a;
+    const { requestId, hasSyncCommands = false } = options;
+    const processedRequest = ((_a = syncRequest.commands) === null || _a === void 0 ? void 0 : _a.length)
+        ? Object.assign(Object.assign({}, syncRequest), { commands: preprocessSyncCommands(syncRequest.commands) }) : syncRequest;
+    const response = await (0, http_client_1.request)({
+        httpMethod: 'POST',
+        baseUri: ctx.syncApiBase,
+        relativePath: endpoints_1.ENDPOINT_SYNC,
+        apiToken: ctx.authToken,
+        customFetch: ctx.customFetch,
+        payload: processedRequest,
+        requestId: requestId,
+        hasSyncCommands: hasSyncCommands,
+    });
+    // Check for sync errors and throw if any are found
+    if (response.data.syncStatus) {
+        Object.entries(response.data.syncStatus).forEach(([_, value]) => {
+            if (value === 'ok')
+                return;
+            throw new types_1.TodoistRequestError(value.error, value.httpCode, value.errorExtra);
+        });
+    }
+    return (0, validators_1.parseSyncResponse)(response.data);
+}

package/dist/cjs/types/goals/types.js

@@ -1,14 +1,41 @@
 "use strict";
+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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoalSchema = exports.GoalProgressSchema = exports.GOAL_OWNER_TYPES = void 0;
 const zod_1 = require("zod");
 /** Available goal owner types. */
 exports.GOAL_OWNER_TYPES = ['USER', 'WORKSPACE'];
-exports.GoalProgressSchema = zod_1.z.looseObject({
+/**
+ * Progress of a {@link Goal}.
+ *
+ * The REST API returns these counts under `total_item_count` / `completed_item_count`,
+ * reflecting the backend's generic "item" terminology. The SDK normalizes them to
+ * `totalTaskCount` / `completedTaskCount` so the public surface consistently speaks
+ * in "tasks" (matching the rest of the SDK). The `preprocess` step below performs
+ * that rename after the transport layer's snake_case → camelCase conversion — do not
+ * remove it without also changing the downstream field names.
+ */
+exports.GoalProgressSchema = zod_1.z.preprocess((raw) => {
+    if (raw === null || raw === undefined || typeof raw !== 'object' || Array.isArray(raw)) {
+        return raw;
+    }
+    const _a = raw, { totalItemCount, completedItemCount, totalTaskCount, completedTaskCount } = _a, rest = __rest(_a, ["totalItemCount", "completedItemCount", "totalTaskCount", "completedTaskCount"]);
+    return Object.assign(Object.assign({}, rest), { totalTaskCount: totalTaskCount !== null && totalTaskCount !== void 0 ? totalTaskCount : totalItemCount, completedTaskCount: completedTaskCount !== null && completedTaskCount !== void 0 ? completedTaskCount : completedItemCount });
+}, zod_1.z.looseObject({
     totalTaskCount: zod_1.z.number().int(),
     completedTaskCount: zod_1.z.number().int(),
     percentage: zod_1.z.number(),
-});
+}));
 exports.GoalSchema = zod_1.z.looseObject({
     id: zod_1.z.string(),
     ownerType: zod_1.z.enum(exports.GOAL_OWNER_TYPES),

package/dist/cjs/utils/headers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headersToRecord = headersToRecord;
+/**
+ * Converts a native Fetch `Headers` object into a plain `Record<string, string>`.
+ * Used when wrapping a native `fetch` response into the SDK's `FileResponse`
+ * shape (which expects headers as a plain record for symmetry with
+ * `CustomFetchResponse`).
+ */
+function headersToRecord(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}

package/dist/cjs/utils/request-helpers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePath = generatePath;
+exports.spreadIfDefined = spreadIfDefined;
+/**
+ * Joins path segments using `/` separator.
+ * @param segments A list of **valid** path segments.
+ * @returns A joined path.
+ */
+function generatePath(...segments) {
+    return segments.join('/');
+}
+/**
+ * Returns `fn(value)` spread into an object if `value` is defined, otherwise an empty object.
+ *
+ * Used to conditionally include a property on a payload object without
+ * resorting to mutation or ternary-built object literals.
+ */
+function spreadIfDefined(value, fn) {
+    return value !== undefined ? fn(value) : {};
+}

package/dist/esm/clients/activity-client.js

@@ -0,0 +1,59 @@
+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 { ENDPOINT_REST_ACTIVITIES } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { denormalizeObjectTypeFromApi, normalizeObjectEventTypeForApi, } from '../utils/activity-helpers.js';
+import { formatDateToYYYYMMDD } from '../utils/url-helpers.js';
+import { validateActivityEventArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling the activity-log endpoint.
+ *
+ * Instantiated by `TodoistApi`; the public `getActivityLogs` method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class ActivityClient extends BaseClient {
+    async getActivityLogs(args = {}) {
+        // Convert Date objects to YYYY-MM-DD strings
+        const dateFrom = args.dateFrom instanceof Date ? formatDateToYYYYMMDD(args.dateFrom) : args.dateFrom;
+        const dateTo = args.dateTo instanceof Date ? formatDateToYYYYMMDD(args.dateTo) : args.dateTo;
+        // Destructure out raw date, filter-type, and removed legacy fields so they don't leak into payload
+        const _a = args, { dateFrom: _dateFrom, dateTo: _dateTo, objectEventTypes, objectType: _objectType, eventType: _eventType, since: _since, until: _until } = _a, rest = __rest(_a, ["dateFrom", "dateTo", "objectEventTypes", "objectType", "eventType", "since", "until"]);
+        // Build normalized objectEventTypes for the API
+        let normalizedObjectEventTypes;
+        if (objectEventTypes !== undefined) {
+            const arr = Array.isArray(objectEventTypes) ? objectEventTypes : [objectEventTypes];
+            normalizedObjectEventTypes = arr.map(normalizeObjectEventTypeForApi);
+        }
+        const processedArgs = Object.assign(Object.assign(Object.assign(Object.assign({}, rest), (dateFrom !== undefined ? { dateFrom } : {})), (dateTo !== undefined ? { dateTo } : {})), (normalizedObjectEventTypes !== undefined
+            ? { objectEventTypes: normalizedObjectEventTypes }
+            : {}));
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_ACTIVITIES,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: processedArgs,
+        });
+        // Convert legacy API object types back to modern SDK types
+        const normalizedResults = results.map((event) => {
+            const normalizedType = denormalizeObjectTypeFromApi(event.objectType);
+            return Object.assign(Object.assign({}, event), { objectType: normalizedType || event.objectType });
+        });
+        return {
+            results: validateActivityEventArray(normalizedResults),
+            nextCursor,
+        };
+    }
+}

package/dist/esm/clients/backup-client.js

@@ -0,0 +1,61 @@
+import { ENDPOINT_REST_BACKUPS, ENDPOINT_REST_BACKUPS_DOWNLOAD } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { headersToRecord } from '../utils/headers.js';
+import { validateBackupArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling backup-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public backup method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class BackupClient extends BaseClient {
+    async getBackups(args = {}) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_BACKUPS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return validateBackupArray(response.data);
+    }
+    async downloadBackup(args) {
+        const url = `${this.syncApiBase}${ENDPOINT_REST_BACKUPS_DOWNLOAD}?file=${encodeURIComponent(args.file)}`;
+        const fetchOptions = {
+            headers: { Authorization: `Bearer ${this.authToken}` },
+        };
+        if (this.customFetch) {
+            const response = await this.customFetch(url, fetchOptions);
+            if (!response.ok) {
+                throw new Error(`Failed to download backup: ${response.status} ${response.statusText}`);
+            }
+            const text = await response.text();
+            const buffer = new TextEncoder().encode(text).buffer;
+            return {
+                ok: response.ok,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                text: () => Promise.resolve(text),
+                json: () => response.json(),
+                arrayBuffer: () => Promise.resolve(buffer),
+            };
+        }
+        const response = await fetch(url, fetchOptions);
+        if (!response.ok) {
+            throw new Error(`Failed to download backup: ${response.status} ${response.statusText}`);
+        }
+        return {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            headers: headersToRecord(response.headers),
+            text: () => response.text(),
+            json: () => response.json(),
+            arrayBuffer: () => response.arrayBuffer(),
+        };
+    }
+}

package/dist/esm/clients/base-client.js

@@ -0,0 +1,26 @@
+/**
+ * Internal base class for every domain sub-client (tasks, projects, …).
+ *
+ * Not exported from the package — sub-clients are an implementation detail
+ * of `TodoistApi`. Holds the three pieces of HTTP identity every sub-client
+ * needs and exposes a typed accessor to feed the Sync API helper.
+ *
+ * The constructor takes a {@link SyncRequestContext} — the same record
+ * shape used by `performSyncRequest` — so there is a single type describing
+ * "the HTTP identity an SDK component needs", not two types that must stay
+ * in sync.
+ */
+export class BaseClient {
+    constructor(context) {
+        this.authToken = context.authToken;
+        this.syncApiBase = context.syncApiBase;
+        this.customFetch = context.customFetch;
+    }
+    get syncContext() {
+        return {
+            authToken: this.authToken,
+            syncApiBase: this.syncApiBase,
+            customFetch: this.customFetch,
+        };
+    }
+}

package/dist/esm/clients/comment-client.js

@@ -0,0 +1,88 @@
+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 { ENDPOINT_REST_COMMENTS } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateComment, validateCommentArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all comment-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public comment method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class CommentClient extends BaseClient {
+    async getComments(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_COMMENTS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateCommentArray(results),
+            nextCursor,
+        };
+    }
+    async getComment(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_COMMENTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateComment(response.data);
+    }
+    async addComment(args, requestId) {
+        const { uidsToNotify } = args, rest = __rest(args, ["uidsToNotify"]);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_COMMENTS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign(Object.assign({}, rest), (uidsToNotify ? { uidsToNotify: uidsToNotify.join(',') } : {})),
+            requestId: requestId,
+        });
+        return validateComment(response.data);
+    }
+    async updateComment(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_COMMENTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateComment(response.data);
+    }
+    async deleteComment(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_COMMENTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}

package/dist/esm/clients/email-client.js

@@ -0,0 +1,39 @@
+import { ENDPOINT_REST_EMAILS } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling email-forwarding endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public email-forwarding method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class EmailClient extends BaseClient {
+    async getOrCreateEmailForwarding(args, requestId) {
+        const { data } = await request({
+            httpMethod: 'PUT',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_EMAILS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return data;
+    }
+    async disableEmailForwarding(args, requestId) {
+        const queryParams = new URLSearchParams({
+            obj_type: args.objType,
+            obj_id: args.objId,
+        });
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: `${ENDPOINT_REST_EMAILS}?${queryParams.toString()}`,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}

package/dist/esm/clients/folder-client.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { ENDPOINT_REST_FOLDERS } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateFolder, validateFolderArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all folder-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public folder method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class FolderClient extends BaseClient {
+    async getFolders(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_FOLDERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateFolderArray(results),
+            nextCursor,
+        };
+    }
+    async getFolder(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_FOLDERS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateFolder(response.data);
+    }
+    async addFolder(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_FOLDERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateFolder(response.data);
+    }
+    async updateFolder(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_FOLDERS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateFolder(response.data);
+    }
+    async deleteFolder(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_FOLDERS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}

package/dist/esm/clients/goals-client.js

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { ENDPOINT_REST_GOALS, ENDPOINT_REST_GOALS_SEARCH, GOAL_COMPLETE, GOAL_TASKS, GOAL_UNCOMPLETE, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateGoal, validateGoalArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all goal-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public goal method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class GoalsClient extends BaseClient {
+    async getGoals(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_GOALS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateGoalArray(results),
+            nextCursor,
+        };
+    }
+    async searchGoals(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_GOALS_SEARCH,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateGoalArray(results),
+            nextCursor,
+        };
+    }
+    async getGoal(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateGoal(response.data);
+    }
+    async addGoal(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_GOALS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async updateGoal(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async deleteGoal(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async completeGoal(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id, GOAL_COMPLETE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async uncompleteGoal(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id, GOAL_UNCOMPLETE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async linkTaskToGoal({ goalId, taskId }, requestId) {
+        z.string().parse(goalId);
+        z.string().parse(taskId);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, goalId, GOAL_TASKS),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: { itemId: taskId },
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async unlinkTaskFromGoal({ goalId, taskId }, requestId) {
+        z.string().parse(goalId);
+        z.string().parse(taskId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, goalId, GOAL_TASKS, taskId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}