@doist/todoist-api-typescript 7.4.0 → 7.6.0

package/dist/esm/{utils → transport}/fetch-with-retry.js

@@ -10,6 +10,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { isNetworkError } from '../types/http.js';
+import { getDefaultDispatcher } from './http-dispatcher.js';
 /**
  * Default retry configuration matching the original axios-retry behavior
  */
@@ -22,32 +23,11 @@ const DEFAULT_RETRY_CONFIG = {
         return retryNumber === 1 ? 0 : 500;
     },
 };
-/**
- * Cached HTTP agent to prevent creating multiple agents
- * null = not initialized, undefined = browser env, UndiciAgent = Node.js env
- */
-let httpAgent = null;
-/**
- * Gets the HTTP agent for Node.js environments or undefined for browser environments.
- * Uses dynamic import to avoid loading undici in browser environments.
- */
-async function getHttpAgent() {
-    var _a;
-    if (httpAgent === null) {
-        if (typeof process !== 'undefined' && ((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node)) {
-            // We're in Node.js - dynamically import undici
-            const { Agent } = await import('undici');
-            httpAgent = new Agent({
-                keepAliveTimeout: 1, // Close connections after 1ms of idle time
-                keepAliveMaxTimeout: 1, // Maximum time to keep connections alive
-            });
-        }
-        else {
-            // We're in browser - no agent needed
-            httpAgent = undefined;
-        }
-    }
-    return httpAgent;
+const TIMEOUT_ERROR_NAME = 'TimeoutError';
+function createTimeoutError(timeoutMs) {
+    const error = new Error(`Request timeout after ${timeoutMs}ms`);
+    error.name = TIMEOUT_ERROR_NAME;
+    return error;
 }
 /**
  * Converts Headers object to a plain object
@@ -67,10 +47,14 @@ function createTimeoutSignal(timeoutMs, existingSignal) {
     const controller = new AbortController();
     // Timeout logic
     const timeoutId = setTimeout(() => {
-        controller.abort(new Error(`Request timeout after ${timeoutMs}ms`));
+        controller.abort(createTimeoutError(timeoutMs));
     }, timeoutMs);
+    let abortHandler;
     function clear() {
         clearTimeout(timeoutId);
+        if (existingSignal && abortHandler) {
+            existingSignal.removeEventListener('abort', abortHandler);
+        }
     }
     // If there's an existing signal, forward its abort
     if (existingSignal) {
@@ -79,10 +63,11 @@ function createTimeoutSignal(timeoutMs, existingSignal) {
             controller.abort(existingSignal.reason);
         }
         else {
-            existingSignal.addEventListener('abort', () => {
+            abortHandler = () => {
                 clearTimeout(timeoutId);
                 controller.abort(existingSignal.reason);
-            }, { once: true });
+            };
+            existingSignal.addEventListener('abort', abortHandler, { once: true });
         }
     }
     // Clean up timeout when request completes
@@ -131,9 +116,13 @@ export async function fetchWithRetry(args) {
                 fetchResponse = await customFetch(url, Object.assign(Object.assign({}, fetchOptions), { signal: requestSignal, timeout }));
             }
             else {
-                const nativeResponse = await fetch(url, Object.assign(Object.assign({}, fetchOptions), { signal: requestSignal, 
+                const dispatcher = await getDefaultDispatcher();
+                const nativeFetchOptions = Object.assign(Object.assign({}, fetchOptions), { signal: requestSignal });
+                if (dispatcher !== undefined) {
                     // @ts-expect-error - dispatcher is a valid option for Node.js fetch but not in the TS types
-                    dispatcher: await getHttpAgent() }));
+                    nativeFetchOptions.dispatcher = dispatcher;
+                }
+                const nativeResponse = await fetch(url, nativeFetchOptions);
                 fetchResponse = convertResponseToCustomFetch(nativeResponse);
             }
             // Check if the response is successful
@@ -188,6 +177,9 @@ export async function fetchWithRetry(args) {
             };
         }
         catch (error) {
+            if (clearTimeoutFn) {
+                clearTimeoutFn();
+            }
             lastError = error;
             // Check if this error should trigger a retry
             const shouldRetry = attempt < config.retries && config.retryCondition(lastError);
@@ -197,9 +189,6 @@ export async function fetchWithRetry(args) {
                     const networkError = lastError;
                     networkError.isNetworkError = true;
                 }
-                if (clearTimeoutFn) {
-                    clearTimeoutFn();
-                }
                 throw lastError;
             }
             // Wait before retrying
@@ -207,10 +196,6 @@ export async function fetchWithRetry(args) {
             if (delay > 0) {
                 await new Promise((resolve) => setTimeout(resolve, delay));
             }
-            // Retry path – ensure this attempt's timeout is cleared before looping
-            if (clearTimeoutFn) {
-                clearTimeoutFn();
-            }
         }
     }
     // This should never be reached, but just in case

package/dist/esm/{rest-client.js → transport/http-client.js}

@@ -1,9 +1,9 @@
-import { TodoistRequestError } from './types/errors.js';
-import { isNetworkError, isHttpError } from './types/http.js';
 import { v4 as uuidv4 } from 'uuid';
-import { API_BASE_URI } from './consts/endpoints.js';
-import { camelCaseKeys, snakeCaseKeys } from './utils/case-conversion.js';
-import { fetchWithRetry } from './utils/fetch-with-retry.js';
+import { API_BASE_URI } from '../consts/endpoints.js';
+import { TodoistRequestError } from '../types/errors.js';
+import { isHttpError, isNetworkError } from '../types/http.js';
+import { camelCaseKeys, snakeCaseKeys } from '../utils/case-conversion.js';
+import { fetchWithRetry } from './fetch-with-retry.js';
 export function paramsSerializer(params) {
     const qs = new URLSearchParams();
     Object.keys(params).forEach((key) => {

package/dist/esm/transport/http-dispatcher.js

@@ -0,0 +1,35 @@
+// Use effectively-disabled keep-alive so short-lived CLI processes do not stay
+// open waiting on idle sockets. Undici requires positive values, so we use 1ms.
+const KEEP_ALIVE_OPTIONS = {
+    keepAliveTimeout: 1,
+    keepAliveMaxTimeout: 1,
+};
+let defaultDispatcherPromise;
+export function getDefaultDispatcher() {
+    if (!isNodeEnvironment()) {
+        return Promise.resolve(undefined);
+    }
+    if (!defaultDispatcherPromise) {
+        defaultDispatcherPromise = createDefaultDispatcher().catch((error) => {
+            defaultDispatcherPromise = undefined;
+            throw error;
+        });
+    }
+    return defaultDispatcherPromise;
+}
+export async function resetDefaultDispatcherForTests() {
+    if (!defaultDispatcherPromise) {
+        return;
+    }
+    const dispatcherPromise = defaultDispatcherPromise;
+    defaultDispatcherPromise = undefined;
+    await dispatcherPromise.then((dispatcher) => dispatcher.close(), () => undefined);
+}
+async function createDefaultDispatcher() {
+    const { EnvHttpProxyAgent } = await import('undici');
+    return new EnvHttpProxyAgent(KEEP_ALIVE_OPTIONS);
+}
+function isNodeEnvironment() {
+    var _a;
+    return typeof process !== 'undefined' && Boolean((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
+}

package/dist/esm/types/entities.js

@@ -319,6 +319,14 @@ export const ActivityEventSchema = z
     extraData: ActivityEventExtraDataSchema,
 })
     .catchall(z.any());
+/** Available project collaborator roles. */
+export const COLLABORATOR_ROLES = [
+    'CREATOR',
+    'ADMIN',
+    'READ_WRITE',
+    'EDIT_ONLY',
+    'COMPLETE_ONLY',
+];
 /**
  * Available workspace roles.
  */
@@ -424,3 +432,117 @@ export const WorkspaceSchema = z.object({
     creatorId: z.string(),
     properties: WorkspacePropertiesSchema,
 });
+export const MemberActivityInfoSchema = z.object({
+    userId: z.string(),
+    tasksAssigned: z.number().int(),
+    tasksOverdue: z.number().int(),
+});
+export const WorkspaceUserTaskSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    responsibleUid: z.string().nullable(),
+    due: DueDateSchema.nullable(),
+    deadline: DeadlineSchema.nullable(),
+    labels: z.array(z.string()),
+    notesCount: z.number().int(),
+    projectId: z.string(),
+    projectName: z.string(),
+    priority: z.number().int(),
+    description: z.string(),
+    isOverdue: z.boolean(),
+});
+// Insights entities
+export const DayActivitySchema = z.object({
+    date: z.string(),
+    totalCount: z.number().int(),
+});
+export const WeekRollupSchema = z.object({
+    fromDate: z.string(),
+    toDate: z.string(),
+    totalCount: z.number().int(),
+});
+export const ProjectActivityStatsSchema = z.object({
+    dayItems: z.array(DayActivitySchema),
+    weekItems: z.array(WeekRollupSchema).nullable(),
+});
+/** Available project health statuses. */
+export const HEALTH_STATUSES = [
+    'UNKNOWN',
+    'ON_TRACK',
+    'AT_RISK',
+    'CRITICAL',
+    'EXCELLENT',
+    'ERROR',
+];
+export const TaskRecommendationSchema = z.object({
+    taskId: z.string(),
+    recommendation: z.string(),
+});
+export const ProjectHealthSchema = z.object({
+    status: z.enum(HEALTH_STATUSES),
+    description: z.string().nullable().optional(),
+    descriptionSummary: z.string().nullable().optional(),
+    taskRecommendations: z.array(TaskRecommendationSchema).nullable().optional(),
+    projectId: z.string().nullable().optional(),
+    updatedAt: z.string().nullable().optional(),
+    isStale: z.boolean().default(false),
+    updateInProgress: z.boolean().default(false),
+});
+export const ProjectMetricsSchema = z.object({
+    totalTasks: z.number().int(),
+    completedTasks: z.number().int(),
+    overdueTasks: z.number().int(),
+    tasksCreatedThisWeek: z.number().int(),
+    tasksCompletedThisWeek: z.number().int(),
+    averageCompletionTime: z.number().nullable(),
+});
+export const TaskContextSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    due: z.string().nullable().optional(),
+    deadline: z.string().nullable().optional(),
+    priority: z.string(),
+    isCompleted: z.boolean(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    completedAt: z.string().nullable(),
+    completedByUid: z.string().nullable(),
+    labels: z.array(z.string()),
+});
+export const ProjectHealthContextSchema = z.object({
+    projectId: z.string(),
+    projectName: z.string(),
+    projectDescription: z.string().nullable(),
+    projectMetrics: ProjectMetricsSchema,
+    tasks: z.array(TaskContextSchema),
+    language: z.string().nullable().optional(),
+});
+export const ProjectProgressSchema = z.object({
+    projectId: z.string(),
+    completedCount: z.number().int(),
+    activeCount: z.number().int(),
+    progressPercent: z.number().int(),
+});
+export const ProjectInsightSchema = z.object({
+    projectId: z.string(),
+    health: ProjectHealthSchema.nullable(),
+    progress: ProjectProgressSchema.nullable(),
+});
+export const WorkspaceInsightsSchema = z.object({
+    folderId: z.string().nullable(),
+    projectInsights: z.array(ProjectInsightSchema),
+});
+// Backups
+export const BackupSchema = z.object({
+    version: z.string(),
+    url: z.string(),
+});
+// ID Mappings
+export const IdMappingSchema = z.object({
+    oldId: z.string().nullable(),
+    newId: z.string().nullable(),
+});
+export const MovedIdSchema = z.object({
+    oldId: z.string(),
+    newId: z.string(),
+});

package/dist/esm/types/errors.js

@@ -15,3 +15,10 @@ export class TodoistRequestError extends CustomError {
         Object.defineProperty(this, 'name', { value: 'TodoistRequestError' });
     }
 }
+export class TodoistArgumentError extends CustomError {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        Object.defineProperty(this, 'name', { value: 'TodoistArgumentError' });
+    }
+}

package/dist/esm/types/http.js

@@ -2,12 +2,14 @@
  * Type guard to check if an error is a network error
  */
 export function isNetworkError(error) {
-    // Network errors in fetch are typically TypeError with specific messages
+    // Network errors in fetch are typically TypeError with specific messages.
+    // Timeout errors are created by fetch-with-retry with the TimeoutError name.
     return ((error instanceof TypeError &&
         (error.message.includes('fetch') ||
             error.message.includes('network') ||
             error.message.includes('Failed to fetch') ||
             error.message.includes('NetworkError'))) ||
+        error.name === 'TimeoutError' ||
         error.isNetworkError === true);
 }
 /**

package/dist/esm/types/requests.js

@@ -1 +1,23 @@
-export {};
+/** Available reminder delivery services. */
+export const REMINDER_DELIVERY_SERVICES = ['email', 'push'];
+// Email forwarding types
+/** Object types that support email forwarding. */
+export const EMAIL_OBJECT_TYPES = ['project', 'project_comments', 'task'];
+// ID mapping types
+/** Object types that support ID mappings. */
+export const ID_MAPPING_OBJECT_TYPES = [
+    'sections',
+    'tasks',
+    'comments',
+    'reminders',
+    'location_reminders',
+    'projects',
+];
+/** Object types that support moved ID lookups. */
+export const MOVED_ID_OBJECT_TYPES = [
+    'sections',
+    'tasks',
+    'comments',
+    'reminders',
+    'location_reminders',
+];

package/dist/esm/types/sync/commands/shared.js

@@ -9,14 +9,7 @@ export const PROJECT_STATUSES = [
     'COMPLETED',
     'CANCELED',
 ];
-/** Available default collaborator roles. */
-export const COLLABORATOR_ROLES = [
-    'CREATOR',
-    'ADMIN',
-    'READ_WRITE',
-    'EDIT_ONLY',
-    'COMPLETE_ONLY',
-];
+export { COLLABORATOR_ROLES } from '../../entities.js';
 /** Available reminder notification services. */
 export const REMINDER_SERVICES = ['default', 'email', 'mobile', 'push', 'no_default'];
 /** Available workspace project sort orders. */

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

@@ -20,11 +20,13 @@ export const LocationReminderSchema = ReminderBaseSchema.extend({
 export const AbsoluteReminderSchema = ReminderBaseSchema.extend({
     type: z.literal('absolute'),
     due: DueDateSchema,
+    isUrgent: z.boolean().optional(),
 }).passthrough();
 export const RelativeReminderSchema = ReminderBaseSchema.extend({
     type: z.literal('relative'),
     minuteOffset: z.number().int(),
     due: DueDateSchema.optional(),
+    isUrgent: z.boolean().optional(),
 }).passthrough();
 export const ReminderSchema = z.discriminatedUnion('type', [
     LocationReminderSchema,

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

@@ -1,4 +1,4 @@
-import { fetchWithRetry } from './fetch-with-retry.js';
+import { fetchWithRetry } from '../transport/fetch-with-retry.js';
 /**
  * Helper function to determine content-type from filename extension.
  * @param fileName - The filename to analyze

package/dist/esm/utils/validators.js

@@ -1,5 +1,5 @@
-import { AttachmentSchema, SectionSchema, LabelSchema, CommentSchema, UserSchema, CurrentUserSchema, TaskSchema, PersonalProjectSchema, WorkspaceProjectSchema, ProductivityStatsSchema, ActivityEventSchema, WorkspaceUserSchema, WorkspaceInvitationSchema, WorkspacePlanDetailsSchema, JoinWorkspaceResultSchema, WorkspaceSchema, } from '../types/entities.js';
-import { FilterSchema, CollaboratorSchema, CollaboratorStateSchema, FolderSchema, NoteSchema, TooltipsSchema, WorkspaceFilterSchema, WorkspaceGoalSchema, CalendarSchema, CalendarAccountSchema, ReminderSchema, CompletedInfoSchema, ViewOptionsSchema, ProjectViewOptionsDefaultsSchema, UserPlanLimitsSchema, LiveNotificationSchema, SyncWorkspaceSchema, SyncUserSchema, UserSettingsSchema, SuggestionSchema, } from '../types/sync/resources/index.js';
+import { AttachmentSchema, SectionSchema, LabelSchema, CommentSchema, UserSchema, CurrentUserSchema, TaskSchema, PersonalProjectSchema, WorkspaceProjectSchema, ProductivityStatsSchema, ActivityEventSchema, WorkspaceUserSchema, WorkspaceInvitationSchema, WorkspacePlanDetailsSchema, JoinWorkspaceResultSchema, WorkspaceSchema, MemberActivityInfoSchema, WorkspaceUserTaskSchema, ProjectActivityStatsSchema, ProjectHealthSchema, ProjectHealthContextSchema, ProjectProgressSchema, WorkspaceInsightsSchema, BackupSchema, IdMappingSchema, MovedIdSchema, } from '../types/entities.js';
+import { FilterSchema, CollaboratorSchema, CollaboratorStateSchema, FolderSchema, NoteSchema, TooltipsSchema, WorkspaceFilterSchema, WorkspaceGoalSchema, CalendarSchema, CalendarAccountSchema, ReminderSchema, LocationReminderSchema, CompletedInfoSchema, ViewOptionsSchema, ProjectViewOptionsDefaultsSchema, UserPlanLimitsSchema, LiveNotificationSchema, SyncWorkspaceSchema, SyncUserSchema, UserSettingsSchema, SuggestionSchema, } from '../types/sync/resources/index.js';
 function createValidator(schema) {
     return (input) => schema.parse(input);
 }
@@ -65,6 +65,21 @@ export const validateWorkspacePlanDetails = createValidator(WorkspacePlanDetails
 export const validateJoinWorkspaceResult = createValidator(JoinWorkspaceResultSchema);
 export const validateWorkspace = createValidator(WorkspaceSchema);
 export const validateWorkspaceArray = createArrayValidator(validateWorkspace);
+export const validateMemberActivityInfo = createValidator(MemberActivityInfoSchema);
+export const validateMemberActivityInfoArray = createArrayValidator(validateMemberActivityInfo);
+export const validateWorkspaceUserTask = createValidator(WorkspaceUserTaskSchema);
+export const validateWorkspaceUserTaskArray = createArrayValidator(validateWorkspaceUserTask);
+export const validateProjectActivityStats = createValidator(ProjectActivityStatsSchema);
+export const validateProjectHealth = createValidator(ProjectHealthSchema);
+export const validateProjectHealthContext = createValidator(ProjectHealthContextSchema);
+export const validateProjectProgress = createValidator(ProjectProgressSchema);
+export const validateWorkspaceInsights = createValidator(WorkspaceInsightsSchema);
+export const validateBackup = createValidator(BackupSchema);
+export const validateBackupArray = createArrayValidator(validateBackup);
+export const validateIdMapping = createValidator(IdMappingSchema);
+export const validateIdMappingArray = createArrayValidator(validateIdMapping);
+export const validateMovedId = createValidator(MovedIdSchema);
+export const validateMovedIdArray = createArrayValidator(validateMovedId);
 // Sync resource validators
 export const validateFilter = createValidator(FilterSchema);
 export const validateFilterArray = createArrayValidator(validateFilter);
@@ -87,6 +102,8 @@ export const validateCalendarAccount = createValidator(CalendarAccountSchema);
 export const validateCalendarAccountArray = createArrayValidator(validateCalendarAccount);
 export const validateReminder = createValidator(ReminderSchema);
 export const validateReminderArray = createArrayValidator(validateReminder);
+export const validateLocationReminder = createValidator(LocationReminderSchema);
+export const validateLocationReminderArray = createArrayValidator(validateLocationReminder);
 export const validateCompletedInfo = createValidator(CompletedInfoSchema);
 export const validateCompletedInfoArray = createArrayValidator(validateCompletedInfo);
 export const validateViewOptions = createValidator(ViewOptionsSchema);

package/dist/types/authentication.d.ts

@@ -10,12 +10,12 @@ export type AuthOptions = {
 export declare const PERMISSIONS: readonly ["task:add", "data:read", "data:read_write", "data:delete", "project:delete", "backups:read"];
 /**
  * Permission scope that can be requested during OAuth2 authorization.
- * @see {@link https://todoist.com/api/v1/docs#tag/Authorization}
+ * @see {@link https://developer.todoist.com/api/v1/#tag/Authorization}
  */
 export type Permission = (typeof PERMISSIONS)[number];
 /**
  * Parameters required to exchange an authorization code for an access token.
- * @see https://todoist.com/api/v1/docs#tag/Authorization/OAuth
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization/OAuth
  */
 export type AuthTokenRequestArgs = {
     clientId: string;
@@ -24,7 +24,7 @@ export type AuthTokenRequestArgs = {
 };
 /**
  * Response from a successful OAuth2 token exchange.
- * @see https://todoist.com/api/v1/docs#tag/Authorization/OAuth
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization/OAuth
  */
 export type AuthTokenResponse = {
     accessToken: string;
@@ -32,13 +32,37 @@ export type AuthTokenResponse = {
 };
 /**
  * Parameters required to revoke a token using RFC 7009 compliant endpoint.
- * @see https://todoist.com/api/v1/docs#tag/Authorization
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization
  */
 export type RevokeTokenRequestArgs = {
     clientId: string;
     clientSecret: string;
     token: string;
 };
+/**
+ * Parameters required to migrate a personal API token to an OAuth token.
+ */
+export type MigratePersonalTokenArgs = {
+    /** The unique Client ID of the registered Todoist application. */
+    clientId: string;
+    /** The unique Client Secret of the registered Todoist application. */
+    clientSecret: string;
+    /** The personal API token obtained from email/password authentication. */
+    personalToken: string;
+    /** Scopes for the new OAuth token. */
+    scope: readonly Permission[];
+};
+/**
+ * Response from a successful personal token migration.
+ */
+export type MigratePersonalTokenResponse = {
+    /** The new OAuth access token, or null if migration failed. */
+    accessToken: string | null;
+    /** The token type (always 'Bearer'). */
+    tokenType: string;
+    /** Token expiration time in seconds. */
+    expiresIn: number;
+};
 /**
  * Generates a random state parameter for OAuth2 authorization.
  * The state parameter helps prevent CSRF attacks.
@@ -67,7 +91,7 @@ export declare function getAuthStateParameter(): string;
  * ```
  *
  * @returns The full authorization URL to redirect users to
- * @see https://todoist.com/api/v1/docs#tag/Authorization/OAuth
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization/OAuth
  */
 export declare function getAuthorizationUrl({ clientId, permissions, state, baseUrl, }: {
     clientId: string;
@@ -108,6 +132,27 @@ export declare function getAuthToken(args: AuthTokenRequestArgs, options?: AuthO
  *
  * @returns True if revocation was successful
  * @see https://datatracker.ietf.org/doc/html/rfc7009
- * @see https://todoist.com/api/v1/docs#tag/Authorization
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization
  */
 export declare function revokeToken(args: RevokeTokenRequestArgs, options?: AuthOptions): Promise<boolean>;
+/**
+ * Migrates a personal API token to an OAuth access token.
+ *
+ * This allows applications to transition users from personal API tokens
+ * to proper OAuth tokens without requiring the user to go through the
+ * full OAuth authorization flow.
+ *
+ * @example
+ * ```typescript
+ * const { accessToken } = await migratePersonalToken({
+ *   clientId: 'your-client-id',
+ *   clientSecret: 'your-client-secret',
+ *   personalToken: 'user-personal-token',
+ *   scope: 'data:read_write,data:delete'
+ * })
+ * ```
+ *
+ * @returns The new OAuth token response
+ * @throws {@link TodoistRequestError} If the migration fails
+ */
+export declare function migratePersonalToken(args: MigratePersonalTokenArgs, options?: AuthOptions): Promise<MigratePersonalTokenResponse>;

package/dist/types/consts/endpoints.d.ts

@@ -16,6 +16,8 @@ export declare const ENDPOINT_REST_LABELS_SHARED: string;
 export declare const ENDPOINT_REST_LABELS_SHARED_RENAME: string;
 export declare const ENDPOINT_REST_LABELS_SHARED_REMOVE: string;
 export declare const ENDPOINT_REST_COMMENTS = "comments";
+export declare const ENDPOINT_REST_REMINDERS = "reminders";
+export declare const ENDPOINT_REST_LOCATION_REMINDERS = "location_reminders";
 export declare const ENDPOINT_REST_TASK_CLOSE = "close";
 export declare const ENDPOINT_REST_TASK_REOPEN = "reopen";
 export declare const ENDPOINT_REST_TASK_MOVE = "move";
@@ -29,13 +31,32 @@ export declare const ENDPOINT_REST_ACTIVITIES = "activities";
 export declare const ENDPOINT_REST_UPLOADS = "uploads";
 export declare const PROJECT_ARCHIVE = "archive";
 export declare const PROJECT_UNARCHIVE = "unarchive";
+export declare const ENDPOINT_REST_PROJECTS_ARCHIVED_COUNT: string;
+export declare const ENDPOINT_REST_PROJECTS_PERMISSIONS: string;
+export declare const ENDPOINT_REST_PROJECT_FULL = "full";
+export declare const ENDPOINT_REST_PROJECT_JOIN = "join";
+export declare const SECTION_ARCHIVE = "archive";
+export declare const SECTION_UNARCHIVE = "unarchive";
 export declare const ENDPOINT_REST_PROJECTS_MOVE_TO_WORKSPACE: string;
 export declare const ENDPOINT_REST_PROJECTS_MOVE_TO_PERSONAL: string;
+export declare const ENDPOINT_REST_TASKS_COMPLETED: string;
+export declare const ENDPOINT_REST_TEMPLATES_FILE = "templates/file";
+export declare const ENDPOINT_REST_TEMPLATES_URL = "templates/url";
+export declare const ENDPOINT_REST_TEMPLATES_CREATE_FROM_FILE = "templates/create_project_from_file";
+export declare const ENDPOINT_REST_TEMPLATES_IMPORT_FROM_FILE = "templates/import_into_project_from_file";
+export declare const ENDPOINT_REST_TEMPLATES_IMPORT_FROM_ID = "templates/import_into_project_from_template_id";
+export declare const ENDPOINT_REST_ACCESS_TOKENS_MIGRATE = "access_tokens/migrate_personal_token";
+export declare const ENDPOINT_REST_BACKUPS = "backups";
+export declare const ENDPOINT_REST_BACKUPS_DOWNLOAD = "backups/download";
+export declare const ENDPOINT_REST_EMAILS = "emails";
+export declare const ENDPOINT_REST_ID_MAPPINGS = "id_mappings";
+export declare const ENDPOINT_REST_MOVED_IDS = "moved_ids";
 export declare const ENDPOINT_SYNC_QUICK_ADD: string;
 export declare const ENDPOINT_SYNC = "sync";
 export declare const ENDPOINT_AUTHORIZATION = "authorize";
 export declare const ENDPOINT_GET_TOKEN = "access_token";
 export declare const ENDPOINT_REVOKE = "revoke";
+export declare const ENDPOINT_REST_WORKSPACES = "workspaces";
 export declare const ENDPOINT_WORKSPACE_INVITATIONS = "workspaces/invitations";
 export declare const ENDPOINT_WORKSPACE_INVITATIONS_ALL = "workspaces/invitations/all";
 export declare const ENDPOINT_WORKSPACE_INVITATIONS_DELETE = "workspaces/invitations/delete";
@@ -45,5 +66,15 @@ export declare const ENDPOINT_WORKSPACE_PLAN_DETAILS = "workspaces/plan_details"
 export declare const ENDPOINT_WORKSPACE_USERS = "workspaces/users";
 export declare function getWorkspaceInvitationAcceptEndpoint(inviteCode: string): string;
 export declare function getWorkspaceInvitationRejectEndpoint(inviteCode: string): string;
+export declare function getProjectInsightsActivityStatsEndpoint(projectId: string): string;
+export declare function getProjectInsightsHealthEndpoint(projectId: string): string;
+export declare function getProjectInsightsHealthContextEndpoint(projectId: string): string;
+export declare function getProjectInsightsProgressEndpoint(projectId: string): string;
+export declare function getProjectInsightsHealthAnalyzeEndpoint(projectId: string): string;
+export declare function getWorkspaceInsightsEndpoint(workspaceId: string): string;
+export declare const ENDPOINT_WORKSPACE_MEMBERS = "workspaces/members";
+export declare function getWorkspaceUserTasksEndpoint(workspaceId: string, userId: string): string;
+export declare function getWorkspaceInviteUsersEndpoint(workspaceId: string): string;
+export declare function getWorkspaceUserEndpoint(workspaceId: string, userId: string): string;
 export declare function getWorkspaceActiveProjectsEndpoint(workspaceId: number): string;
 export declare function getWorkspaceArchivedProjectsEndpoint(workspaceId: number): string;

package/dist/types/test-utils/test-defaults.d.ts

@@ -1,4 +1,4 @@
-import { Label, Section, Task, User, Attachment, Duration, Deadline, RawComment, PersonalProject } from '../types/index.js';
+import { Label, Section, Task, User, Attachment, Duration, Deadline, RawComment, PersonalProject, Reminder } from '../types/index.js';
 export declare const DEFAULT_TASK_ID = "1234";
 export declare const DEFAULT_TASK_CONTENT = "This is a task";
 export declare const DEFAULT_TASK_DESCRIPTION = "A description";
@@ -148,6 +148,10 @@ export declare const DEFAULT_COMMENT: {
     isDeleted: boolean;
     projectId?: string | undefined;
 };
+export declare const DEFAULT_REMINDER_ID = "6XGgmFQrx44wfGHr";
+export declare const DEFAULT_RELATIVE_REMINDER: Reminder;
+export declare const DEFAULT_ABSOLUTE_REMINDER: Reminder;
+export declare const DEFAULT_LOCATION_REMINDER: Reminder;
 export declare const INVALID_COMMENT: {
     isDeleted: string;
     id: string;