@doist/todoist-ai 8.7.0 → 8.7.2

package/dist/tools/find-labels.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+declare const findLabels: {
+    name: "find-labels";
+    description: string;
+    parameters: {
+        searchText: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        labels: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: 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";
+            }>>>;
+            order: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            isFavorite: z.ZodBoolean;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        totalCount: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        sharedLabels: z.ZodArray<z.ZodString>;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        limit: number;
+        searchText?: string | undefined;
+        cursor?: string | undefined;
+    }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            labels: {
+                id: string;
+                name: string;
+                isFavorite: boolean;
+                color?: "berry_red" | "red" | "orange" | "yellow" | "olive_green" | "lime_green" | "green" | "mint_green" | "teal" | "sky_blue" | "light_blue" | "blue" | "grape" | "violet" | "lavender" | "magenta" | "salmon" | "charcoal" | "grey" | "taupe" | undefined;
+                order?: number | undefined;
+            }[];
+            nextCursor: string | undefined;
+            totalCount: number;
+            hasMore: boolean;
+            sharedLabels: string[];
+            appliedFilters: {
+                searchText: string;
+                limit?: undefined;
+                cursor?: undefined;
+            } | {
+                limit: number;
+                cursor: string | undefined;
+                searchText?: undefined;
+            };
+        };
+    }>;
+};
+export { findLabels };
+//# sourceMappingURL=find-labels.d.ts.map

package/dist/tools/find-labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-labels.d.ts","sourceRoot":"","sources":["../../src/tools/find-labels.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA6CvB,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC+C,CAAA;AAwD/D,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/tools/find-project-collaborators.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { ProjectCollaborator } from '../utils/user-resolver.js';
+declare const findProjectCollaborators: {
+    name: "find-project-collaborators";
+    description: string;
+    parameters: {
+        projectId: z.ZodString;
+        searchTerm: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        collaborators: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            email: z.ZodString;
+        }, z.core.$strip>>;
+        projectInfo: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            isShared: z.ZodBoolean;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+        totalAvailable: z.ZodOptional<z.ZodNumber>;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        projectId: string;
+        searchTerm?: string | undefined;
+    }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            collaborators: never[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: false;
+            };
+            totalCount: number;
+            appliedFilters: {
+                projectId: string;
+                searchTerm?: string | undefined;
+            };
+            totalAvailable?: undefined;
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            collaborators: never[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: true;
+            };
+            totalCount: number;
+            appliedFilters: {
+                projectId: string;
+                searchTerm?: string | undefined;
+            };
+            totalAvailable?: undefined;
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            collaborators: ProjectCollaborator[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: true;
+            };
+            totalCount: number;
+            totalAvailable: number;
+            appliedFilters: {
+                projectId: string;
+                searchTerm?: string | undefined;
+            };
+        };
+    }>;
+};
+export { findProjectCollaborators };
+//# sourceMappingURL=find-project-collaborators.d.ts.map

package/dist/tools/find-project-collaborators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-project-collaborators.d.ts","sourceRoot":"","sources":["../../src/tools/find-project-collaborators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,2BAA2B,CAAA;AAkClF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGiC,CAAA;AAwE/D,OAAO,EAAE,wBAAwB,EAAE,CAAA"}

package/dist/tools/find-projects.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+declare const findProjects: {
+    name: "find-projects";
+    description: string;
+    parameters: {
+        searchText: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        projects: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: 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;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        totalCount: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        limit: number;
+        searchText?: string | undefined;
+        cursor?: string | undefined;
+    }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            projects: {
+                id: string;
+                name: string;
+                color: import('@doist/todoist-api-typescript').ColorKey;
+                isFavorite: boolean;
+                isShared: boolean;
+                parentId: string | undefined;
+                inboxProject: boolean;
+                viewStyle: string;
+                workspaceId: string | undefined;
+                folderId: string | undefined;
+                childOrder: number;
+            }[];
+            nextCursor: string | undefined;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                limit: number;
+                searchText?: string | undefined;
+                cursor?: string | undefined;
+            };
+        };
+    }>;
+};
+export { findProjects };
+//# sourceMappingURL=find-projects.d.ts.map

package/dist/tools/find-projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-projects.d.ts","sourceRoot":"","sources":["../../src/tools/find-projects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA0CvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC6C,CAAA;AAoD/D,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-reminders.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+declare const findReminders: {
+    name: "find-reminders";
+    description: string;
+    parameters: {
+        taskId: z.ZodOptional<z.ZodString>;
+        reminderId: z.ZodOptional<z.ZodString>;
+        locationReminderId: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        reminders: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            taskId: z.ZodString;
+            type: z.ZodEnum<{
+                location: "location";
+                absolute: "absolute";
+                relative: "relative";
+            }>;
+            minuteOffset: z.ZodOptional<z.ZodNumber>;
+            due: z.ZodOptional<z.ZodObject<{
+                isRecurring: z.ZodBoolean;
+                string: z.ZodString;
+                date: z.ZodString;
+                datetime: z.ZodOptional<z.ZodString>;
+                timezone: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            name: z.ZodOptional<z.ZodString>;
+            locLat: z.ZodOptional<z.ZodString>;
+            locLong: z.ZodOptional<z.ZodString>;
+            locTrigger: z.ZodOptional<z.ZodEnum<{
+                on_enter: "on_enter";
+                on_leave: "on_leave";
+            }>>;
+            radius: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        searchType: z.ZodString;
+        searchId: z.ZodString;
+        totalCount: z.ZodNumber;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        taskId?: string | undefined;
+        reminderId?: string | undefined;
+        locationReminderId?: string | undefined;
+    }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            reminders: ({
+                minuteOffset: number;
+                due: {
+                    isRecurring: boolean;
+                    string: string;
+                    date: string;
+                    datetime: string | undefined;
+                    timezone: string | undefined;
+                } | undefined;
+                id: string;
+                taskId: string;
+                type: "location" | "absolute" | "relative";
+            } | {
+                due: {
+                    isRecurring: boolean;
+                    string: string;
+                    date: string;
+                    datetime: string | undefined;
+                    timezone: string | undefined;
+                };
+                id: string;
+                taskId: string;
+                type: "location" | "absolute" | "relative";
+            } | {
+                name: string;
+                locLat: string;
+                locLong: string;
+                locTrigger: "on_enter" | "on_leave";
+                radius: number;
+                id: string;
+                taskId: string;
+                type: "location" | "absolute" | "relative";
+            })[];
+            searchType: string;
+            searchId: string;
+            totalCount: number;
+        };
+    }>;
+};
+export { findReminders };
+//# sourceMappingURL=find-reminders.d.ts.map

package/dist/tools/find-reminders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-reminders.d.ts","sourceRoot":"","sources":["../../src/tools/find-reminders.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkCvB,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsF4C,CAAA;AAsB/D,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/tools/find-sections.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+declare const findSections: {
+    name: "find-sections";
+    description: string;
+    parameters: {
+        projectId: z.ZodString;
+        searchText: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        sections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        projectId: string;
+        searchText?: string | undefined;
+    }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            sections: {
+                id: string;
+                name: string;
+            }[];
+            totalCount: number;
+            appliedFilters: {
+                projectId: string;
+                searchText?: string | undefined;
+            };
+        };
+    }>;
+};
+export { findSections };
+//# sourceMappingURL=find-sections.d.ts.map

package/dist/tools/find-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-sections.d.ts","sourceRoot":"","sources":["../../src/tools/find-sections.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqCvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C6C,CAAA;AAwC/D,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-tasks-by-date.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+export declare const ArgsSchema: {
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    labelsOperator: z.ZodOptional<z.ZodEnum<{
+        or: "or";
+        and: "and";
+    }>>;
+    startDate: z.ZodOptional<z.ZodString>;
+    overdueOption: z.ZodOptional<z.ZodEnum<{
+        "overdue-only": "overdue-only";
+        "include-overdue": "include-overdue";
+        "exclude-overdue": "exclude-overdue";
+    }>>;
+    daysCount: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    responsibleUser: z.ZodOptional<z.ZodString>;
+    responsibleUserFiltering: z.ZodOptional<z.ZodEnum<{
+        assigned: "assigned";
+        unassignedOrMe: "unassignedOrMe";
+        all: "all";
+    }>>;
+};
+declare const findTasksByDate: {
+    name: "find-tasks-by-date";
+    description: string;
+    parameters: {
+        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        labelsOperator: z.ZodOptional<z.ZodEnum<{
+            or: "or";
+            and: "and";
+        }>>;
+        startDate: z.ZodOptional<z.ZodString>;
+        overdueOption: z.ZodOptional<z.ZodEnum<{
+            "overdue-only": "overdue-only";
+            "include-overdue": "include-overdue";
+            "exclude-overdue": "exclude-overdue";
+        }>>;
+        daysCount: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+        responsibleUser: z.ZodOptional<z.ZodString>;
+        responsibleUserFiltering: z.ZodOptional<z.ZodEnum<{
+            assigned: "assigned";
+            unassignedOrMe: "unassignedOrMe";
+            all: "all";
+        }>>;
+    };
+    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>;
+            checked: z.ZodBoolean;
+            completedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        totalCount: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        daysCount: number;
+        limit: number;
+        labels?: string[] | undefined;
+        labelsOperator?: "or" | "and" | undefined;
+        startDate?: string | undefined;
+        overdueOption?: "overdue-only" | "include-overdue" | "exclude-overdue" | undefined;
+        cursor?: string | undefined;
+        responsibleUser?: string | undefined;
+        responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
+    }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            tasks: {
+                id: string;
+                content: string;
+                description: string;
+                dueDate: string | undefined;
+                recurring: string | boolean;
+                deadlineDate: string | undefined;
+                priority: "p1" | "p2" | "p3" | "p4";
+                projectId: string;
+                sectionId: string | undefined;
+                parentId: string | undefined;
+                labels: string[];
+                duration: string | undefined;
+                responsibleUid: string | undefined;
+                assignedByUid: string | undefined;
+                checked: boolean;
+                completedAt: string | undefined;
+            }[];
+            nextCursor: string | undefined;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                daysCount: number;
+                limit: number;
+                labels?: string[] | undefined;
+                labelsOperator?: "or" | "and" | undefined;
+                startDate?: string | undefined;
+                overdueOption?: "overdue-only" | "include-overdue" | "exclude-overdue" | undefined;
+                cursor?: string | undefined;
+                responsibleUser?: string | undefined;
+                responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
+            };
+        };
+    }>;
+};
+export { findTasksByDate };
+//# sourceMappingURL=find-tasks-by-date.d.ts.map

package/dist/tools/find-tasks-by-date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-tasks-by-date.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks-by-date.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsBvB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CA+CtB,CAAA;AAYD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqF0C,CAAA;AAyF/D,OAAO,EAAE,eAAe,EAAE,CAAA"}

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

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+declare const findTasks: {
+    name: "find-tasks";
+    description: string;
+    parameters: {
+        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        labelsOperator: z.ZodOptional<z.ZodEnum<{
+            or: "or";
+            and: "and";
+        }>>;
+        searchText: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        sectionId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        responsibleUser: z.ZodOptional<z.ZodString>;
+        responsibleUserFiltering: z.ZodOptional<z.ZodEnum<{
+            assigned: "assigned";
+            unassignedOrMe: "unassignedOrMe";
+            all: "all";
+        }>>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+        filter: z.ZodOptional<z.ZodString>;
+        filterIdOrName: z.ZodOptional<z.ZodString>;
+    };
+    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>;
+            checked: z.ZodBoolean;
+            completedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        totalCount: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        limit: number;
+        labels?: string[] | undefined;
+        labelsOperator?: "or" | "and" | undefined;
+        searchText?: string | undefined;
+        projectId?: string | undefined;
+        sectionId?: string | undefined;
+        parentId?: string | undefined;
+        responsibleUser?: string | undefined;
+        responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
+        cursor?: string | undefined;
+        filter?: string | undefined;
+        filterIdOrName?: string | undefined;
+    }, client: import('@doist/todoist-api-typescript').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            tasks: {
+                id: string;
+                content: string;
+                description: string;
+                dueDate: string | undefined;
+                recurring: string | boolean;
+                deadlineDate: string | undefined;
+                priority: "p1" | "p2" | "p3" | "p4";
+                projectId: string;
+                sectionId: string | undefined;
+                parentId: string | undefined;
+                labels: string[];
+                duration: string | undefined;
+                responsibleUid: string | undefined;
+                assignedByUid: string | undefined;
+                checked: boolean;
+                completedAt: string | undefined;
+            }[];
+            nextCursor: string | undefined;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                limit: number;
+                labels?: string[] | undefined;
+                labelsOperator?: "or" | "and" | undefined;
+                searchText?: string | undefined;
+                projectId?: string | undefined;
+                sectionId?: string | undefined;
+                parentId?: string | undefined;
+                responsibleUser?: string | undefined;
+                responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
+                cursor?: string | undefined;
+                filter?: string | undefined;
+                filterIdOrName?: string | undefined;
+            };
+        };
+    }>;
+};
+export { findTasks };
+//# sourceMappingURL=find-tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"find-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAoFvB,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwNgD,CAAA;AA2K/D,OAAO,EAAE,SAAS,EAAE,CAAA"}