@doist/todoist-sdk 9.0.0 → 9.1.0

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

@@ -95,6 +95,7 @@ export async function request(args) {
                 break;
             case 'POST':
             case 'PUT':
+            case 'PATCH':
             case 'DELETE': {
                 // Convert payload from camelCase to snake_case
                 // Note: While DELETE with body is uncommon, the Todoist API uses it for some endpoints

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

@@ -0,0 +1,72 @@
+import { ENDPOINT_SYNC } from '../consts/endpoints.js';
+import { TodoistRequestError } from '../types/index.js';
+import { DATE_FORMAT_TO_API, TIME_FORMAT_TO_API, DAY_OF_WEEK_TO_API, } from '../types/sync/index.js';
+import { spreadIfDefined } from '../utils/request-helpers.js';
+import { parseSyncResponse } from '../utils/validators.js';
+import { request } from './http-client.js';
+function serializeUserUpdateArgs(args) {
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, args), spreadIfDefined(args.dateFormat, (v) => ({
+        dateFormat: DATE_FORMAT_TO_API[v],
+    }))), spreadIfDefined(args.timeFormat, (v) => ({
+        timeFormat: TIME_FORMAT_TO_API[v],
+    }))), spreadIfDefined(args.startDay, (v) => ({
+        startDay: DAY_OF_WEEK_TO_API[v],
+    }))), spreadIfDefined(args.nextWeek, (v) => ({
+        nextWeek: DAY_OF_WEEK_TO_API[v],
+    })));
+}
+function serializeTaskUpdateDateCompleteArgs(args) {
+    return Object.assign(Object.assign(Object.assign({}, args), { isForward: args.isForward ? 1 : 0 }), spreadIfDefined(args.resetSubtasks, (v) => ({
+        resetSubtasks: v ? 1 : 0,
+    })));
+}
+function serializeUpdateGoalsArgs(args) {
+    return Object.assign(Object.assign(Object.assign({}, args), spreadIfDefined(args.vacationMode, (v) => ({ vacationMode: v ? 1 : 0 }))), 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.
+ */
+export 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 request({
+        httpMethod: 'POST',
+        baseUri: ctx.syncApiBase,
+        relativePath: 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 TodoistRequestError(value.error, value.httpCode, value.errorExtra);
+        });
+    }
+    return parseSyncResponse(response.data);
+}

package/dist/esm/types/apps/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/apps/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/apps/types.js

@@ -0,0 +1,248 @@
+import { z } from 'zod';
+import { StringOrNumberSchema } from '../common.js';
+import { UI_EXTENSION_TYPES } from '../ui-extensions/types.js';
+/**
+ * Available statuses for a developer application.
+ */
+export const APP_STATUSES = ['public'];
+export const AppStatusSchema = z.enum(APP_STATUSES);
+/**
+ * Webhook event types that can be subscribed to.
+ *
+ * These are the friendly public names the backend uses in webhook payloads.
+ * The on-the-wire config endpoint uses a different (legacy) form (see
+ * {@link WEBHOOK_EVENT_WIRE_NAMES}); the SDK converts between the two
+ * so consumers only ever work with these pretty names.
+ *
+ * @see https://developer.todoist.com/sync/v1/#webhooks
+ */
+export const WEBHOOK_EVENTS = [
+    'item:added',
+    'item:updated',
+    'item:completed',
+    'item:uncompleted',
+    'item:deleted',
+    'note:added',
+    'note:updated',
+    'note:deleted',
+    'project:added',
+    'project:updated',
+    'project:deleted',
+    'project:archived',
+    'project:unarchived',
+    'section:added',
+    'section:updated',
+    'section:deleted',
+    'section:archived',
+    'section:unarchived',
+    'label:added',
+    'label:updated',
+    'label:deleted',
+    'filter:added',
+    'filter:updated',
+    'filter:deleted',
+    'reminder:fired',
+];
+export const WebhookEventSchema = z.enum(WEBHOOK_EVENTS);
+/**
+ * Raw wire-format webhook event names used by the config endpoint
+ * (`POST/GET /apps/<id>/webhook`). Exported for completeness — prefer
+ * {@link WEBHOOK_EVENTS} when working with the SDK.
+ */
+export const WEBHOOK_EVENT_WIRE_NAMES = [
+    'e_item_added',
+    'e_item_updated',
+    'e_item_completed',
+    'e_item_uncompleted',
+    'e_item_deleted',
+    'e_note_added',
+    'e_note_updated',
+    'e_note_deleted',
+    'e_project_added',
+    'e_project_updated',
+    'e_project_deleted',
+    'e_project_archived',
+    'e_project_unarchived',
+    'e_section_added',
+    'e_section_updated',
+    'e_section_deleted',
+    'e_section_archived',
+    'e_section_unarchived',
+    'e_label_added',
+    'e_label_updated',
+    'e_label_deleted',
+    'e_filter_added',
+    'e_filter_updated',
+    'e_filter_deleted',
+    'e_reminder_fired',
+];
+export const WebhookEventWireNameSchema = z.enum(WEBHOOK_EVENT_WIRE_NAMES);
+/**
+ * Translates a wire-format event name (`'e_item_added'`) to its pretty form (`'item:added'`).
+ */
+export function webhookEventFromWireName(wireName) {
+    // Strip leading `e_`, replace first `_` with `:`. The resulting string is
+    // guaranteed to be a `WebhookEvent` by construction of the two const arrays.
+    return wireName.slice(2).replace('_', ':');
+}
+/**
+ * Translates a pretty event name (`'item:added'`) to its wire-format form (`'e_item_added'`).
+ */
+export function webhookEventToWireName(event) {
+    return ('e_' + event.replace(':', '_'));
+}
+/**
+ * Available statuses for an app webhook.
+ */
+export const WEBHOOK_STATUSES = ['active', 'invalid'];
+export const WebhookStatusSchema = z.enum(WEBHOOK_STATUSES);
+/**
+ * Supported webhook payload versions. v9 is deprecated and intentionally excluded.
+ */
+export const WEBHOOK_VERSIONS = ['1'];
+export const WebhookVersionSchema = z.enum(WEBHOOK_VERSIONS);
+/**
+ * Available installation types for an app installation.
+ */
+export const INSTALLATION_TYPES = ['user'];
+export const InstallationTypeSchema = z.enum(INSTALLATION_TYPES);
+/**
+ * Transforms a comma-separated scope string into `string[] | null`.
+ *
+ * The backend stores `app_token_scopes` as a single comma-separated string
+ * (e.g. `"data:read,task:add"`). Reads are exposed as `string[]` (rather than
+ * `Permission[]`) so that newly added backend scopes don't break parsing —
+ * writes accept `Permission` for autocomplete while still permitting `string`
+ * (via `UpdateAppArgs`), so a fetched `App.appTokenScopes` can be round-tripped
+ * back into `updateApp()` without casts.
+ *
+ * Preserves `null` on read (backend returns `null` for apps that have had
+ * their scopes cleared via `updateApp({ appTokenScopes: null })`) so the
+ * read and write shapes line up and information is not lost.
+ */
+export const AppTokenScopesSchema = z
+    .string()
+    .nullable()
+    .transform((value) => {
+    if (value === null)
+        return null;
+    if (value === '')
+        return [];
+    return value.split(',').filter(Boolean);
+});
+/**
+ * Schema for a developer application.
+ * @see https://developer.todoist.com/api/v1/#tag/Apps
+ */
+export const AppSchema = z.object({
+    id: StringOrNumberSchema,
+    status: AppStatusSchema,
+    displayName: z.string(),
+    userId: StringOrNumberSchema,
+    createdAt: z.coerce.date(),
+    serviceUrl: z.string().nullable(),
+    oauthRedirectUri: z.string().nullable(),
+    description: z.string().nullable(),
+    iconSm: z.string().nullable(),
+    iconMd: z.string().nullable(),
+    iconLg: z.string().nullable(),
+    appTokenScopes: AppTokenScopesSchema,
+});
+/**
+ * Schema for a developer application that includes the user count.
+ * Returned by most endpoints that manage a single app (get, update, delete).
+ */
+export const AppWithUserCountSchema = AppSchema.extend({
+    userCount: z.number().int(),
+});
+/**
+ * OAuth client credentials for a developer application.
+ */
+export const AppSecretsSchema = z.object({
+    clientId: z.string(),
+    clientSecret: z.string(),
+});
+/**
+ * Webhook verification token for a developer application.
+ */
+export const AppVerificationTokenSchema = z.object({
+    verificationToken: z.string(),
+});
+/**
+ * Developer test access token for a developer application.
+ */
+export const AppTestTokenSchema = z.object({
+    accessToken: z.string().nullish(),
+});
+/**
+ * Distribution token for a developer application.
+ */
+export const AppDistributionTokenSchema = z.object({
+    distributionToken: z.string(),
+});
+/**
+ * Subset of an app returned when resolving by distribution token — used by the installation flow.
+ * Includes a lightweight list of the app's UI extensions (not full `UIExtension` records).
+ */
+export const AppByDistributionTokenUiExtensionSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    icon: z.string().nullable(),
+    extensionType: z.enum(UI_EXTENSION_TYPES),
+});
+export const AppByDistributionTokenSchema = z.object({
+    id: StringOrNumberSchema,
+    displayName: z.string(),
+    description: z.string().nullable(),
+    iconMd: z.string().nullable(),
+    appTokenScopes: AppTokenScopesSchema,
+    uiExtensions: z.array(AppByDistributionTokenUiExtensionSchema),
+});
+/**
+ * Schema for an app webhook.
+ *
+ * Events arrive from the wire in their `e_*` form and are transformed to
+ * their pretty `item:added`-style names for SDK consumers.
+ */
+export const AppWebhookSchema = z.object({
+    status: WebhookStatusSchema,
+    callbackUrl: z.string(),
+    version: WebhookVersionSchema,
+    events: z.array(WebhookEventWireNameSchema.transform(webhookEventFromWireName)),
+});
+/**
+ * Lightweight view of an app embedded in an installation record.
+ * Mirrors `AppSchema` shape — backend returns the same `ApplicationRestView`.
+ */
+export const InstalledIntegrationSchema = AppSchema;
+/**
+ * Schema for an installed application (integration installed to a user's account).
+ */
+export const AppInstallationSchema = z.object({
+    id: StringOrNumberSchema,
+    creator: StringOrNumberSchema,
+    createdTs: z.number().int(),
+    installationType: InstallationTypeSchema,
+    appTokenScopesValidated: z.boolean(),
+    integration: InstalledIntegrationSchema.nullable(),
+});
+/**
+ * Lightweight app info included on a user authorization record.
+ */
+export const UserAuthorizationAppSchema = z.object({
+    id: StringOrNumberSchema,
+    displayName: z.string(),
+    description: z.string().nullable(),
+    serviceUrl: z.string().nullable(),
+    iconMd: z.string().nullable(),
+});
+/**
+ * Schema for a user authorization entry — a token the user has granted to a third-party app.
+ */
+export const UserAuthorizationSchema = z.object({
+    accessTokenId: StringOrNumberSchema,
+    scope: z.array(z.string()),
+    scopeDescriptions: z.array(z.string()),
+    createdAt: z.coerce.date(),
+    app: UserAuthorizationAppSchema.nullable(),
+});

package/dist/esm/types/index.js

@@ -18,3 +18,5 @@ export * from './templates/index.js';
 export * from './errors.js';
 export * from './http.js';
 export * from './sync/index.js';
+export * from './apps/index.js';
+export * from './ui-extensions/index.js';

package/dist/esm/types/ui-extensions/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/ui-extensions/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/ui-extensions/types.js

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { StringOrNumberSchema } from '../common.js';
+/**
+ * Discriminator values for the UI extension variants.
+ * Exposed as an enum-like object because the values are used in `z.literal()`
+ * across multiple variant schemas (see AGENTS.md "Discriminated unions" exception).
+ */
+export const UiExtensionTypeEnum = {
+    ContextMenu: 'context-menu',
+    Composer: 'composer',
+    Settings: 'settings',
+};
+/**
+ * All UI extension type values.
+ */
+export const UI_EXTENSION_TYPES = [
+    UiExtensionTypeEnum.ContextMenu,
+    UiExtensionTypeEnum.Composer,
+    UiExtensionTypeEnum.Settings,
+];
+/**
+ * Context locations where a context-menu extension can appear.
+ */
+export const CONTEXT_MENU_EXTENSION_CONTEXTS = ['project', 'task'];
+export const ContextMenuExtensionContextSchema = z.enum(CONTEXT_MENU_EXTENSION_CONTEXTS);
+/**
+ * Composer locations where a composer extension can appear.
+ */
+export const COMPOSER_EXTENSION_CONTEXTS = ['task', 'comment'];
+export const ComposerExtensionContextSchema = z.enum(COMPOSER_EXTENSION_CONTEXTS);
+/**
+ * Shared fields across all UI extension variants.
+ */
+export const UiExtensionBaseSchema = z.object({
+    id: StringOrNumberSchema,
+    integrationId: StringOrNumberSchema,
+    extensionId: z.string(),
+    url: z.string(),
+    icon: z.string().nullable(),
+    name: z.string(),
+    description: z.string(),
+    width: z.number().int().nullable(),
+    height: z.number().int().nullable(),
+    defVersion: z.number().int(),
+    minimumCardistVersion: z.string(),
+});
+/**
+ * Schema for a context-menu UI extension.
+ */
+export const ContextMenuExtensionSchema = UiExtensionBaseSchema.extend({
+    extensionType: z.literal(UiExtensionTypeEnum.ContextMenu),
+    contextType: ContextMenuExtensionContextSchema,
+});
+/**
+ * Schema for a composer UI extension.
+ */
+export const ComposerExtensionSchema = UiExtensionBaseSchema.extend({
+    extensionType: z.literal(UiExtensionTypeEnum.Composer),
+    composerType: ComposerExtensionContextSchema,
+});
+/**
+ * Schema for a settings UI extension.
+ */
+export const SettingsExtensionSchema = UiExtensionBaseSchema.extend({
+    extensionType: z.literal(UiExtensionTypeEnum.Settings),
+});
+/**
+ * Discriminated union of all UI extension variants.
+ */
+export const UiExtensionSchema = z.discriminatedUnion('extensionType', [
+    ContextMenuExtensionSchema,
+    ComposerExtensionSchema,
+    SettingsExtensionSchema,
+]);

package/dist/esm/utils/headers.js

@@ -0,0 +1,13 @@
+/**
+ * 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`).
+ */
+export function headersToRecord(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Joins path segments using `/` separator.
+ * @param segments A list of **valid** path segments.
+ * @returns A joined path.
+ */
+export 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.
+ */
+export function spreadIfDefined(value, fn) {
+    return value !== undefined ? fn(value) : {};
+}

package/dist/esm/utils/validators.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ActivityEventSchema } from '../types/activity/types.js';
+import { AppSchema, AppWithUserCountSchema, AppSecretsSchema, AppVerificationTokenSchema, AppTestTokenSchema, AppDistributionTokenSchema, AppByDistributionTokenSchema, AppWebhookSchema, AppInstallationSchema, UserAuthorizationSchema, } from '../types/apps/types.js';
 import { BackupSchema } from '../types/backups/types.js';
 import { AttachmentSchema, CommentSchema } from '../types/comments/types.js';
 import { IdMappingSchema, MovedIdSchema } from '../types/id-mappings/types.js';
@@ -10,6 +11,7 @@ import { WorkspaceProjectSchema, ProjectSchema } from '../types/projects/types.j
 import { SectionSchema } from '../types/sections/types.js';
 import { SyncResponseSchema } from '../types/sync/response.js';
 import { TaskSchema } from '../types/tasks/types.js';
+import { UiExtensionSchema } from '../types/ui-extensions/types.js';
 import { UserSchema, CurrentUserSchema } from '../types/users/types.js';
 import { WorkspaceUserSchema, WorkspaceInvitationSchema, WorkspacePlanDetailsSchema, JoinWorkspaceResultSchema, WorkspaceSchema, MemberActivityInfoSchema, WorkspaceUserTaskSchema, } from '../types/workspaces/types.js';
 import { FilterSchema, CollaboratorSchema, CollaboratorStateSchema, FolderSchema, NoteSchema, TooltipsSchema, WorkspaceFilterSchema, WorkspaceGoalSchema, CalendarSchema, CalendarAccountSchema, ReminderSchema, LocationReminderSchema, CompletedInfoSchema, ViewOptionsSchema, ProjectViewOptionsDefaultsSchema, UserPlanLimitsSchema, LiveNotificationSchema, SyncWorkspaceSchema, SyncUserSchema, UserSettingsSchema, SuggestionSchema, } from '../types/sync/resources/index.js';
@@ -76,3 +78,15 @@ export const { validate: validateSuggestion, validateArray: validateSuggestionAr
 export function parseSyncResponse(raw) {
     return SyncResponseSchema.parse(raw);
 }
+// App management validators
+export const { validate: validateApp, validateArray: validateAppArray } = createValidator(AppSchema);
+export const { validate: validateAppWithUserCount } = createValidator(AppWithUserCountSchema);
+export const { validate: validateAppSecrets } = createValidator(AppSecretsSchema);
+export const { validate: validateAppVerificationToken } = createValidator(AppVerificationTokenSchema);
+export const { validate: validateAppTestToken } = createValidator(AppTestTokenSchema);
+export const { validate: validateAppDistributionToken } = createValidator(AppDistributionTokenSchema);
+export const { validate: validateAppByDistributionToken } = createValidator(AppByDistributionTokenSchema);
+export const { validate: validateAppWebhook } = createValidator(AppWebhookSchema);
+export const { validate: validateAppInstallation, validateArray: validateAppInstallationArray } = createValidator(AppInstallationSchema);
+export const { validate: validateUserAuthorization, validateArray: validateUserAuthorizationArray, } = createValidator(UserAuthorizationSchema);
+export const { validate: validateUiExtension, validateArray: validateUiExtensionArray } = createValidator(UiExtensionSchema);

package/dist/types/authentication.d.ts

@@ -7,7 +7,7 @@ export type AuthOptions = {
     customFetch?: CustomFetch;
 };
 /** Available OAuth2 permission scopes. */
-export declare const PERMISSIONS: readonly ["task:add", "data:read", "data:read_write", "data:delete", "project:delete", "backups:read"];
+export declare const PERMISSIONS: readonly ["task:add", "data:read", "data:read_write", "data:delete", "project:delete", "backups:read", "dev:app_console"];
 /**
  * Permission scope that can be requested during OAuth2 authorization.
  * @see {@link https://developer.todoist.com/api/v1/#tag/Authorization}

package/dist/types/clients/activity-client.d.ts

@@ -0,0 +1,12 @@
+import type { GetActivityLogsArgs, GetActivityLogsResponse } from '../types/activity/index.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 declare class ActivityClient extends BaseClient {
+    getActivityLogs(args?: GetActivityLogsArgs): Promise<GetActivityLogsResponse>;
+}

package/dist/types/clients/app-client.d.ts

@@ -0,0 +1,37 @@
+import type { AddAppArgs, App, AppByDistributionToken, AppDistributionToken, AppInstallation, AppSecrets, AppTestToken, AppVerificationToken, AppWebhook, AppWithUserCount, InstallAppArgs, RevokeUserAuthorizationArgs, UpdateAppArgs, UpdateAppInstallationArgs, UpdateAppWebhookArgs, UploadAppIconArgs, UserAuthorization } from '../types/apps/index.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all developer-app management endpoints
+ * (apps, secrets, tokens, webhooks, installations, user authorizations).
+ * All endpoints require the `dev:app_console` OAuth scope.
+ *
+ * Instantiated by `TodoistApi`; every public app-management method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing JSDoc.
+ */
+export declare class AppClient extends BaseClient {
+    getApps(requestId?: string): Promise<App[]>;
+    getApp(appId: string, requestId?: string): Promise<AppWithUserCount>;
+    addApp(args: AddAppArgs, requestId?: string): Promise<App>;
+    updateApp(appId: string, args: UpdateAppArgs, requestId?: string): Promise<AppWithUserCount>;
+    deleteApp(appId: string, requestId?: string): Promise<boolean>;
+    getAppSecrets(appId: string, requestId?: string): Promise<AppSecrets>;
+    resetAppClientSecret(appId: string, requestId?: string): Promise<AppWithUserCount>;
+    revokeAppTokens(appId: string, requestId?: string): Promise<AppWithUserCount>;
+    uploadAppIcon(args: UploadAppIconArgs, requestId?: string): Promise<AppWithUserCount>;
+    getAppTestToken(appId: string, requestId?: string): Promise<AppTestToken>;
+    createAppTestToken(appId: string, requestId?: string): Promise<AppTestToken>;
+    getAppDistributionToken(appId: string, requestId?: string): Promise<AppDistributionToken>;
+    getAppVerificationToken(appId: string, requestId?: string): Promise<AppVerificationToken>;
+    resetAppVerificationToken(appId: string, requestId?: string): Promise<AppVerificationToken>;
+    getAppByDistributionToken(distributionToken: string, requestId?: string): Promise<AppByDistributionToken>;
+    getAppWebhook(appId: string, requestId?: string): Promise<AppWebhook | null>;
+    updateAppWebhook(args: UpdateAppWebhookArgs, requestId?: string): Promise<AppWebhook>;
+    deleteAppWebhook(appId: string, requestId?: string): Promise<boolean>;
+    getAppInstallations(requestId?: string): Promise<AppInstallation[]>;
+    installApp(args: InstallAppArgs, requestId?: string): Promise<AppInstallation>;
+    getAppInstallation(installationId: string, requestId?: string): Promise<AppInstallation>;
+    updateAppInstallation(installationId: string, args: UpdateAppInstallationArgs, requestId?: string): Promise<AppInstallation>;
+    uninstallApp(installationId: string, requestId?: string): Promise<boolean>;
+    getUserAuthorizations(requestId?: string): Promise<UserAuthorization[]>;
+    revokeUserAuthorization(args: RevokeUserAuthorizationArgs, requestId?: string): Promise<boolean>;
+}

package/dist/types/clients/backup-client.d.ts

@@ -0,0 +1,14 @@
+import type { Backup, DownloadBackupArgs, GetBackupsArgs } from '../types/backups/index.js';
+import type { FileResponse } from '../types/http.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 declare class BackupClient extends BaseClient {
+    getBackups(args?: GetBackupsArgs): Promise<Backup[]>;
+    downloadBackup(args: DownloadBackupArgs): Promise<FileResponse>;
+}

package/dist/types/clients/base-client.d.ts

@@ -0,0 +1,21 @@
+import type { SyncRequestContext } from '../transport/sync-request.js';
+import type { CustomFetch } from '../types/http.js';
+/**
+ * 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 declare abstract class BaseClient {
+    protected readonly authToken: string;
+    protected readonly syncApiBase: string;
+    protected readonly customFetch?: CustomFetch;
+    constructor(context: SyncRequestContext);
+    protected get syncContext(): SyncRequestContext;
+}

package/dist/types/clients/comment-client.d.ts

@@ -0,0 +1,15 @@
+import type { AddCommentArgs, Comment, GetCommentsResponse, GetProjectCommentsArgs, GetTaskCommentsArgs, UpdateCommentArgs } from '../types/comments/index.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 declare class CommentClient extends BaseClient {
+    getComments(args: GetTaskCommentsArgs | GetProjectCommentsArgs): Promise<GetCommentsResponse>;
+    getComment(id: string): Promise<Comment>;
+    addComment(args: AddCommentArgs, requestId?: string): Promise<Comment>;
+    updateComment(id: string, args: UpdateCommentArgs, requestId?: string): Promise<Comment>;
+    deleteComment(id: string, requestId?: string): Promise<boolean>;
+}

package/dist/types/clients/email-client.d.ts

@@ -0,0 +1,13 @@
+import type { DisableEmailArgs, GetOrCreateEmailArgs, GetOrCreateEmailResponse } from '../types/emails/index.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 declare class EmailClient extends BaseClient {
+    getOrCreateEmailForwarding(args: GetOrCreateEmailArgs, requestId?: string): Promise<GetOrCreateEmailResponse>;
+    disableEmailForwarding(args: DisableEmailArgs, requestId?: string): Promise<boolean>;
+}

package/dist/types/clients/folder-client.d.ts

@@ -0,0 +1,16 @@
+import type { AddFolderArgs, GetFoldersArgs, GetFoldersResponse, UpdateFolderArgs } from '../types/folders/index.js';
+import type { Folder } from '../types/sync/resources/folders.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 declare class FolderClient extends BaseClient {
+    getFolders(args: GetFoldersArgs): Promise<GetFoldersResponse>;
+    getFolder(id: string): Promise<Folder>;
+    addFolder(args: AddFolderArgs, requestId?: string): Promise<Folder>;
+    updateFolder(id: string, args: UpdateFolderArgs, requestId?: string): Promise<Folder>;
+    deleteFolder(id: string, requestId?: string): Promise<boolean>;
+}

package/dist/types/clients/id-mapping-client.d.ts

@@ -0,0 +1,13 @@
+import type { GetIdMappingsArgs, GetMovedIdsArgs, IdMapping, MovedId } from '../types/id-mappings/index.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 declare class IdMappingClient extends BaseClient {
+    getIdMappings(args: GetIdMappingsArgs): Promise<IdMapping[]>;
+    getMovedIds(args: GetMovedIdsArgs): Promise<MovedId[]>;
+}