@todoist/mcp 0.0.1 → 15.0.0

package/dist/tools/manage-assignments.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+export type OperationResult = {
+    taskId: string;
+    success: boolean;
+    error?: string;
+    originalAssigneeId?: string;
+    newAssigneeId?: string;
+};
+declare const manageAssignments: {
+    name: "manage-assignments";
+    description: string;
+    parameters: {
+        operation: z.ZodEnum<{
+            assign: "assign";
+            unassign: "unassign";
+            reassign: "reassign";
+        }>;
+        taskIds: z.ZodArray<z.ZodString>;
+        responsibleUser: z.ZodOptional<z.ZodString>;
+        fromAssigneeUser: z.ZodOptional<z.ZodString>;
+        dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    };
+    outputSchema: {
+        results: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodString;
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+            originalAssigneeId: z.ZodOptional<z.ZodString>;
+            newAssigneeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        summary: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            succeeded: z.ZodNumber;
+            failed: z.ZodNumber;
+            dryRun: z.ZodBoolean;
+        }, z.core.$strip>>;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: true;
+        idempotentHint: false;
+        openWorldHint: true;
+    };
+    execute(args: {
+        operation: "assign" | "unassign" | "reassign";
+        taskIds: string[];
+        dryRun: boolean;
+        responsibleUser?: string | undefined;
+        fromAssigneeUser?: string | undefined;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            operation: "unassign";
+            results: OperationResult[];
+            totalRequested: number;
+            successful: number;
+            failed: number;
+            dryRun: boolean;
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            operation: "assign" | "reassign";
+            results: OperationResult[];
+            totalRequested: number;
+            successful: number;
+            failed: number;
+            dryRun: boolean;
+        };
+    }>;
+};
+export { manageAssignments };
+//# sourceMappingURL=manage-assignments.d.ts.map

package/dist/tools/manage-assignments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manage-assignments.d.ts","sourceRoot":"","sources":["../../src/tools/manage-assignments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2CvB,MAAM,MAAM,eAAe,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AA+BD,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0RwC,CAAA;AAuF/D,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/tools/project-management.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+declare const projectManagement: {
+    name: "project-management";
+    description: string;
+    parameters: {
+        action: z.ZodEnum<{
+            archive: "archive";
+            unarchive: "unarchive";
+        }>;
+        projectId: z.ZodString;
+    };
+    outputSchema: {
+        project: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            color: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+                berry_red: "berry_red";
+                red: "red";
+                orange: "orange";
+                yellow: "yellow";
+                olive_green: "olive_green";
+                lime_green: "lime_green";
+                green: "green";
+                mint_green: "mint_green";
+                teal: "teal";
+                sky_blue: "sky_blue";
+                light_blue: "light_blue";
+                blue: "blue";
+                grape: "grape";
+                violet: "violet";
+                lavender: "lavender";
+                magenta: "magenta";
+                salmon: "salmon";
+                charcoal: "charcoal";
+                grey: "grey";
+                taupe: "taupe";
+            }>>>;
+            isFavorite: z.ZodBoolean;
+            isShared: z.ZodBoolean;
+            parentId: z.ZodOptional<z.ZodString>;
+            inboxProject: z.ZodBoolean;
+            viewStyle: z.ZodString;
+            workspaceId: z.ZodOptional<z.ZodString>;
+            folderId: z.ZodOptional<z.ZodString>;
+            childOrder: z.ZodNumber;
+            isArchived: z.ZodBoolean;
+        }, z.core.$strip>;
+        success: z.ZodBoolean;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        action: "archive" | "unarchive";
+        projectId: string;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            project: {
+                id: string;
+                name: string;
+                description: string;
+                color: import('@doist/todoist-sdk').ColorKey;
+                isFavorite: boolean;
+                isShared: boolean;
+                parentId: string | undefined;
+                inboxProject: boolean;
+                viewStyle: string;
+                workspaceId: string | undefined;
+                folderId: string | undefined;
+                childOrder: number;
+                isArchived: boolean;
+            };
+            success: true;
+        };
+    }>;
+};
+export { projectManagement };
+//# sourceMappingURL=project-management.d.ts.map

package/dist/tools/project-management.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-management.d.ts","sourceRoot":"","sources":["../../src/tools/project-management.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAoBvB,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCwC,CAAA;AAE/D,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/tools/project-move.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+declare const projectMove: {
+    name: "project-move";
+    description: string;
+    parameters: {
+        action: z.ZodEnum<{
+            "move-to-workspace": "move-to-workspace";
+            "move-to-personal": "move-to-personal";
+        }>;
+        projectId: z.ZodString;
+        workspaceId: z.ZodOptional<z.ZodString>;
+        folderId: z.ZodOptional<z.ZodString>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            public: "public";
+            restricted: "restricted";
+            team: "team";
+        }>>;
+    };
+    outputSchema: {
+        project: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            color: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+                berry_red: "berry_red";
+                red: "red";
+                orange: "orange";
+                yellow: "yellow";
+                olive_green: "olive_green";
+                lime_green: "lime_green";
+                green: "green";
+                mint_green: "mint_green";
+                teal: "teal";
+                sky_blue: "sky_blue";
+                light_blue: "light_blue";
+                blue: "blue";
+                grape: "grape";
+                violet: "violet";
+                lavender: "lavender";
+                magenta: "magenta";
+                salmon: "salmon";
+                charcoal: "charcoal";
+                grey: "grey";
+                taupe: "taupe";
+            }>>>;
+            isFavorite: z.ZodBoolean;
+            isShared: z.ZodBoolean;
+            parentId: z.ZodOptional<z.ZodString>;
+            inboxProject: z.ZodBoolean;
+            viewStyle: z.ZodString;
+            workspaceId: z.ZodOptional<z.ZodString>;
+            folderId: z.ZodOptional<z.ZodString>;
+            childOrder: z.ZodNumber;
+            isArchived: z.ZodBoolean;
+        }, z.core.$strip>;
+        success: z.ZodBoolean;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: true;
+        idempotentHint: true;
+    };
+    execute(args: {
+        action: "move-to-workspace" | "move-to-personal";
+        projectId: string;
+        workspaceId?: string | undefined;
+        folderId?: string | undefined;
+        visibility?: "public" | "restricted" | "team" | undefined;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            project: {
+                id: string;
+                name: string;
+                description: string;
+                color: import('@doist/todoist-sdk').ColorKey;
+                isFavorite: boolean;
+                isShared: boolean;
+                parentId: string | undefined;
+                inboxProject: boolean;
+                viewStyle: string;
+                workspaceId: string | undefined;
+                folderId: string | undefined;
+                childOrder: number;
+                isArchived: boolean;
+            };
+            success: true;
+        };
+    }>;
+};
+export { projectMove };
+//# sourceMappingURL=project-move.d.ts.map

package/dist/tools/project-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-move.d.ts","sourceRoot":"","sources":["../../src/tools/project-move.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsCvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwD8C,CAAA;AAE/D,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/reorder-objects.d.ts

@@ -0,0 +1,61 @@
+import { TodoistApi } from '@doist/todoist-sdk';
+import { z } from 'zod';
+type Failure = {
+    item: string;
+    error: string;
+};
+declare const reorderObjects: {
+    name: "reorder-objects";
+    description: string;
+    parameters: {
+        type: z.ZodEnum<{
+            project: "project";
+            section: "section";
+        }>;
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            order: z.ZodOptional<z.ZodNumber>;
+            parentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    };
+    outputSchema: {
+        type: z.ZodEnum<{
+            project: "project";
+            section: "section";
+        }>;
+        movedCount: z.ZodNumber;
+        reorderedCount: z.ZodNumber;
+        affectedIds: z.ZodArray<z.ZodString>;
+        failures: z.ZodArray<z.ZodObject<{
+            item: z.ZodString;
+            error: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        success: z.ZodBoolean;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        type: "project" | "section";
+        items: {
+            id: string;
+            order?: number | undefined;
+            parentId?: string | undefined;
+        }[];
+    }, client: TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            type: "project" | "section";
+            movedCount: number;
+            reorderedCount: number;
+            affectedIds: string[];
+            failures: Failure[];
+            success: boolean;
+        };
+    }>;
+};
+export { reorderObjects };
+//# sourceMappingURL=reorder-objects.d.ts.map

package/dist/tools/reorder-objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reorder-objects.d.ts","sourceRoot":"","sources":["../../src/tools/reorder-objects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiC,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEnF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2DvB,KAAK,OAAO,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAM9C,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkE2C,CAAA;AAiR/D,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/reschedule-tasks.d.ts

@@ -0,0 +1,95 @@
+import { Task } from '@doist/todoist-sdk';
+import { z } from 'zod';
+declare const rescheduleTasks: {
+    name: "reschedule-tasks";
+    description: string;
+    parameters: {
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            date: z.ZodString;
+            duration: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    };
+    outputSchema: {
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            description: z.ZodString;
+            dueDate: z.ZodOptional<z.ZodString>;
+            recurring: z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>;
+            deadlineDate: z.ZodOptional<z.ZodString>;
+            priority: z.ZodEnum<{
+                p1: "p1";
+                p2: "p2";
+                p3: "p3";
+                p4: "p4";
+            }>;
+            projectId: z.ZodString;
+            sectionId: z.ZodOptional<z.ZodString>;
+            parentId: z.ZodOptional<z.ZodString>;
+            labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            duration: z.ZodOptional<z.ZodString>;
+            responsibleUid: z.ZodOptional<z.ZodString>;
+            isUncompletable: z.ZodOptional<z.ZodBoolean>;
+            assignedByUid: z.ZodOptional<z.ZodString>;
+            isDeleted: z.ZodOptional<z.ZodBoolean>;
+            checked: z.ZodBoolean;
+            completedAt: z.ZodOptional<z.ZodString>;
+            addedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+        rescheduledTaskIds: z.ZodArray<z.ZodString>;
+        failures: z.ZodArray<z.ZodObject<{
+            item: z.ZodString;
+            error: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: true;
+        idempotentHint: false;
+    };
+    execute(args: {
+        tasks: {
+            id: string;
+            date: string;
+            duration?: string | undefined;
+        }[];
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            tasks: {
+                id: string;
+                content: string;
+                description: string;
+                recurring: string | boolean;
+                priority: "p1" | "p2" | "p3" | "p4";
+                projectId: string;
+                checked: boolean;
+                dueDate?: string | undefined;
+                deadlineDate?: string | undefined;
+                sectionId?: string | undefined;
+                parentId?: string | undefined;
+                labels?: string[] | undefined;
+                duration?: string | undefined;
+                responsibleUid?: string | undefined;
+                isUncompletable?: boolean | undefined;
+                assignedByUid?: string | undefined;
+                isDeleted?: boolean | undefined;
+                completedAt?: string | undefined;
+                addedAt?: string | undefined;
+            }[];
+            totalCount: number;
+            rescheduledTaskIds: string[];
+            failures: {
+                item: string;
+                error: string;
+                code?: string | undefined;
+            }[];
+        };
+    }>;
+};
+declare function buildRescheduleDate(inputDate: string, existingDue: NonNullable<Task['due']>): string;
+export { buildRescheduleDate, rescheduleTasks };
+//# sourceMappingURL=reschedule-tasks.d.ts.map

package/dist/tools/reschedule-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reschedule-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/reschedule-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,IAAI,EAAkB,MAAM,oBAAoB,CAAA;AAE3E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAyCvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+G0C,CAAA;AA4B/D,iBAAS,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,MAAM,CAU7F;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAA"}

package/dist/tools/search.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+type SearchResult = {
+    id: string;
+    title: string;
+    url: string;
+};
+/**
+ * OpenAI MCP search tool - returns a list of relevant search results from Todoist.
+ *
+ * This tool follows the OpenAI MCP search tool specification:
+ * @see https://platform.openai.com/docs/mcp#search-tool
+ */
+declare const search: {
+    name: "search";
+    description: string;
+    parameters: {
+        query: z.ZodString;
+    };
+    outputSchema: {
+        results: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        query: string;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            results: SearchResult[];
+            totalCount: number;
+        };
+    }>;
+};
+export { search };
+//# sourceMappingURL=search.d.ts.map

package/dist/tools/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/tools/search.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,KAAK,YAAY,GAAG;IAChB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACd,CAAA;AAeD;;;;;GAKG;AACH,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDmD,CAAA;AAE/D,OAAO,EAAE,MAAM,EAAE,CAAA"}

package/dist/tools/set-user-status.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+declare const setUserStatus: {
+    name: "set-user-status";
+    description: string;
+    parameters: {
+        message: z.ZodOptional<z.ZodString>;
+        emoji: z.ZodOptional<z.ZodString>;
+        activeUntil: z.ZodOptional<z.ZodString>;
+        pauseNotifications: z.ZodOptional<z.ZodBoolean>;
+        pauseActivity: z.ZodOptional<z.ZodBoolean>;
+        clear: z.ZodOptional<z.ZodBoolean>;
+    };
+    outputSchema: {
+        hasStatus: z.ZodBoolean;
+        status: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            emoji: z.ZodOptional<z.ZodString>;
+            activeUntil: z.ZodOptional<z.ZodString>;
+            pauseNotifications: z.ZodBoolean;
+            pauseActivity: z.ZodBoolean;
+        }, z.core.$strip>>;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: true;
+        idempotentHint: true;
+        openWorldHint: true;
+    };
+    execute(args: {
+        message?: string | undefined;
+        emoji?: string | undefined;
+        activeUntil?: string | undefined;
+        pauseNotifications?: boolean | undefined;
+        pauseActivity?: boolean | undefined;
+        clear?: boolean | undefined;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            hasStatus: boolean;
+            status?: {
+                message: string;
+                pauseNotifications: boolean;
+                pauseActivity: boolean;
+                emoji?: string | undefined;
+                activeUntil?: string | undefined;
+            };
+        };
+    }>;
+};
+export { setUserStatus };
+//# sourceMappingURL=set-user-status.d.ts.map

package/dist/tools/set-user-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-user-status.d.ts","sourceRoot":"","sources":["../../src/tools/set-user-status.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkKvB,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDsD,CAAA;AAEzE,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/tools/uncomplete-tasks.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+declare const uncompleteTasks: {
+    name: "uncomplete-tasks";
+    description: string;
+    parameters: {
+        ids: z.ZodArray<z.ZodString>;
+    };
+    outputSchema: {
+        uncompleted: z.ZodArray<z.ZodString>;
+        failures: z.ZodArray<z.ZodObject<{
+            item: z.ZodString;
+            error: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        totalRequested: z.ZodNumber;
+        successCount: z.ZodNumber;
+        failureCount: z.ZodNumber;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: false;
+        idempotentHint: false;
+    };
+    execute(args: {
+        ids: string[];
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            uncompleted: string[];
+            failures: {
+                item: string;
+                error: string;
+                code?: string;
+            }[];
+            totalRequested: number;
+            successCount: number;
+            failureCount: number;
+        };
+    }>;
+};
+export { uncompleteTasks };
+//# sourceMappingURL=uncomplete-tasks.d.ts.map

package/dist/tools/uncomplete-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncomplete-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/uncomplete-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAoBvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAQiB,MAAM;uBAAS,MAAM;uBAAS,MAAM;;;;;;;CAoCX,CAAA;AAqB/D,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/tools/update-comments.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+declare const updateComments: {
+    name: "update-comments";
+    description: string;
+    parameters: {
+        comments: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strip>>;
+    };
+    outputSchema: {
+        comments: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            taskId: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            content: z.ZodString;
+            postedAt: z.ZodString;
+            postedUid: z.ZodOptional<z.ZodString>;
+            notifiedUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fileAttachment: z.ZodOptional<z.ZodObject<{
+                resourceType: z.ZodString;
+                fileName: z.ZodOptional<z.ZodString>;
+                fileSize: z.ZodOptional<z.ZodNumber>;
+                fileType: z.ZodOptional<z.ZodString>;
+                fileUrl: z.ZodOptional<z.ZodString>;
+                fileDuration: z.ZodOptional<z.ZodNumber>;
+                uploadState: z.ZodOptional<z.ZodEnum<{
+                    pending: "pending";
+                    completed: "completed";
+                }>>;
+                url: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodString>;
+                image: z.ZodOptional<z.ZodString>;
+                imageWidth: z.ZodOptional<z.ZodNumber>;
+                imageHeight: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+        updatedCommentIds: z.ZodArray<z.ZodString>;
+        failures: z.ZodArray<z.ZodObject<{
+            item: z.ZodString;
+            error: z.ZodString;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        appliedOperations: z.ZodObject<{
+            updateCount: z.ZodNumber;
+            failureCount: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    annotations: {
+        readOnlyHint: false;
+        destructiveHint: true;
+        idempotentHint: false;
+    };
+    execute(args: {
+        comments: {
+            id: string;
+            content: string;
+        }[];
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            comments: {
+                id: string;
+                taskId: string | undefined;
+                projectId: string | undefined;
+                content: string;
+                postedAt: string;
+                postedUid: string;
+                notifiedUserIds: string[] | undefined;
+                fileAttachment: {
+                    resourceType: string;
+                    fileName: string | undefined;
+                    fileSize: number | undefined;
+                    fileType: string | undefined;
+                    fileUrl: string | undefined;
+                    fileDuration: number | undefined;
+                    uploadState: "pending" | "completed" | undefined;
+                    url: string | undefined;
+                    title: string | undefined;
+                    image: string | undefined;
+                    imageWidth: number | undefined;
+                    imageHeight: number | undefined;
+                } | undefined;
+            }[];
+            totalCount: number;
+            updatedCommentIds: string[];
+            failures: {
+                item: string;
+                error: string;
+            }[];
+            appliedOperations: {
+                updateCount: number;
+                failureCount: number;
+            };
+        };
+    }>;
+};
+export { updateComments };
+//# sourceMappingURL=update-comments.d.ts.map

package/dist/tools/update-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-comments.d.ts","sourceRoot":"","sources":["../../src/tools/update-comments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkCvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoBkB,MAAM;uBAAS,MAAM;;;;;;;;CAkCI,CAAA;AAqB/D,OAAO,EAAE,cAAc,EAAE,CAAA"}