@todoist/sdk 0.0.1 → 19.0.0

package/dist/esm/utils/webhook-parser.js

@@ -0,0 +1,56 @@
+import { WebhookPayloadSchema } from '../types/webhooks/types.js';
+import { camelCaseKeys } from './case-conversion.js';
+/**
+ * Parses an incoming webhook request body into a typed payload.
+ *
+ * The backend sends snake_case keys (e.g. `event_name`, `user_id`, `added_at`);
+ * this converts them to camelCase and validates against
+ * {@link WebhookPayloadSchema}. Event-specific `eventData` is returned as
+ * `unknown` for events that are not yet narrowed per-resource.
+ *
+ * Pass the parsed JSON body (or any unknown value) — validation throws on
+ * unexpected shape.
+ */
+export function parseWebhookPayload(raw) {
+    return WebhookPayloadSchema.parse(camelCaseKeys(raw));
+}
+const encoder = new TextEncoder();
+function base64ToBytes(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Verifies a webhook request's HMAC signature.
+ *
+ * Todoist signs webhook deliveries with an HMAC-SHA256 of the raw request body
+ * using the app's `client_secret` as the key, base64-encoded in the
+ * `X-Todoist-Hmac-SHA256` header.
+ *
+ * Uses the Web Crypto API (`crypto.subtle`), which is available in Node ≥ 20,
+ * modern browsers, React Native (with polyfills), and edge runtimes. The
+ * comparison is constant-time.
+ *
+ * @returns `true` when the signature is valid, `false` otherwise. Never throws
+ * on malformed input.
+ */
+export async function verifyWebhookSignature({ rawBody, signature, clientSecret, }) {
+    let provided;
+    try {
+        provided = base64ToBytes(signature);
+    }
+    catch (_a) {
+        return false;
+    }
+    const key = await crypto.subtle.importKey('raw', encoder.encode(clientSecret), { name: 'HMAC', hash: 'SHA-256' }, false, ['verify']);
+    const body = typeof rawBody === 'string' ? encoder.encode(rawBody) : rawBody;
+    try {
+        return await crypto.subtle.verify('HMAC', key, provided, body);
+    }
+    catch (_b) {
+        return false;
+    }
+}

package/dist/types/authentication.d.ts

@@ -0,0 +1,262 @@
+import { CustomFetch } from './types/http.js';
+/**
+ * Options for authentication functions
+ */
+export type AuthOptions = {
+    baseUrl?: string;
+    customFetch?: CustomFetch;
+};
+/** Available OAuth2 permission scopes. */
+export declare const PERMISSIONS: readonly ["task:add", "data:read", "data:read_write", "data:delete", "project:delete", "backups:read", "billing:read", "billing:read_write", "dev:app_console"];
+/**
+ * Permission scope that can be requested during OAuth2 authorization.
+ * @see {@link https://developer.todoist.com/api/v1/#tag/Authorization}
+ */
+export type Permission = (typeof PERMISSIONS)[number];
+/** Supported token endpoint authentication methods for dynamic client registration. */
+export declare const TOKEN_ENDPOINT_AUTH_METHODS: readonly ["client_secret_post", "client_secret_basic", "none"];
+/**
+ * Authentication method used at the token endpoint.
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7591#section-2 RFC 7591 Section 2}
+ */
+export type TokenEndpointAuthMethod = (typeof TOKEN_ENDPOINT_AUTH_METHODS)[number];
+/**
+ * Parameters for registering a new OAuth client via Dynamic Client Registration.
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7591 RFC 7591}
+ */
+export type ClientRegistrationRequest = {
+    redirectUris: string[];
+    clientName?: string;
+    clientUri?: string;
+    logoUri?: string;
+    scope?: readonly Permission[];
+    grantTypes?: string[];
+    responseTypes?: string[];
+    tokenEndpointAuthMethod?: TokenEndpointAuthMethod;
+};
+type RawClientRegistrationResponse = {
+    clientId: string;
+    clientSecret?: string;
+    clientName: string;
+    redirectUris: string[];
+    scope?: string;
+    grantTypes: string[];
+    responseTypes: string[];
+    tokenEndpointAuthMethod: string;
+    clientIdIssuedAt?: number;
+    clientSecretExpiresAt?: number;
+    clientUri?: string;
+    logoUri?: string;
+};
+/**
+ * Response from a successful dynamic client registration.
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7591#section-3.2.1 RFC 7591 Section 3.2.1}
+ */
+export type ClientRegistrationResponse = Omit<RawClientRegistrationResponse, 'clientIdIssuedAt' | 'clientSecretExpiresAt' | 'scope'> & {
+    scope?: Permission[];
+    clientIdIssuedAt?: Date;
+    /** `null` indicates the client secret never expires. Absent when no secret is issued. */
+    clientSecretExpiresAt?: Date | null;
+};
+/**
+ * Parameters required to exchange an authorization code for an access token.
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization/OAuth
+ */
+export type AuthTokenRequestArgs = {
+    clientId: string;
+    clientSecret: string;
+    code: string;
+};
+/**
+ * Response from a successful OAuth2 token exchange.
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization/OAuth
+ */
+export type AuthTokenResponse = {
+    accessToken: string;
+    tokenType: string;
+    /**
+     * Refresh token for use with {@link refreshAuthToken}.
+     *
+     * Only present when the OAuth app has refresh tokens enabled — the default
+     * for new apps, and immutable once on. Apps without it receive a long-lived
+     * access token and no refresh token.
+     */
+    refreshToken?: string;
+    /** Access token lifetime in seconds. */
+    expiresIn?: number;
+    /** Space-separated granted scopes, when returned. */
+    scope?: string;
+};
+/**
+ * Parameters required to exchange a refresh token for a new access token.
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization/OAuth
+ */
+export type RefreshTokenRequestArgs = {
+    clientId: string;
+    /**
+     * Client secret. Required for confidential clients; omit for public clients
+     * registered with `tokenEndpointAuthMethod: 'none'`.
+     */
+    clientSecret?: string;
+    refreshToken: string;
+};
+/**
+ * Parameters required to revoke a token using RFC 7009 compliant endpoint.
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * const state = getAuthStateParameter()
+ * // Store state in session
+ * const authUrl = getAuthorizationUrl(clientId, ['data:read'], state)
+ * ```
+ *
+ * @returns A random UUID v4 string
+ */
+export declare function getAuthStateParameter(): string;
+/**
+ * Generates the authorization URL for the OAuth2 flow.
+ *
+ * The `clientId` can be either a traditional client ID string (e.g. from
+ * {@link registerClient}) or an HTTPS URL pointing to a client metadata document,
+ * as defined in {@link https://drafts.ietf.org/doc/draft-ietf-oauth-client-id-metadata-document/ RFC draft-ietf-oauth-client-id-metadata-document}.
+ *
+ * @example
+ * ```typescript
+ * const url = getAuthorizationUrl({
+ *   clientId: 'your-client-id',
+ *   permissions: ['data:read', 'task:add'],
+ *   state,
+ * })
+ * // Redirect user to url
+ * ```
+ *
+ * @returns The full authorization URL to redirect users to
+ * @see https://developer.todoist.com/api/v1/#tag/Authorization/OAuth
+ */
+export declare function getAuthorizationUrl({ clientId, permissions, state, baseUrl, }: {
+    clientId: string;
+    permissions: readonly Permission[];
+    state: string;
+    baseUrl?: string;
+}): string;
+export declare function getAuthToken(args: AuthTokenRequestArgs, options?: AuthOptions): Promise<AuthTokenResponse>;
+/**
+ * Exchanges a refresh token for a new access token using the OAuth2
+ * `refresh_token` grant.
+ *
+ * Only relevant for OAuth apps that have refresh tokens enabled (the default for
+ * new apps). Apps without them never receive a `refreshToken` from
+ * {@link getAuthToken}, so they have nothing to pass here — their access tokens
+ * are long-lived instead.
+ *
+ * Omit `clientSecret` for public clients registered with
+ * `tokenEndpointAuthMethod: 'none'`.
+ *
+ * @example
+ * ```typescript
+ * const { accessToken, refreshToken } = await refreshAuthToken({
+ *   clientId: 'your-client-id',
+ *   clientSecret: 'your-client-secret',
+ *   refreshToken: storedRefreshToken,
+ * })
+ * ```
+ *
+ * @returns The refreshed token. The server rotates the refresh token, so the
+ * response carries a new `refreshToken` — persist it in place of the old one.
+ * @throws {@link TodoistRequestError} If the refresh fails
+ */
+export declare function refreshAuthToken(args: RefreshTokenRequestArgs, options?: AuthOptions): Promise<AuthTokenResponse>;
+/**
+ * Revokes a token using the RFC 7009 OAuth 2.0 Token Revocation standard.
+ *
+ * This function uses HTTP Basic Authentication with client credentials and follows
+ * the RFC 7009 specification for token revocation.
+ *
+ * @example
+ * ```typescript
+ * await revokeToken({
+ *   clientId: 'your-client-id',
+ *   clientSecret: 'your-client-secret',
+ *   token: 'access-token-to-revoke'
+ * })
+ * ```
+ *
+ * @returns True if revocation was successful
+ * @see https://datatracker.ietf.org/doc/html/rfc7009
+ * @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>;
+/**
+ * Registers a new OAuth client via Dynamic Client Registration (RFC 7591).
+ *
+ * @example
+ * ```typescript
+ * const client = await registerClient({
+ *   redirectUris: ['https://example.com/callback'],
+ *   clientName: 'My App',
+ *   scope: ['data:read_write', 'task:add'],
+ * })
+ * // Use client.clientId and client.clientSecret for OAuth flows
+ * ```
+ *
+ * @returns The registered client details
+ * @throws {@link TodoistRequestError} If the registration fails
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7591 RFC 7591}
+ */
+export declare function registerClient(args: ClientRegistrationRequest, options?: AuthOptions): Promise<ClientRegistrationResponse>;
+export {};

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({ appId, file, fileName, size }: 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,23 @@
+import type { SyncRequestContext } from '../transport/sync-request.js';
+import type { CustomFetch, CustomHeaders } 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 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 apiRootBase: string;
+    protected readonly customFetch?: CustomFetch;
+    protected readonly customHeaders?: CustomHeaders;
+    constructor(context: SyncRequestContext);
+    protected get syncContext(): SyncRequestContext;
+}

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

@@ -0,0 +1,22 @@
+import type { BillingPortalUrlResponse, CancelPlanArgs, CheckoutSessionResponse, GetPricingArgs, PricesResponse, PricingResponse, ProBillingPortalArgs, ProPlanDetails, StartProTrialArgs, StartWorkspaceTrialArgs, SubscriptionInfo, UpgradeToProArgs, UpgradeWorkspaceArgs, WorkspaceBillingPortalArgs } from '../types/billing/index.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all billing-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public billing method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export declare class BillingClient extends BaseClient {
+    getSubscriptionInfo(): Promise<SubscriptionInfo>;
+    cancelPlan(args?: CancelPlanArgs, requestId?: string): Promise<BillingPortalUrlResponse>;
+    reactivatePlan(requestId?: string): Promise<SubscriptionInfo>;
+    upgradeToPro(args: UpgradeToProArgs, requestId?: string): Promise<CheckoutSessionResponse>;
+    startProTrial(args: StartProTrialArgs, requestId?: string): Promise<CheckoutSessionResponse>;
+    createProBillingPortalSession(args: ProBillingPortalArgs, requestId?: string): Promise<BillingPortalUrlResponse>;
+    getProPlanDetails(): Promise<ProPlanDetails>;
+    upgradeWorkspace(args: UpgradeWorkspaceArgs, requestId?: string): Promise<CheckoutSessionResponse>;
+    startWorkspaceTrial(args: StartWorkspaceTrialArgs, requestId?: string): Promise<CheckoutSessionResponse>;
+    createWorkspaceBillingPortalSession(args: WorkspaceBillingPortalArgs, requestId?: string): Promise<BillingPortalUrlResponse>;
+    getPrices(): Promise<PricesResponse>;
+    getPricing(args?: GetPricingArgs): Promise<PricingResponse>;
+}

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/filter-client.d.ts

@@ -0,0 +1,10 @@
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all filter-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public filter method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export declare class FilterClient extends BaseClient {
+    deleteFilter(id: string, 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[]>;
+}

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

@@ -0,0 +1,18 @@
+import type { GetProjectActivityStatsArgs, GetWorkspaceInsightsArgs, ProjectActivityStats, ProjectHealth, ProjectHealthContext, ProjectProgress, WorkspaceInsights } from '../types/insights/index.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 declare class InsightsClient extends BaseClient {
+    getProjectActivityStats(projectId: string, args?: GetProjectActivityStatsArgs): Promise<ProjectActivityStats>;
+    getProjectHealth(projectId: string): Promise<ProjectHealth>;
+    getProjectHealthContext(projectId: string): Promise<ProjectHealthContext>;
+    getProjectProgress(projectId: string): Promise<ProjectProgress>;
+    getWorkspaceInsights(workspaceId: string, args?: GetWorkspaceInsightsArgs): Promise<WorkspaceInsights>;
+    analyzeProjectHealth(projectId: string, requestId?: string): Promise<ProjectHealth>;
+}

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

@@ -0,0 +1,19 @@
+import type { AddLabelArgs, GetLabelsArgs, GetLabelsResponse, GetSharedLabelsArgs, GetSharedLabelsResponse, Label, RemoveSharedLabelArgs, RenameSharedLabelArgs, SearchLabelsArgs, UpdateLabelArgs } from '../types/labels/index.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 declare class LabelClient extends BaseClient {
+    getLabel(id: string): Promise<Label>;
+    getLabels(args?: GetLabelsArgs): Promise<GetLabelsResponse>;
+    searchLabels(args: SearchLabelsArgs): Promise<GetLabelsResponse>;
+    addLabel(args: AddLabelArgs, requestId?: string): Promise<Label>;
+    updateLabel(id: string, args: UpdateLabelArgs, requestId?: string): Promise<Label>;
+    deleteLabel(id: string, requestId?: string): Promise<boolean>;
+    getSharedLabels(args?: GetSharedLabelsArgs): Promise<GetSharedLabelsResponse>;
+    renameSharedLabel(args: RenameSharedLabelArgs): Promise<boolean>;
+    removeSharedLabel(args: RemoveSharedLabelArgs): Promise<boolean>;
+}

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

@@ -0,0 +1,12 @@
+import type { ProductivityStats } from '../types/productivity/index.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 declare class ProductivityClient extends BaseClient {
+    getProductivityStats(): Promise<ProductivityStats>;
+}

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

@@ -0,0 +1,22 @@
+import type { AddProjectArgs, GetArchivedProjectsArgs, GetArchivedProjectsCountArgs, GetArchivedProjectsCountResponse, GetArchivedProjectsResponse, GetFullProjectArgs, GetFullProjectResponse, GetProjectCollaboratorsArgs, GetProjectCollaboratorsResponse, GetProjectPermissionsResponse, GetProjectsArgs, GetProjectsResponse, JoinProjectResponse, MoveProjectToPersonalArgs, MoveProjectToWorkspaceArgs, PersonalProject, PersonalProjectCapacity, SearchProjectsArgs, UpdateProjectArgs, WorkspaceProject } from '../types/projects/index.js';
+import { BaseClient } from './base-client.js';
+export declare class ProjectClient extends BaseClient {
+    getProject(id: string): Promise<PersonalProject | WorkspaceProject>;
+    getProjects(args?: GetProjectsArgs): Promise<GetProjectsResponse>;
+    searchProjects(args: SearchProjectsArgs): Promise<GetProjectsResponse>;
+    getArchivedProjects(args?: GetArchivedProjectsArgs): Promise<GetArchivedProjectsResponse>;
+    addProject(args: AddProjectArgs, requestId?: string): Promise<PersonalProject | WorkspaceProject>;
+    updateProject(id: string, args: UpdateProjectArgs, requestId?: string): Promise<PersonalProject | WorkspaceProject>;
+    deleteProject(id: string, requestId?: string): Promise<boolean>;
+    archiveProject(id: string, requestId?: string): Promise<PersonalProject | WorkspaceProject>;
+    unarchiveProject(id: string, requestId?: string): Promise<PersonalProject | WorkspaceProject>;
+    moveProjectToWorkspace(args: MoveProjectToWorkspaceArgs, requestId?: string): Promise<PersonalProject | WorkspaceProject>;
+    moveProjectToPersonal(args: MoveProjectToPersonalArgs, requestId?: string): Promise<PersonalProject | WorkspaceProject>;
+    getArchivedProjectsCount(args?: GetArchivedProjectsCountArgs): Promise<GetArchivedProjectsCountResponse>;
+    getProjectPermissions(): Promise<GetProjectPermissionsResponse>;
+    getFullProject(id: string, args?: GetFullProjectArgs): Promise<GetFullProjectResponse>;
+    joinProject(id: string, requestId?: string): Promise<JoinProjectResponse>;
+    getProjectCollaborators(projectId: string, args?: GetProjectCollaboratorsArgs): Promise<GetProjectCollaboratorsResponse>;
+    getPersonalProjectCapacity(): Promise<PersonalProjectCapacity>;
+    private countActivePersonalProjects;
+}

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

@@ -0,0 +1,25 @@
+import type { Reminder } from '../types/index.js';
+import type { AddLocationReminderArgs, AddReminderArgs, GetLocationRemindersArgs, GetLocationRemindersResponse, GetRemindersArgs, GetRemindersResponse, UpdateLocationReminderArgs, UpdateReminderArgs } from '../types/reminders/index.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 declare class ReminderClient extends BaseClient {
+    getReminders(args?: GetRemindersArgs): Promise<GetRemindersResponse>;
+    getLocationReminders(args?: GetLocationRemindersArgs): Promise<GetLocationRemindersResponse>;
+    getReminder(id: string): Promise<Reminder>;
+    getLocationReminder(id: string): Promise<Reminder>;
+    addReminder(args: AddReminderArgs, requestId?: string): Promise<Reminder>;
+    addLocationReminder(args: AddLocationReminderArgs, requestId?: string): Promise<Reminder>;
+    updateReminder(id: string, args: UpdateReminderArgs, requestId?: string): Promise<Reminder>;
+    updateLocationReminder(id: string, args: UpdateLocationReminderArgs, requestId?: string): Promise<Reminder>;
+    deleteReminder(id: string, requestId?: string): Promise<boolean>;
+    deleteLocationReminder(id: string, requestId?: string): Promise<boolean>;
+}

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

@@ -0,0 +1,18 @@
+import type { AddSectionArgs, GetSectionsArgs, GetSectionsResponse, SearchSectionsArgs, Section, UpdateSectionArgs } from '../types/sections/index.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all section-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public section method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export declare class SectionClient extends BaseClient {
+    getSections(args?: GetSectionsArgs): Promise<GetSectionsResponse>;
+    searchSections(args: SearchSectionsArgs): Promise<GetSectionsResponse>;
+    getSection(id: string): Promise<Section>;
+    addSection(args: AddSectionArgs, requestId?: string): Promise<Section>;
+    updateSection(id: string, args: UpdateSectionArgs, requestId?: string): Promise<Section>;
+    deleteSection(id: string, requestId?: string): Promise<boolean>;
+    archiveSection(id: string, requestId?: string): Promise<Section>;
+    unarchiveSection(id: string, requestId?: string): Promise<Section>;
+}