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

package/dist/esm/clients/id-mapping-client.js

@@ -0,0 +1,35 @@
+import { ENDPOINT_REST_ID_MAPPINGS, ENDPOINT_REST_MOVED_IDS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateIdMappingArray, validateMovedIdArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling ID-mapping endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public id-mapping method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class IdMappingClient extends BaseClient {
+    async getIdMappings(args) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_ID_MAPPINGS, args.objName, args.objIds.join(',')),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateIdMappingArray(response.data);
+    }
+    async getMovedIds(args) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_MOVED_IDS, args.objName),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args.oldIds ? { oldIds: args.oldIds.join(',') } : undefined,
+        });
+        return validateMovedIdArray(response.data);
+    }
+}

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

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { getProjectInsightsActivityStatsEndpoint, getProjectInsightsHealthAnalyzeEndpoint, getProjectInsightsHealthContextEndpoint, getProjectInsightsHealthEndpoint, getProjectInsightsProgressEndpoint, getWorkspaceInsightsEndpoint, } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { validateProjectActivityStats, validateProjectHealth, validateProjectHealthContext, validateProjectProgress, validateWorkspaceInsights, } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all insights-domain endpoints
+ * (project activity stats, health, progress, workspace insights).
+ *
+ * Instantiated by `TodoistApi`; every public insights method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class InsightsClient extends BaseClient {
+    async getProjectActivityStats(projectId, args = {}) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsActivityStatsEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign({ objectType: 'ITEM', eventType: 'COMPLETED' }, args),
+        });
+        return validateProjectActivityStats(response.data);
+    }
+    async getProjectHealth(projectId) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsHealthEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProjectHealth(response.data);
+    }
+    async getProjectHealthContext(projectId) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsHealthContextEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProjectHealthContext(response.data);
+    }
+    async getProjectProgress(projectId) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsProgressEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProjectProgress(response.data);
+    }
+    async getWorkspaceInsights(workspaceId, args = {}) {
+        z.string().parse(workspaceId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInsightsEndpoint(workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign(Object.assign({}, args), (args.projectIds ? { projectIds: args.projectIds.join(',') } : {})),
+        });
+        return validateWorkspaceInsights(response.data);
+    }
+    async analyzeProjectHealth(projectId, requestId) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsHealthAnalyzeEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateProjectHealth(response.data);
+    }
+}

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

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { ENDPOINT_REST_LABELS, ENDPOINT_REST_LABELS_SEARCH, ENDPOINT_REST_LABELS_SHARED, ENDPOINT_REST_LABELS_SHARED_REMOVE, ENDPOINT_REST_LABELS_SHARED_RENAME, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateLabel, validateLabelArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all label-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public label method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class LabelClient extends BaseClient {
+    async getLabel(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_LABELS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateLabel(response.data);
+    }
+    async getLabels(args = {}) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateLabelArray(results),
+            nextCursor,
+        };
+    }
+    async searchLabels(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS_SEARCH,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateLabelArray(results),
+            nextCursor,
+        };
+    }
+    async addLabel(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateLabel(response.data);
+    }
+    async updateLabel(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_LABELS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateLabel(response.data);
+    }
+    async deleteLabel(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_LABELS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getSharedLabels(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS_SHARED,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return { results, nextCursor };
+    }
+    async renameSharedLabel(args) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS_SHARED_RENAME,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return isSuccess(response);
+    }
+    async removeSharedLabel(args) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS_SHARED_REMOVE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return isSuccess(response);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { ENDPOINT_REST_PRODUCTIVITY } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { validateProductivityStats } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling the productivity-stats endpoint.
+ *
+ * Instantiated by `TodoistApi`; the public `getProductivityStats` method
+ * on `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class ProductivityClient extends BaseClient {
+    async getProductivityStats() {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PRODUCTIVITY,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProductivityStats(response.data);
+    }
+}

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

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+import { ENDPOINT_REST_PROJECTS, ENDPOINT_REST_PROJECTS_ARCHIVED, ENDPOINT_REST_PROJECTS_ARCHIVED_COUNT, ENDPOINT_REST_PROJECTS_MOVE_TO_PERSONAL, ENDPOINT_REST_PROJECTS_MOVE_TO_WORKSPACE, ENDPOINT_REST_PROJECTS_PERMISSIONS, ENDPOINT_REST_PROJECTS_SEARCH, ENDPOINT_REST_PROJECT_COLLABORATORS, ENDPOINT_REST_PROJECT_FULL, ENDPOINT_REST_PROJECT_JOIN, PROJECT_ARCHIVE, PROJECT_UNARCHIVE, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateCollaboratorArray, validateCollaboratorStateArray, validateCommentArray, validateFolder, validateNoteArray, validateProject, validateProjectArray, validateSectionArray, validateTaskArray, validateUserArray, validateWorkspaceProject, validateWorkspaceProjectArray, } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all project-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public project method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class ProjectClient extends BaseClient {
+    async getProject(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_PROJECTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProject(response.data);
+    }
+    async getProjects(args = {}) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PROJECTS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateProjectArray(results),
+            nextCursor,
+        };
+    }
+    async searchProjects(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PROJECTS_SEARCH,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateProjectArray(results),
+            nextCursor,
+        };
+    }
+    async getArchivedProjects(args = {}) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PROJECTS_ARCHIVED,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateProjectArray(results),
+            nextCursor,
+        };
+    }
+    async addProject(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PROJECTS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateProject(response.data);
+    }
+    async updateProject(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_PROJECTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateProject(response.data);
+    }
+    async deleteProject(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_PROJECTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async archiveProject(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_PROJECTS, id, PROJECT_ARCHIVE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateProject(response.data);
+    }
+    async unarchiveProject(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_PROJECTS, id, PROJECT_UNARCHIVE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateProject(response.data);
+    }
+    async moveProjectToWorkspace(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PROJECTS_MOVE_TO_WORKSPACE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateProject(response.data.project);
+    }
+    async moveProjectToPersonal(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PROJECTS_MOVE_TO_PERSONAL,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateProject(response.data.project);
+    }
+    async getArchivedProjectsCount(args = {}) {
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PROJECTS_ARCHIVED_COUNT,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return data;
+    }
+    async getProjectPermissions() {
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PROJECTS_PERMISSIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return data;
+    }
+    async getFullProject(id, args = {}) {
+        z.string().parse(id);
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_PROJECTS, id, ENDPOINT_REST_PROJECT_FULL),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            project: data.project ? validateProject(data.project) : null,
+            commentsCount: data.commentsCount,
+            tasks: validateTaskArray(data.tasks),
+            sections: validateSectionArray(data.sections),
+            collaborators: validateUserArray(data.collaborators),
+            notes: validateCommentArray(data.notes),
+        };
+    }
+    async joinProject(id, requestId) {
+        z.string().parse(id);
+        const { data } = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_PROJECTS, id, ENDPOINT_REST_PROJECT_JOIN),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return {
+            project: validateWorkspaceProject(data.project),
+            tasks: validateTaskArray(data.tasks),
+            sections: validateSectionArray(data.sections),
+            comments: validateNoteArray(data.comments),
+            collaborators: validateCollaboratorArray(data.collaborators),
+            collaboratorStates: validateCollaboratorStateArray(data.collaboratorStates),
+            folder: data.folder ? validateFolder(data.folder) : null,
+            subprojects: validateWorkspaceProjectArray(data.subprojects),
+        };
+    }
+    async getProjectCollaborators(projectId, args = {}) {
+        z.string().parse(projectId);
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_PROJECTS, projectId, ENDPOINT_REST_PROJECT_COLLABORATORS),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateUserArray(results),
+            nextCursor,
+        };
+    }
+}

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

@@ -0,0 +1,194 @@
+import { ENDPOINT_REST_LOCATION_REMINDERS, ENDPOINT_REST_REMINDERS } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { TodoistArgumentError, TodoistRequestError } from '../types/index.js';
+import { ReminderIdSchema, UpdateLocationReminderArgsSchema, UpdateReminderArgsSchema, } from '../types/reminders/index.js';
+import { ReminderTypeEnum } from '../types/sync/resources/reminders.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateLocationReminderArray, validateReminder, validateReminderArray, } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all reminder-domain endpoints
+ * (both time-based and location-based reminders).
+ *
+ * Instantiated by `TodoistApi`; every public reminder method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc. The time-vs-location 404 translation is preserved here so a
+ * caller who used the wrong endpoint gets a TodoistArgumentError
+ * pointing at the correct method, rather than a bare 404.
+ */
+export class ReminderClient extends BaseClient {
+    async getReminders(args = {}) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_REMINDERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateReminderArray(results),
+            nextCursor,
+        };
+    }
+    async getLocationReminders(args = {}) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LOCATION_REMINDERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateLocationReminderArray(results),
+            nextCursor,
+        };
+    }
+    async getReminder(id) {
+        ReminderIdSchema.parse(id);
+        try {
+            const response = await request({
+                httpMethod: 'GET',
+                baseUri: this.syncApiBase,
+                relativePath: generatePath(ENDPOINT_REST_REMINDERS, id),
+                apiToken: this.authToken,
+                customFetch: this.customFetch,
+            });
+            return validateReminder(response.data);
+        }
+        catch (error) {
+            if (!(error instanceof TodoistRequestError) || error.httpStatusCode !== 404) {
+                throw error;
+            }
+            throw new TodoistArgumentError(`Reminder ${id} was not found on the time-based reminder endpoint. If this is a location reminder, use getLocationReminder instead.`);
+        }
+    }
+    async getLocationReminder(id) {
+        ReminderIdSchema.parse(id);
+        try {
+            const response = await request({
+                httpMethod: 'GET',
+                baseUri: this.syncApiBase,
+                relativePath: generatePath(ENDPOINT_REST_LOCATION_REMINDERS, id),
+                apiToken: this.authToken,
+                customFetch: this.customFetch,
+            });
+            return validateReminder(response.data);
+        }
+        catch (error) {
+            if (!(error instanceof TodoistRequestError) || error.httpStatusCode !== 404) {
+                throw error;
+            }
+            throw new TodoistArgumentError(`Location reminder ${id} was not found on the location reminder endpoint. If this is a time-based reminder, use getReminder instead.`);
+        }
+    }
+    async addReminder(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_REMINDERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateReminder(response.data);
+    }
+    async addLocationReminder(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LOCATION_REMINDERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign(Object.assign({}, args), { reminderType: ReminderTypeEnum.Location }),
+            requestId: requestId,
+        });
+        return validateReminder(response.data);
+    }
+    async updateReminder(id, args, requestId) {
+        ReminderIdSchema.parse(id);
+        const payload = UpdateReminderArgsSchema.parse(args);
+        try {
+            const response = await request({
+                httpMethod: 'POST',
+                baseUri: this.syncApiBase,
+                relativePath: generatePath(ENDPOINT_REST_REMINDERS, id),
+                apiToken: this.authToken,
+                customFetch: this.customFetch,
+                payload,
+                requestId: requestId,
+            });
+            return validateReminder(response.data);
+        }
+        catch (error) {
+            if (!(error instanceof TodoistRequestError) || error.httpStatusCode !== 404) {
+                throw error;
+            }
+            throw new TodoistArgumentError(`Reminder ${id} was not found on the time-based reminder endpoint. If this is a location reminder, use updateLocationReminder instead.`);
+        }
+    }
+    async updateLocationReminder(id, args, requestId) {
+        ReminderIdSchema.parse(id);
+        const payload = UpdateLocationReminderArgsSchema.parse(args);
+        try {
+            const response = await request({
+                httpMethod: 'POST',
+                baseUri: this.syncApiBase,
+                relativePath: generatePath(ENDPOINT_REST_LOCATION_REMINDERS, id),
+                apiToken: this.authToken,
+                customFetch: this.customFetch,
+                payload,
+                requestId: requestId,
+            });
+            return validateReminder(response.data);
+        }
+        catch (error) {
+            if (!(error instanceof TodoistRequestError) || error.httpStatusCode !== 404) {
+                throw error;
+            }
+            throw new TodoistArgumentError(`Location reminder ${id} was not found on the location reminder endpoint. If this is a time-based reminder, use updateReminder instead.`);
+        }
+    }
+    async deleteReminder(id, requestId) {
+        ReminderIdSchema.parse(id);
+        try {
+            const response = await request({
+                httpMethod: 'DELETE',
+                baseUri: this.syncApiBase,
+                relativePath: generatePath(ENDPOINT_REST_REMINDERS, id),
+                apiToken: this.authToken,
+                customFetch: this.customFetch,
+                requestId: requestId,
+            });
+            return isSuccess(response);
+        }
+        catch (error) {
+            if (!(error instanceof TodoistRequestError) || error.httpStatusCode !== 404) {
+                throw error;
+            }
+            throw new TodoistArgumentError(`Reminder ${id} was not found on the time-based reminder endpoint. If this is a location reminder, use deleteLocationReminder instead.`);
+        }
+    }
+    async deleteLocationReminder(id, requestId) {
+        ReminderIdSchema.parse(id);
+        try {
+            const response = await request({
+                httpMethod: 'DELETE',
+                baseUri: this.syncApiBase,
+                relativePath: generatePath(ENDPOINT_REST_LOCATION_REMINDERS, id),
+                apiToken: this.authToken,
+                customFetch: this.customFetch,
+                requestId: requestId,
+            });
+            return isSuccess(response);
+        }
+        catch (error) {
+            if (!(error instanceof TodoistRequestError) || error.httpStatusCode !== 404) {
+                throw error;
+            }
+            throw new TodoistArgumentError(`Location reminder ${id} was not found on the location reminder endpoint. If this is a time-based reminder, use deleteReminder instead.`);
+        }
+    }
+}