@todoist/sdk 0.0.0-stage → 18.0.0

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

@@ -0,0 +1,384 @@
+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_WORKSPACES, ENDPOINT_WORKSPACE_INVITATIONS, ENDPOINT_WORKSPACE_INVITATIONS_ALL, ENDPOINT_WORKSPACE_INVITATIONS_DELETE, ENDPOINT_WORKSPACE_JOIN, ENDPOINT_WORKSPACE_LOGO, ENDPOINT_WORKSPACE_MEMBERS, ENDPOINT_WORKSPACE_PLAN_DETAILS, ENDPOINT_WORKSPACE_USERS, getWorkspaceActiveProjectsEndpoint, getWorkspaceArchivedProjectsEndpoint, getWorkspaceInvitationAcceptEndpoint, getWorkspaceInvitationRejectEndpoint, getWorkspaceInviteUsersEndpoint, getWorkspaceUserEndpoint, getWorkspaceUserTasksEndpoint, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { uploadMultipartFile } from '../utils/multipart-upload.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { IdSchema, validateJoinWorkspaceResult, validateMemberActivityInfoArray, validateProject, validateWorkspace, validateWorkspaceArray, validateWorkspaceInvitation, validateWorkspaceInvitationArray, validateWorkspacePlanDetails, validateWorkspaceUserArray, validateWorkspaceUserTaskArray, } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all workspace-domain endpoints —
+ * workspaces, invitations, users, plans, logos, and workspace project
+ * pagination.
+ *
+ * Instantiated by `TodoistApi`; every public workspace method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class WorkspaceClient extends BaseClient {
+    async getWorkspaceInvitations(args, requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: { workspace_id: args.workspaceId },
+            requestId: requestId,
+        });
+        return response.data;
+    }
+    async getAllWorkspaceInvitations(args = {}, requestId) {
+        const queryParams = {};
+        if (args.workspaceId) {
+            queryParams.workspace_id = args.workspaceId;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS_ALL,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitationArray(response.data);
+    }
+    async deleteWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS_DELETE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: {
+                workspace_id: args.workspaceId,
+                user_email: args.userEmail,
+            },
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async acceptWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'PUT',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInvitationAcceptEndpoint(args.inviteCode),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async rejectWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'PUT',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInvitationRejectEndpoint(args.inviteCode),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async joinWorkspace(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_JOIN,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: {
+                invite_code: args.inviteCode,
+                workspace_id: args.workspaceId,
+            },
+            requestId: requestId,
+        });
+        return validateJoinWorkspaceResult(response.data);
+    }
+    async uploadWorkspaceLogo(args, requestId) {
+        if (args.delete) {
+            // Delete logo
+            const data = await uploadMultipartFile({
+                baseUrl: this.syncApiBase,
+                authToken: this.authToken,
+                endpoint: ENDPOINT_WORKSPACE_LOGO,
+                file: Buffer.alloc(0), // Empty buffer for delete
+                fileName: 'delete',
+                additionalFields: {
+                    workspace_id: args.workspaceId,
+                    delete: true,
+                },
+                requestId: requestId,
+                customFetch: this.customFetch,
+                customHeaders: this.customHeaders,
+            });
+            return data;
+        }
+        if (!args.file) {
+            throw new Error('file is required when not deleting logo');
+        }
+        // Validate buffer is not empty if it's a Buffer
+        if (Buffer.isBuffer(args.file) && args.file.length === 0) {
+            throw new Error('Cannot upload empty image file');
+        }
+        const additionalFields = {
+            workspace_id: args.workspaceId,
+        };
+        const data = await uploadMultipartFile({
+            baseUrl: this.syncApiBase,
+            authToken: this.authToken,
+            endpoint: ENDPOINT_WORKSPACE_LOGO,
+            file: args.file,
+            fileName: args.fileName,
+            additionalFields: additionalFields,
+            requestId: requestId,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+        });
+        return data;
+    }
+    async getWorkspacePlanDetails(args, requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_PLAN_DETAILS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: { workspace_id: args.workspaceId },
+            requestId: requestId,
+        });
+        return validateWorkspacePlanDetails(response.data);
+    }
+    async getWorkspaceUsers(args = {}, requestId) {
+        const queryParams = {};
+        if (args.workspaceId !== undefined && args.workspaceId !== null) {
+            queryParams.workspace_id = args.workspaceId;
+        }
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_USERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return {
+            hasMore: response.data.hasMore || false,
+            nextCursor: response.data.nextCursor,
+            workspaceUsers: validateWorkspaceUserArray(response.data.workspaceUsers || []),
+        };
+    }
+    async getWorkspaces(requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_WORKSPACES,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            requestId: requestId,
+        });
+        return validateWorkspaceArray(response.data);
+    }
+    async getWorkspace(id, requestId) {
+        IdSchema.parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async addWorkspace(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_WORKSPACES,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async updateWorkspace(id, args, requestId) {
+        IdSchema.parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async deleteWorkspace(id, requestId) {
+        IdSchema.parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getWorkspaceMembersActivity(args, requestId) {
+        const { workspaceId } = args, queryParams = __rest(args, ["workspaceId"]);
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_MEMBERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: Object.assign({ workspaceId }, queryParams),
+            requestId: requestId,
+        });
+        return {
+            members: validateMemberActivityInfoArray(data.members),
+        };
+    }
+    async getWorkspaceUserTasks(args, requestId) {
+        const { workspaceId, userId } = args, queryParams = __rest(args, ["workspaceId", "userId"]);
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserTasksEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return {
+            tasks: validateWorkspaceUserTaskArray(data.tasks),
+        };
+    }
+    async inviteWorkspaceUsers(args, requestId) {
+        const { workspaceId } = args, payload = __rest(args, ["workspaceId"]);
+        const { data } = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInviteUsersEndpoint(workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: payload,
+            requestId: requestId,
+        });
+        return data;
+    }
+    async updateWorkspaceUser(args, requestId) {
+        const { workspaceId, userId } = args, payload = __rest(args, ["workspaceId", "userId"]);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: payload,
+            requestId: requestId,
+        });
+        return validateJoinWorkspaceResult(response.data);
+    }
+    async removeWorkspaceUser(args, requestId) {
+        const { workspaceId, userId } = args;
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getWorkspaceActiveProjects(args, requestId) {
+        var _a;
+        const queryParams = {};
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceActiveProjectsEndpoint(args.workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        // oxlint-disable-next-line no-unsafe-assignment, no-unsafe-call, no-unsafe-member-access
+        const validatedProjects = (_a = response.data.results) === null || _a === void 0 ? void 0 : _a.map((project) => validateProject(project));
+        return Object.assign(Object.assign({}, response.data), { 
+            // oxlint-disable-next-line no-unsafe-assignment
+            results: validatedProjects || [] });
+    }
+    async getWorkspaceArchivedProjects(args, requestId) {
+        var _a;
+        const queryParams = {};
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceArchivedProjectsEndpoint(args.workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            customHeaders: this.customHeaders,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        // oxlint-disable-next-line no-unsafe-assignment, no-unsafe-call, no-unsafe-member-access
+        const validatedProjects = (_a = response.data.results) === null || _a === void 0 ? void 0 : _a.map((project) => validateProject(project));
+        return Object.assign(Object.assign({}, response.data), { 
+            // oxlint-disable-next-line no-unsafe-assignment
+            results: validatedProjects || [] });
+    }
+}

package/dist/esm/consts/endpoints.js

@@ -0,0 +1,193 @@
+import { encodePathSegment } from '../utils/request-helpers.js';
+const BASE_URI = 'https://api.todoist.com';
+const TODOIST_URI = 'https://todoist.com';
+export const TODOIST_WEB_URI = 'https://app.todoist.com/app';
+// The API version is not configurable, to ensure
+// compatibility between the API and the client.
+export const API_VERSION = 'v1';
+export const API_BASE_URI = `/api/${API_VERSION}/`;
+const API_AUTHORIZATION_BASE_URI = '/oauth/';
+export function getSyncBaseUri(domainBase = BASE_URI) {
+    return new URL(API_BASE_URI, domainBase).toString();
+}
+export function getApiRootBaseUri(domainBase = BASE_URI) {
+    return new URL('/', domainBase).toString();
+}
+export function getAuthBaseUri(domainBase = TODOIST_URI) {
+    return new URL(API_AUTHORIZATION_BASE_URI, domainBase).toString();
+}
+export const ENDPOINT_REST_TASKS = 'tasks';
+export const ENDPOINT_REST_TASKS_FILTER = ENDPOINT_REST_TASKS + '/filter';
+export const ENDPOINT_REST_TASKS_COMPLETED_BY_COMPLETION_DATE = ENDPOINT_REST_TASKS + '/completed/by_completion_date';
+export const ENDPOINT_REST_TASKS_COMPLETED_BY_DUE_DATE = ENDPOINT_REST_TASKS + '/completed/by_due_date';
+export const ENDPOINT_REST_TASKS_COMPLETED_SEARCH = 'completed/search';
+export const ENDPOINT_REST_SECTIONS = 'sections';
+export const ENDPOINT_REST_SECTIONS_SEARCH = ENDPOINT_REST_SECTIONS + '/search';
+export const ENDPOINT_REST_LABELS = 'labels';
+export const ENDPOINT_REST_LABELS_SEARCH = ENDPOINT_REST_LABELS + '/search';
+export const ENDPOINT_REST_LABELS_SHARED = ENDPOINT_REST_LABELS + '/shared';
+export const ENDPOINT_REST_LABELS_SHARED_RENAME = ENDPOINT_REST_LABELS_SHARED + '/rename';
+export const ENDPOINT_REST_LABELS_SHARED_REMOVE = ENDPOINT_REST_LABELS_SHARED + '/remove';
+export const ENDPOINT_REST_COMMENTS = 'comments';
+export const ENDPOINT_REST_REMINDERS = 'reminders';
+export const ENDPOINT_REST_LOCATION_REMINDERS = 'location_reminders';
+export const ENDPOINT_REST_TASK_CLOSE = 'close';
+export const ENDPOINT_REST_TASK_REOPEN = 'reopen';
+export const ENDPOINT_REST_TASK_MOVE = 'move';
+export const ENDPOINT_REST_PROJECTS = 'projects';
+export const ENDPOINT_REST_PROJECTS_SEARCH = ENDPOINT_REST_PROJECTS + '/search';
+export const ENDPOINT_REST_PROJECTS_ARCHIVED = ENDPOINT_REST_PROJECTS + '/archived';
+export const ENDPOINT_REST_PROJECT_COLLABORATORS = 'collaborators';
+export const ENDPOINT_REST_USER = 'user';
+export const ENDPOINT_REST_PRODUCTIVITY = ENDPOINT_REST_TASKS + '/completed/stats';
+export const ENDPOINT_REST_ACTIVITIES = 'activities';
+export const ENDPOINT_REST_UPLOADS = 'uploads';
+export const PROJECT_ARCHIVE = 'archive';
+export const PROJECT_UNARCHIVE = 'unarchive';
+export const ENDPOINT_REST_PROJECTS_ARCHIVED_COUNT = ENDPOINT_REST_PROJECTS + '/archived/count';
+export const ENDPOINT_REST_PROJECTS_PERMISSIONS = ENDPOINT_REST_PROJECTS + '/permissions';
+export const ENDPOINT_REST_PROJECT_FULL = 'full';
+export const ENDPOINT_REST_PROJECT_JOIN = 'join';
+export const SECTION_ARCHIVE = 'archive';
+export const SECTION_UNARCHIVE = 'unarchive';
+export const ENDPOINT_REST_PROJECTS_MOVE_TO_WORKSPACE = ENDPOINT_REST_PROJECTS + '/move_to_workspace';
+export const ENDPOINT_REST_PROJECTS_MOVE_TO_PERSONAL = ENDPOINT_REST_PROJECTS + '/move_to_personal';
+export const ENDPOINT_REST_TASKS_COMPLETED = ENDPOINT_REST_TASKS + '/completed';
+export const ENDPOINT_REST_TEMPLATES_FILE = 'templates/file';
+export const ENDPOINT_REST_TEMPLATES_URL = 'templates/url';
+export const ENDPOINT_REST_TEMPLATES_CREATE_FROM_FILE = 'templates/create_project_from_file';
+export const ENDPOINT_REST_TEMPLATES_IMPORT_FROM_FILE = 'templates/import_into_project_from_file';
+export const ENDPOINT_REST_TEMPLATES_IMPORT_FROM_ID = 'templates/import_into_project_from_template_id';
+export const ENDPOINT_REST_ACCESS_TOKENS_MIGRATE = 'access_tokens/migrate_personal_token';
+export const ENDPOINT_REST_BACKUPS = 'backups';
+export const ENDPOINT_REST_BACKUPS_DOWNLOAD = 'backups/download';
+export const ENDPOINT_REST_EMAILS = 'emails';
+export const ENDPOINT_REST_ID_MAPPINGS = 'id_mappings';
+export const ENDPOINT_REST_MOVED_IDS = 'moved_ids';
+export const ENDPOINT_SYNC_QUICK_ADD = ENDPOINT_REST_TASKS + '/quick';
+export const ENDPOINT_SYNC = 'sync';
+export const ENDPOINT_AUTHORIZATION = 'authorize';
+export const ENDPOINT_GET_TOKEN = 'access_token';
+export const ENDPOINT_REVOKE = 'revoke';
+export const ENDPOINT_REGISTER = 'register';
+export const ENDPOINT_REST_FOLDERS = 'folders';
+export const ENDPOINT_REST_FILTERS = 'filters';
+// Workspace endpoints
+export const ENDPOINT_REST_WORKSPACES = 'workspaces';
+export const ENDPOINT_WORKSPACE_INVITATIONS = 'workspaces/invitations';
+export const ENDPOINT_WORKSPACE_INVITATIONS_ALL = 'workspaces/invitations/all';
+export const ENDPOINT_WORKSPACE_INVITATIONS_DELETE = 'workspaces/invitations/delete';
+export const ENDPOINT_WORKSPACE_JOIN = 'workspaces/join';
+export const ENDPOINT_WORKSPACE_LOGO = 'workspaces/logo';
+export const ENDPOINT_WORKSPACE_PLAN_DETAILS = 'workspaces/plan_details';
+export const ENDPOINT_WORKSPACE_USERS = 'workspaces/users';
+// Billing endpoints
+export const ENDPOINT_PAYMENTS_SUBSCRIPTION_INFO = 'payments/get_subscription_info';
+export const ENDPOINT_PAYMENTS_CANCEL_PLAN = 'payments/cancel_plan_with_redirect_to_stripe';
+export const ENDPOINT_PAYMENTS_REACTIVATE_PLAN = 'payments/reactivate_plan';
+export const ENDPOINT_PRO_UPGRADE = 'pro/upgrade';
+export const ENDPOINT_PRO_TRIAL = 'pro/trial';
+export const ENDPOINT_PRO_BILLING_PORTAL = 'pro/billing_portal';
+export const ENDPOINT_PRO_PLAN_DETAILS = 'pro/plan_details';
+export const ENDPOINT_WORKSPACE_UPGRADE = 'workspaces/upgrade';
+export const ENDPOINT_WORKSPACE_TRIAL = 'workspaces/trial';
+export const ENDPOINT_WORKSPACE_BILLING_PORTAL = 'workspaces/billing_portal';
+export const ENDPOINT_PRICES = 'prices';
+export const ENDPOINT_PRICING = 'pricing';
+// Workspace invitation actions (require invite_code parameter)
+export function getWorkspaceInvitationAcceptEndpoint(inviteCode) {
+    return `workspaces/invitations/${encodePathSegment(inviteCode)}/accept`;
+}
+export function getWorkspaceInvitationRejectEndpoint(inviteCode) {
+    return `workspaces/invitations/${encodePathSegment(inviteCode)}/reject`;
+}
+// Insights endpoints
+export function getProjectInsightsActivityStatsEndpoint(projectId) {
+    return `projects/${encodePathSegment(projectId)}/insights/activity_stats`;
+}
+export function getProjectInsightsHealthEndpoint(projectId) {
+    return `projects/${encodePathSegment(projectId)}/insights/health`;
+}
+export function getProjectInsightsHealthContextEndpoint(projectId) {
+    return `projects/${encodePathSegment(projectId)}/insights/health/context`;
+}
+export function getProjectInsightsProgressEndpoint(projectId) {
+    return `projects/${encodePathSegment(projectId)}/insights/progress`;
+}
+export function getProjectInsightsHealthAnalyzeEndpoint(projectId) {
+    return `projects/${encodePathSegment(projectId)}/insights/health/analyze`;
+}
+export function getWorkspaceInsightsEndpoint(workspaceId) {
+    return `workspaces/${encodePathSegment(workspaceId)}/insights`;
+}
+// Workspace members
+export const ENDPOINT_WORKSPACE_MEMBERS = 'workspaces/members';
+// Workspace user management (require workspace_id and/or user_id parameters)
+export function getWorkspaceUserTasksEndpoint(workspaceId, userId) {
+    return `workspaces/${encodePathSegment(workspaceId)}/users/${encodePathSegment(userId)}/tasks`;
+}
+export function getWorkspaceInviteUsersEndpoint(workspaceId) {
+    return `workspaces/${encodePathSegment(workspaceId)}/users/invite`;
+}
+export function getWorkspaceUserEndpoint(workspaceId, userId) {
+    return `workspaces/${encodePathSegment(workspaceId)}/users/${encodePathSegment(userId)}`;
+}
+// Workspace projects (require workspace_id parameter)
+export function getWorkspaceActiveProjectsEndpoint(workspaceId) {
+    return `workspaces/${encodePathSegment(workspaceId)}/projects/active`;
+}
+export function getWorkspaceArchivedProjectsEndpoint(workspaceId) {
+    return `workspaces/${encodePathSegment(workspaceId)}/projects/archived`;
+}
+// App management endpoints (dev:app_console scope)
+export const ENDPOINT_REST_APPS = 'apps';
+export const ENDPOINT_REST_APPS_INSTALLATIONS = 'apps/installations';
+export const ENDPOINT_REST_APPS_UI_EXTENSIONS = 'apps/ui_extensions';
+export const ENDPOINT_REST_APPS_UI_EXTENSIONS_INSTALLED = 'apps/ui_extensions/installed';
+export const ENDPOINT_REST_USER_AUTHORIZATIONS = 'user/authorizations';
+export const ENDPOINT_REST_USER_AUTHORIZATIONS_DELETE = 'user/authorizations/delete';
+/** Available app icon sizes (small 60x60, medium 300x300, large 600x600). */
+export const APP_ICON_SIZES = ['small', 'medium', 'large'];
+export function getAppEndpoint(appId) {
+    return `apps/${encodePathSegment(appId)}`;
+}
+export function getAppSecretsEndpoint(appId) {
+    return `apps/${encodePathSegment(appId)}/secrets`;
+}
+export function getAppClientSecretEndpoint(appId) {
+    return `apps/${encodePathSegment(appId)}/client_secret`;
+}
+export function getAppTokensEndpoint(appId) {
+    return `apps/${encodePathSegment(appId)}/tokens`;
+}
+export function getAppTestTokenEndpoint(appId) {
+    return `apps/${encodePathSegment(appId)}/test_token`;
+}
+export function getAppDistributionTokenEndpoint(appId) {
+    return `apps/${encodePathSegment(appId)}/distribution_token`;
+}
+export function getAppVerificationTokenEndpoint(appId) {
+    return `apps/${encodePathSegment(appId)}/verification_token`;
+}
+export function getAppWebhookEndpoint(appId) {
+    return `apps/${encodePathSegment(appId)}/webhook`;
+}
+export function getAppIconEndpoint(appId, size) {
+    const base = `apps/${encodePathSegment(appId)}/icon`;
+    return size === 'medium' ? base : `${base}/${size}`;
+}
+export function getAppInstallationEndpoint(installationId) {
+    return `apps/installations/${encodePathSegment(installationId)}`;
+}
+export function getAppByDistributionTokenEndpoint(distributionToken) {
+    return `apps/by_distribution_token/${encodePathSegment(distributionToken)}`;
+}
+export function getUiExtensionEndpoint(uiExtensionId) {
+    return `apps/ui_extensions/${encodePathSegment(uiExtensionId)}`;
+}
+export function getUiExtensionIconEndpoint(uiExtensionId) {
+    return `apps/ui_extensions/${encodePathSegment(uiExtensionId)}/icon`;
+}
+export function getUiExtensionsByIntegrationEndpoint(integrationId) {
+    return `apps/ui_extensions/integration/${encodePathSegment(integrationId)}`;
+}

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export * from './todoist-api.js';
+export * from './authentication.js';
+export * from './types/index.js';
+export * from './utils/index.js';
+export { getDefaultDispatcher, getDefaultTransport } from './transport/http-dispatcher.js';

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

@@ -0,0 +1,8 @@
+// Has to use 'any' to express constructor type
+// oxlint-disable-next-line no-explicit-any
+export function assertInstance(value, type) {
+    if (value instanceof type) {
+        return;
+    }
+    throw new TypeError(`Unexpected type ${typeof value}`);
+}

package/dist/esm/test-utils/msw-setup.js

@@ -0,0 +1,88 @@
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+import { beforeAll, afterEach, afterAll } from 'vitest';
+// Request capture storage
+const capturedRequests = [];
+// Helper function to capture requests
+export function captureRequest({ request, body }) {
+    const headers = {};
+    request.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    capturedRequests.push({
+        url: request.url,
+        method: request.method,
+        headers,
+        body,
+    });
+}
+// Helper function to get the last captured request
+export function getLastRequest() {
+    return capturedRequests[capturedRequests.length - 1];
+}
+// Helper function to get all captured requests
+export function getAllRequests() {
+    return [...capturedRequests];
+}
+// Helper function to clear captured requests
+export function clearCapturedRequests() {
+    capturedRequests.length = 0;
+}
+// Default handlers for common API responses
+export const handlers = [
+// Default handlers can be added here for common endpoints
+// Individual test files will add their own specific handlers
+];
+// Create MSW server instance
+export const server = setupServer(...handlers);
+// Helper to create a resolver function for MSW handlers
+function createResolver(data, status, headers) {
+    return async function resolver({ request }) {
+        let body = undefined;
+        if (request.method !== 'GET') {
+            try {
+                body = await request.json();
+            }
+            catch (_a) {
+                // Body might not be JSON
+                try {
+                    body = await request.text();
+                }
+                catch (_b) {
+                    // Body might be FormData or not parseable
+                }
+            }
+        }
+        captureRequest({ request, body });
+        return HttpResponse.json(data, {
+            status,
+            headers,
+        });
+    };
+}
+// Helper to mock a successful API response
+export function mockApiResponse({ endpoint, data, options = {}, }) {
+    const { status = 200, method = 'GET', headers = {} } = options;
+    const resolver = createResolver(data, status, headers);
+    const httpMethod = method.toLowerCase();
+    server.use(http[httpMethod](endpoint, resolver));
+}
+// Helper to mock an error response
+export function mockApiError({ endpoint, data, status, options = {}, }) {
+    mockApiResponse({ endpoint, data, options: Object.assign(Object.assign({}, options), { status }) });
+}
+// Setup MSW for tests
+beforeAll(() => {
+    server.listen({
+        onUnhandledRequest: 'error', // Throw errors for unhandled requests to catch unexpected fetch calls
+    });
+});
+afterEach(() => {
+    server.resetHandlers(); // Reset handlers between tests
+    clearCapturedRequests(); // Clear captured requests between tests
+});
+afterAll(() => {
+    server.close(); // Clean up after all tests
+});
+// Export MSW utilities for use in tests
+export { http, HttpResponse };