@doist/todoist-ai 0.1.0

package/dist/tools/tasks-add-multiple.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+declare const tasksAddMultiple: {
+    name: string;
+    description: string;
+    parameters: {
+        projectId: z.ZodOptional<z.ZodString>;
+        sectionId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        tasks: z.ZodArray<z.ZodObject<{
+            content: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            dueString: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            description?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+        }, {
+            content: string;
+            description?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+        }>, "many">;
+    };
+    execute(args: {
+        tasks: {
+            content: string;
+            description?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+        }[];
+        projectId?: string | undefined;
+        parentId?: string | undefined;
+        sectionId?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        id: string;
+        content: string;
+        description: string;
+        dueDate: string | undefined;
+        recurring: string | boolean;
+        priority: number;
+        projectId: string;
+        sectionId: string | null;
+        parentId: string | null;
+        labels: string[];
+    }[]>;
+};
+export { tasksAddMultiple };
+//# sourceMappingURL=tasks-add-multiple.d.ts.map

package/dist/tools/tasks-add-multiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-add-multiple.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-add-multiple.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoCxB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaoB,CAAC;AAE3C,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/tools/tasks-add-multiple.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { mapTask } from "./shared.js";
+const TaskSchema = z.object({
+    content: z.string().min(1).describe("The content of the task to create."),
+    description: z.string().optional().describe("The description of the task."),
+    priority: z
+        .number()
+        .int()
+        .min(1)
+        .max(4)
+        .optional()
+        .describe("The priority of the task (1-4)."),
+    dueString: z
+        .string()
+        .optional()
+        .describe("The due date for the task, in natural language."),
+});
+const ArgsSchema = {
+    projectId: z
+        .string()
+        .optional()
+        .describe("The project ID to add the tasks to."),
+    sectionId: z
+        .string()
+        .optional()
+        .describe("The section ID to add the tasks to."),
+    parentId: z
+        .string()
+        .optional()
+        .describe("The parent task ID (for subtasks)."),
+    tasks: z.array(TaskSchema).min(1).describe("The array of tasks to add."),
+};
+const tasksAddMultiple = {
+    name: "tasks-add-multiple",
+    description: "Add one or more tasks to a project, section, or parent.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { projectId, sectionId, parentId, tasks } = args;
+        const newTasks = [];
+        for (const task of tasks) {
+            const taskArgs = { ...task, projectId, sectionId, parentId };
+            newTasks.push(await client.addTask(taskArgs));
+        }
+        return newTasks.map(mapTask);
+    },
+};
+export { tasksAddMultiple };

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+declare const tasksListByDate: {
+    name: string;
+    description: string;
+    parameters: {
+        startDate: z.ZodString;
+        daysCount: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        startDate: string;
+        daysCount: number;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        tasks: {
+            id: string;
+            content: string;
+            description: string;
+            dueDate: string | undefined;
+            recurring: string | boolean;
+            priority: number;
+            projectId: string;
+            sectionId: string | null;
+            parentId: string | null;
+            labels: string[];
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+export { tasksListByDate };
+//# sourceMappingURL=tasks-by-date-range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-by-date-range.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-by-date-range.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmCxB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBqB,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/tools/tasks-by-date-range.js

@@ -0,0 +1,47 @@
+import { addDays, formatISO } from "date-fns";
+import { z } from "zod";
+import { getTasksByFilter } from "./shared.js";
+const ArgsSchema = {
+    startDate: z
+        .string()
+        .regex(/^(\d{4}-\d{2}-\d{2}|today)$/)
+        .describe("The start date to get the tasks for. Format: YYYY-MM-DD or 'today'."),
+    daysCount: z
+        .number()
+        .int()
+        .min(1)
+        .max(30)
+        .default(1)
+        .describe("The number of days to get the tasks for, starting from the start date."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("The maximum number of tasks to return."),
+    cursor: z
+        .string()
+        .optional()
+        .describe("The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters)."),
+};
+const tasksListByDate = {
+    name: "tasks-list-by-date",
+    description: "Get tasks by date range.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const startDate = args.startDate === "today"
+            ? formatISO(new Date(), { representation: "date" })
+            : args.startDate;
+        const endDate = addDays(startDate, args.daysCount + 1);
+        const endDateStr = formatISO(endDate, { representation: "date" });
+        const query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
+        return await getTasksByFilter({
+            client,
+            query,
+            cursor: args.cursor,
+            limit: args.limit,
+        });
+    },
+};
+export { tasksListByDate };

package/dist/tools/tasks-by-project.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+declare const tasksListForProject: {
+    name: string;
+    description: string;
+    parameters: {
+        projectId: z.ZodString;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        projectId: string;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        tasks: {
+            id: string;
+            content: string;
+            description: string;
+            dueDate: string | undefined;
+            recurring: string | boolean;
+            priority: number;
+            projectId: string;
+            sectionId: string | null;
+            parentId: string | null;
+            labels: string[];
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+export { tasksListForProject };
+//# sourceMappingURL=tasks-by-project.d.ts.map

package/dist/tools/tasks-by-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-by-project.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-by-project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBiB,CAAC;AAE3C,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/tools/tasks-by-project.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { mapTask } from "./shared.js";
+const ArgsSchema = {
+    projectId: z
+        .string()
+        .min(1)
+        .describe("The ID of the project to get tasks for."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("The maximum number of tasks to return."),
+    cursor: z
+        .string()
+        .optional()
+        .describe("The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters)."),
+};
+const tasksListForProject = {
+    name: "tasks-list-for-project",
+    description: "Get tasks by project ID.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { projectId, limit, cursor } = args;
+        const { results, nextCursor } = await client.getTasks({
+            projectId,
+            limit,
+            cursor: cursor ?? null,
+        });
+        return {
+            tasks: results.map(mapTask),
+            nextCursor,
+        };
+    },
+};
+export { tasksListForProject };

package/dist/tools/tasks-complete-multiple.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+declare const tasksCompleteMultiple: {
+    name: string;
+    description: string;
+    parameters: {
+        ids: z.ZodArray<z.ZodString, "many">;
+    };
+    execute(args: {
+        ids: string[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        success: boolean;
+        completed: string[];
+    }>;
+};
+export { tasksCompleteMultiple };
+//# sourceMappingURL=tasks-complete-multiple.d.ts.map

package/dist/tools/tasks-complete-multiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-complete-multiple.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-complete-multiple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,QAAA,MAAM,qBAAqB;;;;;;;;;;;;CAgBe,CAAC;AAE3C,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/tools/tasks-complete-multiple.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+const ArgsSchema = {
+    ids: z
+        .array(z.string().min(1))
+        .min(1)
+        .describe("The IDs of the tasks to complete."),
+};
+const tasksCompleteMultiple = {
+    name: "tasks-complete-multiple",
+    description: "Complete one or more tasks by their IDs.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const completed = [];
+        for (const id of args.ids) {
+            try {
+                await client.closeTask(id);
+                completed.push(id);
+            }
+            catch {
+                // Ignore errors for individual tasks, continue with others
+            }
+        }
+        return { success: true, completed };
+    },
+};
+export { tasksCompleteMultiple };

package/dist/tools/tasks-delete-one.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+declare const tasksDeleteOne: {
+    name: string;
+    description: string;
+    parameters: {
+        id: z.ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        success: boolean;
+    }>;
+};
+export { tasksDeleteOne };
+//# sourceMappingURL=tasks-delete-one.d.ts.map

package/dist/tools/tasks-delete-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-delete-one.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-delete-one.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,QAAA,MAAM,cAAc;;;;;;;;;;;CAQsB,CAAC;AAE3C,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/tools/tasks-delete-one.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+const ArgsSchema = {
+    id: z.string().min(1).describe("The ID of the task to delete."),
+};
+const tasksDeleteOne = {
+    name: "tasks-delete-one",
+    description: "Delete a task by its ID.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        await client.deleteTask(args.id);
+        return { success: true };
+    },
+};
+export { tasksDeleteOne };

package/dist/tools/tasks-list-for-section.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+declare const tasksListForSection: {
+    name: string;
+    description: string;
+    parameters: {
+        sectionId: z.ZodString;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        sectionId: string;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        tasks: {
+            id: string;
+            content: string;
+            description: string;
+            dueDate: string | undefined;
+            recurring: string | boolean;
+            priority: number;
+            projectId: string;
+            sectionId: string | null;
+            parentId: string | null;
+            labels: string[];
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+export { tasksListForSection };
+//# sourceMappingURL=tasks-list-for-section.d.ts.map

package/dist/tools/tasks-list-for-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-list-for-section.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-list-for-section.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBiB,CAAC;AAE3C,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/tools/tasks-list-for-section.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { mapTask } from "./shared.js";
+const ArgsSchema = {
+    sectionId: z
+        .string()
+        .min(1)
+        .describe("The ID of the section to get tasks for."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("The maximum number of tasks to return."),
+    cursor: z
+        .string()
+        .optional()
+        .describe("The cursor to get the next page of tasks (from previous call)."),
+};
+const tasksListForSection = {
+    name: "tasks-list-for-section",
+    description: "List tasks for a given section.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { sectionId, limit, cursor } = args;
+        const { results, nextCursor } = await client.getTasks({
+            sectionId,
+            limit,
+            cursor: cursor ?? null,
+        });
+        return {
+            tasks: results.map(mapTask),
+            nextCursor,
+        };
+    },
+};
+export { tasksListForSection };

package/dist/tools/tasks-list-overdue.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+declare const tasksListOverdue: {
+    name: string;
+    description: string;
+    parameters: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        tasks: {
+            id: string;
+            content: string;
+            description: string;
+            dueDate: string | undefined;
+            recurring: string | boolean;
+            priority: number;
+            projectId: string;
+            sectionId: string | null;
+            parentId: string | null;
+            labels: string[];
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+export { tasksListOverdue };
+//# sourceMappingURL=tasks-list-overdue.d.ts.map

package/dist/tools/tasks-list-overdue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-list-overdue.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-list-overdue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;CAYoB,CAAC;AAE3C,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/tools/tasks-list-overdue.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { getTasksByFilter } from "./shared.js";
+const ArgsSchema = {
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("The maximum number of overdue tasks to return."),
+    cursor: z
+        .string()
+        .optional()
+        .describe("The cursor to get the next page of overdue tasks (cursor is obtained from the previous call to this tool, with the same parameters)."),
+};
+const tasksListOverdue = {
+    name: "tasks-list-overdue",
+    description: "Get overdue tasks.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        return await getTasksByFilter({
+            client,
+            query: "overdue",
+            cursor: args.cursor,
+            limit: args.limit,
+        });
+    },
+};
+export { tasksListOverdue };

package/dist/tools/tasks-organize-multiple.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+declare const tasksOrganizeMultiple: {
+    name: string;
+    description: string;
+    parameters: {
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            projectId: z.ZodOptional<z.ZodString>;
+            sectionId: z.ZodOptional<z.ZodString>;
+            parentId: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            projectId?: string | undefined;
+            parentId?: string | undefined;
+            sectionId?: string | undefined;
+            order?: number | undefined;
+        }, {
+            id: string;
+            projectId?: string | undefined;
+            parentId?: string | undefined;
+            sectionId?: string | undefined;
+            order?: number | undefined;
+        }>, "many">;
+    };
+    execute(args: {
+        tasks: {
+            id: string;
+            projectId?: string | undefined;
+            parentId?: string | undefined;
+            sectionId?: string | undefined;
+            order?: number | undefined;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<import("@doist/todoist-api-typescript").Task[]>;
+};
+export { tasksOrganizeMultiple };
+//# sourceMappingURL=tasks-organize-multiple.d.ts.map

package/dist/tools/tasks-organize-multiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-organize-multiple.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-organize-multiple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8BxB,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYe,CAAC;AAE3C,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/tools/tasks-organize-multiple.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+const TaskUpdateSchema = z.object({
+    id: z.string().min(1).describe("The ID of the task to update."),
+    projectId: z
+        .string()
+        .optional()
+        .describe("The new project ID for the task."),
+    sectionId: z
+        .string()
+        .optional()
+        .describe("The new section ID for the task."),
+    parentId: z
+        .string()
+        .optional()
+        .describe("The new parent task ID (for subtasks)."),
+    order: z
+        .number()
+        .optional()
+        .describe("The new order of the task within its parent/section."),
+});
+const ArgsSchema = {
+    tasks: z
+        .array(TaskUpdateSchema)
+        .min(1)
+        .describe("Array of task updates to apply."),
+};
+const tasksOrganizeMultiple = {
+    name: "tasks-organize-multiple",
+    description: "Organize multiple tasks (move, reorder, etc.) in bulk.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const results = [];
+        for (const update of args.tasks) {
+            const { id, ...updateArgs } = update;
+            results.push(await client.updateTask(id, updateArgs));
+        }
+        return results;
+    },
+};
+export { tasksOrganizeMultiple };

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

@@ -0,0 +1,31 @@
+import { z } from "zod";
+declare const tasksSearch: {
+    name: string;
+    description: string;
+    parameters: {
+        searchText: z.ZodString;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        searchText: string;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        tasks: {
+            id: string;
+            content: string;
+            description: string;
+            dueDate: string | undefined;
+            recurring: string | boolean;
+            priority: number;
+            projectId: string;
+            sectionId: string | null;
+            parentId: string | null;
+            labels: string[];
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+export { tasksSearch };
+//# sourceMappingURL=tasks-search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-search.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqBxB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYyB,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/tools/tasks-search.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { getTasksByFilter } from "./shared.js";
+const ArgsSchema = {
+    searchText: z.string().min(1).describe("The text to search for in tasks."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("The maximum number of tasks to return."),
+    cursor: z
+        .string()
+        .optional()
+        .describe("The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters)."),
+};
+const tasksSearch = {
+    name: "tasks-search",
+    description: "Search tasks by text using Todoist's filter query.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        return await getTasksByFilter({
+            client,
+            query: `search: ${args.searchText}`,
+            cursor: args.cursor,
+            limit: args.limit,
+        });
+    },
+};
+export { tasksSearch };

package/dist/tools/tasks-update-one.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+declare const tasksUpdateOne: {
+    name: string;
+    description: string;
+    parameters: {
+        id: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        sectionId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        dueString: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        id: string;
+        content?: string | undefined;
+        projectId?: string | undefined;
+        parentId?: string | undefined;
+        description?: string | undefined;
+        priority?: number | undefined;
+        dueString?: string | undefined;
+        sectionId?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<import("@doist/todoist-api-typescript").Task>;
+};
+export { tasksUpdateOne };
+//# sourceMappingURL=tasks-update-one.d.ts.map

package/dist/tools/tasks-update-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-update-one.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-update-one.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqCxB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;CAQsB,CAAC;AAE3C,OAAO,EAAE,cAAc,EAAE,CAAC"}