@panoptic-it-solutions/zoho-projects-client 0.1.4 → 0.2.1

package/dist/client.js

@@ -2,7 +2,7 @@ import axios from "axios";
 import { z } from "zod";
 import { TokenManager } from "./auth/token-manager.js";
 import { parseAxiosError, ZohoProjectsError, ZohoResponseValidationError, } from "./errors.js";
-import { ProjectSchema, ProjectListResponseSchema, TaskSchema, TaskListResponseSchema, TimeLogListResponseSchema, UserSchema, UserListResponseSchema, } from "./types/index.js";
+import { ProjectSchema, ProjectListResponseSchema, TaskSchema, TaskListResponseSchema, TimeLogSchema, TimeLogListResponseSchema, UserSchema, UserListResponseSchema, TagSchema, TagListResponseSchema, RoleSchema, RoleListResponseSchema, ProfileSchema, ProfileListResponseSchema, ClientSchema, ClientListResponseSchema, ContactSchema, ContactListResponseSchema, ProjectGroupSchema, ProjectGroupListResponseSchema, LeaveSchema, LeaveListResponseSchema, TeamSchema, TeamListResponseSchema, TaskListSchema, TaskListListResponseSchema, PhaseSchema, PhaseListResponseSchema, IssueSchema, IssueListResponseSchema, ForumSchema, ForumListResponseSchema, EventSchema, EventListResponseSchema, AttachmentSchema, AttachmentListResponseSchema, DocumentSchema, DocumentListResponseSchema, DocumentFolderSchema, DocumentFolderListResponseSchema, CommentSchema, CommentListResponseSchema, FollowerSchema, FollowerListResponseSchema, DashboardSchema, DashboardListResponseSchema, WidgetSchema, WidgetListResponseSchema, ReportSchema, ReportListResponseSchema, ReportDataResponseSchema, SearchResponseSchema, TrashListResponseSchema, TrashRestoreResponseSchema, PortalSchema, PortalListResponseSchema, ModuleSchema, ModuleListResponseSchema, ModuleFieldSchema, ModuleFieldListResponseSchema, TimerResponseSchema, TimerListResponseSchema, CustomViewSchema, CustomViewListResponseSchema, BlueprintSchema, BlueprintListResponseSchema, NextTransitionsResponseSchema, DuringActionsResponseSchema, } from "./types/index.js";
 import { createRateLimiter } from "./utils/rate-limiter.js";
 import { autoPaginate, collectAll, DEFAULT_PAGE_SIZE, } from "./utils/pagination.js";
 /**
@@ -142,6 +142,28 @@ export function createZohoProjectsClient(config) {
                 }
                 return response.projects[0];
             },
+            /**
+             * Create a new project
+             */
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/projects/`, z.object({ projects: z.array(ProjectSchema) }), { method: "POST", data });
+                return response.projects[0];
+            },
+            /**
+             * Update an existing project
+             */
+            async update(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/`, z.object({ projects: z.array(ProjectSchema) }), { method: "PUT", data });
+                return response.projects[0];
+            },
+            /**
+             * Delete a project (moves to trash)
+             */
+            async delete(projectId) {
+                await request(`${basePath}/projects/${projectId}/`, {
+                    method: "DELETE",
+                });
+            },
         },
         /**
          * Tasks API
@@ -199,6 +221,28 @@ export function createZohoProjectsClient(config) {
                 }
                 return allTasks;
             },
+            /**
+             * Create a new task in a project
+             */
+            async create(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/tasks/`, z.object({ tasks: z.array(TaskSchema) }), { method: "POST", data });
+                return response.tasks[0];
+            },
+            /**
+             * Update an existing task
+             */
+            async update(projectId, taskId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/tasks/${taskId}/`, z.object({ tasks: z.array(TaskSchema) }), { method: "PUT", data });
+                return response.tasks[0];
+            },
+            /**
+             * Delete a task (moves to trash)
+             */
+            async delete(projectId, taskId) {
+                await request(`${basePath}/projects/${projectId}/tasks/${taskId}/`, {
+                    method: "DELETE",
+                });
+            },
             // Internal reference to projects API
             _getProjectsRef: () => client.projects,
         },
@@ -280,6 +324,44 @@ export function createZohoProjectsClient(config) {
                 }
                 return allLogs;
             },
+            /**
+             * Create a time log for a task
+             */
+            async createForTask(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/logs/`, z.object({ timelogs: z.object({ tasklogs: z.array(TimeLogSchema) }) }), { method: "POST", data });
+                return response.timelogs.tasklogs[0];
+            },
+            /**
+             * Create a time log for a bug
+             */
+            async createForBug(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/logs/`, z.object({ timelogs: z.object({ buglogs: z.array(TimeLogSchema) }) }), { method: "POST", data });
+                return response.timelogs.buglogs[0];
+            },
+            /**
+             * Create a general time log (not tied to task or bug)
+             */
+            async createGeneral(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/logs/`, z.object({ timelogs: z.object({ generallogs: z.array(TimeLogSchema) }) }), { method: "POST", data });
+                return response.timelogs.generallogs[0];
+            },
+            /**
+             * Update a time log
+             */
+            async update(projectId, logId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/logs/${logId}/`, z.object({ timelogs: z.object({ tasklogs: z.array(TimeLogSchema).optional(), buglogs: z.array(TimeLogSchema).optional(), generallogs: z.array(TimeLogSchema).optional() }) }), { method: "PUT", data });
+                // Return whichever type was updated
+                const logs = response.timelogs.tasklogs || response.timelogs.buglogs || response.timelogs.generallogs || [];
+                return logs[0];
+            },
+            /**
+             * Delete a time log
+             */
+            async delete(projectId, logId) {
+                await request(`${basePath}/projects/${projectId}/logs/${logId}/`, {
+                    method: "DELETE",
+                });
+            },
             // Internal reference to projects API
             _getProjectsRef: () => client.projects,
         },
@@ -339,6 +421,1546 @@ export function createZohoProjectsClient(config) {
                     pageInfo: response.page_info,
                 };
             },
+            /**
+             * Invite a new user to the portal
+             */
+            async invite(data) {
+                const response = await requestWithValidation(`${basePath}/users/`, z.object({ users: z.array(UserSchema) }), { method: "POST", data });
+                return response.users[0];
+            },
+            /**
+             * Add a user to a project
+             */
+            async addToProject(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/users/`, z.object({ users: z.array(UserSchema) }), { method: "POST", data });
+                return response.users[0];
+            },
+            /**
+             * Update a user's details
+             */
+            async update(userId, data) {
+                const response = await requestWithValidation(`${basePath}/users/${userId}/`, z.object({ users: z.array(UserSchema) }), { method: "PUT", data });
+                return response.users[0];
+            },
+            /**
+             * Remove a user from the portal
+             */
+            async delete(userId) {
+                await request(`${basePath}/users/${userId}/`, {
+                    method: "DELETE",
+                });
+            },
+            /**
+             * Remove a user from a project
+             */
+            async removeFromProject(projectId, userId) {
+                await request(`${basePath}/projects/${projectId}/users/${userId}/`, {
+                    method: "DELETE",
+                });
+            },
+        },
+        /**
+         * Tags API
+         */
+        tags: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/tags/`, TagListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.tags, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(tagId) {
+                const response = await requestWithValidation(`${basePath}/tags/${tagId}/`, z.object({ tags: z.array(TagSchema) }));
+                if (response.tags.length === 0) {
+                    throw new ZohoProjectsError(`Tag not found: ${tagId}`, 404);
+                }
+                return response.tags[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/tags/`, z.object({ tags: z.array(TagSchema) }), { method: "POST", data });
+                return response.tags[0];
+            },
+            async update(tagId, data) {
+                const response = await requestWithValidation(`${basePath}/tags/${tagId}/`, z.object({ tags: z.array(TagSchema) }), { method: "PUT", data });
+                return response.tags[0];
+            },
+            async delete(tagId) {
+                await request(`${basePath}/tags/${tagId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Roles API
+         */
+        roles: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/roles/`, RoleListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.roles, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(roleId) {
+                const response = await requestWithValidation(`${basePath}/roles/${roleId}/`, z.object({ roles: z.array(RoleSchema) }));
+                if (response.roles.length === 0) {
+                    throw new ZohoProjectsError(`Role not found: ${roleId}`, 404);
+                }
+                return response.roles[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/roles/`, z.object({ roles: z.array(RoleSchema) }), { method: "POST", data });
+                return response.roles[0];
+            },
+            async update(roleId, data) {
+                const response = await requestWithValidation(`${basePath}/roles/${roleId}/`, z.object({ roles: z.array(RoleSchema) }), { method: "PUT", data });
+                return response.roles[0];
+            },
+            async delete(roleId) {
+                await request(`${basePath}/roles/${roleId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Profiles API
+         */
+        profiles: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/profiles/`, ProfileListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.profiles, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(profileId) {
+                const response = await requestWithValidation(`${basePath}/profiles/${profileId}/`, z.object({ profiles: z.array(ProfileSchema) }));
+                if (response.profiles.length === 0) {
+                    throw new ZohoProjectsError(`Profile not found: ${profileId}`, 404);
+                }
+                return response.profiles[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/profiles/`, z.object({ profiles: z.array(ProfileSchema) }), { method: "POST", data });
+                return response.profiles[0];
+            },
+            async update(profileId, data) {
+                const response = await requestWithValidation(`${basePath}/profiles/${profileId}/`, z.object({ profiles: z.array(ProfileSchema) }), { method: "PUT", data });
+                return response.profiles[0];
+            },
+            async delete(profileId) {
+                await request(`${basePath}/profiles/${profileId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Clients API
+         */
+        clients: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/clients/`, ClientListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.clients, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(clientId) {
+                const response = await requestWithValidation(`${basePath}/clients/${clientId}/`, z.object({ clients: z.array(ClientSchema) }));
+                if (response.clients.length === 0) {
+                    throw new ZohoProjectsError(`Client not found: ${clientId}`, 404);
+                }
+                return response.clients[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/clients/`, z.object({ clients: z.array(ClientSchema) }), { method: "POST", data });
+                return response.clients[0];
+            },
+            async update(clientId, data) {
+                const response = await requestWithValidation(`${basePath}/clients/${clientId}/`, z.object({ clients: z.array(ClientSchema) }), { method: "PUT", data });
+                return response.clients[0];
+            },
+            async delete(clientId) {
+                await request(`${basePath}/clients/${clientId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Contacts API
+         */
+        contacts: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/contacts/`, ContactListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.contacts, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(contactId) {
+                const response = await requestWithValidation(`${basePath}/contacts/${contactId}/`, z.object({ contacts: z.array(ContactSchema) }));
+                if (response.contacts.length === 0) {
+                    throw new ZohoProjectsError(`Contact not found: ${contactId}`, 404);
+                }
+                return response.contacts[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/contacts/`, z.object({ contacts: z.array(ContactSchema) }), { method: "POST", data });
+                return response.contacts[0];
+            },
+            async update(contactId, data) {
+                const response = await requestWithValidation(`${basePath}/contacts/${contactId}/`, z.object({ contacts: z.array(ContactSchema) }), { method: "PUT", data });
+                return response.contacts[0];
+            },
+            async delete(contactId) {
+                await request(`${basePath}/contacts/${contactId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Project Groups API
+         */
+        groups: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/groups/`, ProjectGroupListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.groups, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(groupId) {
+                const response = await requestWithValidation(`${basePath}/groups/${groupId}/`, z.object({ groups: z.array(ProjectGroupSchema) }));
+                if (response.groups.length === 0) {
+                    throw new ZohoProjectsError(`Project group not found: ${groupId}`, 404);
+                }
+                return response.groups[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/groups/`, z.object({ groups: z.array(ProjectGroupSchema) }), { method: "POST", data });
+                return response.groups[0];
+            },
+            async update(groupId, data) {
+                const response = await requestWithValidation(`${basePath}/groups/${groupId}/`, z.object({ groups: z.array(ProjectGroupSchema) }), { method: "PUT", data });
+                return response.groups[0];
+            },
+            async delete(groupId) {
+                await request(`${basePath}/groups/${groupId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Leaves API
+         */
+        leaves: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/leaves/`, LeaveListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.leaves, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(leaveId) {
+                const response = await requestWithValidation(`${basePath}/leaves/${leaveId}/`, z.object({ leaves: z.array(LeaveSchema) }));
+                if (response.leaves.length === 0) {
+                    throw new ZohoProjectsError(`Leave not found: ${leaveId}`, 404);
+                }
+                return response.leaves[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/leaves/`, z.object({ leaves: z.array(LeaveSchema) }), { method: "POST", data });
+                return response.leaves[0];
+            },
+            async update(leaveId, data) {
+                const response = await requestWithValidation(`${basePath}/leaves/${leaveId}/`, z.object({ leaves: z.array(LeaveSchema) }), { method: "PUT", data });
+                return response.leaves[0];
+            },
+            async delete(leaveId) {
+                await request(`${basePath}/leaves/${leaveId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Teams API
+         */
+        teams: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/teams/`, TeamListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.teams, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(teamId) {
+                const response = await requestWithValidation(`${basePath}/teams/${teamId}/`, z.object({ teams: z.array(TeamSchema) }));
+                if (response.teams.length === 0) {
+                    throw new ZohoProjectsError(`Team not found: ${teamId}`, 404);
+                }
+                return response.teams[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/teams/`, z.object({ teams: z.array(TeamSchema) }), { method: "POST", data });
+                return response.teams[0];
+            },
+            async update(teamId, data) {
+                const response = await requestWithValidation(`${basePath}/teams/${teamId}/`, z.object({ teams: z.array(TeamSchema) }), { method: "PUT", data });
+                return response.teams[0];
+            },
+            async delete(teamId) {
+                await request(`${basePath}/teams/${teamId}/`, { method: "DELETE" });
+            },
+            async addMembers(teamId, data) {
+                const response = await requestWithValidation(`${basePath}/teams/${teamId}/members/`, z.object({ teams: z.array(TeamSchema) }), { method: "POST", data });
+                return response.teams[0];
+            },
+            async removeMember(teamId, userId) {
+                await request(`${basePath}/teams/${teamId}/members/${userId}/`, {
+                    method: "DELETE",
+                });
+            },
+        },
+        /**
+         * Task Lists API (project-scoped)
+         */
+        tasklists: {
+            async list(projectId, params) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/tasklists/`, TaskListListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.tasklists, pageInfo: response.page_info };
+            },
+            async listAll(projectId, options) {
+                return collectAll(this.iterate(projectId, options));
+            },
+            iterate(projectId, options) {
+                return autoPaginate((index, range) => this.list(projectId, { index, range }), options);
+            },
+            async get(projectId, tasklistId) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/tasklists/${tasklistId}/`, z.object({ tasklists: z.array(TaskListSchema) }));
+                if (response.tasklists.length === 0) {
+                    throw new ZohoProjectsError(`Task list not found: ${tasklistId}`, 404);
+                }
+                return response.tasklists[0];
+            },
+            async create(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/tasklists/`, z.object({ tasklists: z.array(TaskListSchema) }), { method: "POST", data });
+                return response.tasklists[0];
+            },
+            async update(projectId, tasklistId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/tasklists/${tasklistId}/`, z.object({ tasklists: z.array(TaskListSchema) }), { method: "PUT", data });
+                return response.tasklists[0];
+            },
+            async delete(projectId, tasklistId) {
+                await request(`${basePath}/projects/${projectId}/tasklists/${tasklistId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Phases (Milestones) API (project-scoped)
+         * Note: Zoho calls these "milestones" in the API
+         */
+        phases: {
+            async list(projectId, params) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/milestones/`, PhaseListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.milestones, pageInfo: response.page_info };
+            },
+            async listAll(projectId, options) {
+                return collectAll(this.iterate(projectId, options));
+            },
+            iterate(projectId, options) {
+                return autoPaginate((index, range) => this.list(projectId, { index, range }), options);
+            },
+            async get(projectId, phaseId) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/milestones/${phaseId}/`, z.object({ milestones: z.array(PhaseSchema) }));
+                if (response.milestones.length === 0) {
+                    throw new ZohoProjectsError(`Phase not found: ${phaseId}`, 404);
+                }
+                return response.milestones[0];
+            },
+            async create(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/milestones/`, z.object({ milestones: z.array(PhaseSchema) }), { method: "POST", data });
+                return response.milestones[0];
+            },
+            async update(projectId, phaseId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/milestones/${phaseId}/`, z.object({ milestones: z.array(PhaseSchema) }), { method: "PUT", data });
+                return response.milestones[0];
+            },
+            async delete(projectId, phaseId) {
+                await request(`${basePath}/projects/${projectId}/milestones/${phaseId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Issues (Bugs) API (project-scoped)
+         * Note: Zoho calls these "bugs" in the API
+         */
+        issues: {
+            async list(projectId, params) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/bugs/`, IssueListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.bugs, pageInfo: response.page_info };
+            },
+            async listAll(projectId, options) {
+                return collectAll(this.iterate(projectId, options));
+            },
+            iterate(projectId, options) {
+                return autoPaginate((index, range) => this.list(projectId, { index, range }), options);
+            },
+            async get(projectId, issueId) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/bugs/${issueId}/`, z.object({ bugs: z.array(IssueSchema) }));
+                if (response.bugs.length === 0) {
+                    throw new ZohoProjectsError(`Issue not found: ${issueId}`, 404);
+                }
+                return response.bugs[0];
+            },
+            async create(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/bugs/`, z.object({ bugs: z.array(IssueSchema) }), { method: "POST", data });
+                return response.bugs[0];
+            },
+            async update(projectId, issueId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/bugs/${issueId}/`, z.object({ bugs: z.array(IssueSchema) }), { method: "PUT", data });
+                return response.bugs[0];
+            },
+            async delete(projectId, issueId) {
+                await request(`${basePath}/projects/${projectId}/bugs/${issueId}/`, {
+                    method: "DELETE",
+                });
+            },
+        },
+        /**
+         * Forums (Discussions) API (project-scoped)
+         */
+        forums: {
+            async list(projectId, params) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/forums/`, ForumListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.forums, pageInfo: response.page_info };
+            },
+            async listAll(projectId, options) {
+                return collectAll(this.iterate(projectId, options));
+            },
+            iterate(projectId, options) {
+                return autoPaginate((index, range) => this.list(projectId, { index, range }), options);
+            },
+            async get(projectId, forumId) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/forums/${forumId}/`, z.object({ forums: z.array(ForumSchema) }));
+                if (response.forums.length === 0) {
+                    throw new ZohoProjectsError(`Forum not found: ${forumId}`, 404);
+                }
+                return response.forums[0];
+            },
+            async create(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/forums/`, z.object({ forums: z.array(ForumSchema) }), { method: "POST", data });
+                return response.forums[0];
+            },
+            async update(projectId, forumId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/forums/${forumId}/`, z.object({ forums: z.array(ForumSchema) }), { method: "PUT", data });
+                return response.forums[0];
+            },
+            async delete(projectId, forumId) {
+                await request(`${basePath}/projects/${projectId}/forums/${forumId}/`, {
+                    method: "DELETE",
+                });
+            },
+        },
+        /**
+         * Events (Calendar) API (project-scoped)
+         */
+        events: {
+            async list(projectId, params) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/events/`, EventListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.events, pageInfo: response.page_info };
+            },
+            async listAll(projectId, options) {
+                return collectAll(this.iterate(projectId, options));
+            },
+            iterate(projectId, options) {
+                return autoPaginate((index, range) => this.list(projectId, { index, range }), options);
+            },
+            async get(projectId, eventId) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/events/${eventId}/`, z.object({ events: z.array(EventSchema) }));
+                if (response.events.length === 0) {
+                    throw new ZohoProjectsError(`Event not found: ${eventId}`, 404);
+                }
+                return response.events[0];
+            },
+            async create(projectId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/events/`, z.object({ events: z.array(EventSchema) }), { method: "POST", data });
+                return response.events[0];
+            },
+            async update(projectId, eventId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/events/${eventId}/`, z.object({ events: z.array(EventSchema) }), { method: "PUT", data });
+                return response.events[0];
+            },
+            async delete(projectId, eventId) {
+                await request(`${basePath}/projects/${projectId}/events/${eventId}/`, {
+                    method: "DELETE",
+                });
+            },
+        },
+        /**
+         * Attachments API (project-scoped)
+         * Note: Upload requires multipart/form-data
+         */
+        attachments: {
+            async list(projectId, params) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/attachments/`, AttachmentListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.attachments, pageInfo: response.page_info };
+            },
+            async listAll(projectId, options) {
+                return collectAll(this.iterate(projectId, options));
+            },
+            iterate(projectId, options) {
+                return autoPaginate((index, range) => this.list(projectId, { index, range }), options);
+            },
+            async get(projectId, attachmentId) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/attachments/${attachmentId}/`, z.object({ attachments: z.array(AttachmentSchema) }));
+                if (response.attachments.length === 0) {
+                    throw new ZohoProjectsError(`Attachment not found: ${attachmentId}`, 404);
+                }
+                return response.attachments[0];
+            },
+            /**
+             * Upload an attachment
+             * @param projectId - Project ID
+             * @param file - File buffer or stream
+             * @param filename - Original filename
+             * @param options - Additional options
+             */
+            async upload(projectId, file, filename, options) {
+                const FormData = (await import("form-data")).default;
+                const formData = new FormData();
+                formData.append("uploaddoc", file, filename);
+                if (options?.name)
+                    formData.append("name", options.name);
+                if (options?.description)
+                    formData.append("description", options.description);
+                if (options?.entity_type)
+                    formData.append("entity_type", options.entity_type);
+                if (options?.entity_id)
+                    formData.append("entity_id", options.entity_id);
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/attachments/`, z.object({ attachments: z.array(AttachmentSchema) }), {
+                    method: "POST",
+                    data: formData,
+                    headers: formData.getHeaders(),
+                });
+                return response.attachments[0];
+            },
+            async delete(projectId, attachmentId) {
+                await request(`${basePath}/projects/${projectId}/attachments/${attachmentId}/`, { method: "DELETE" });
+            },
+        },
+        /**
+         * Documents API (project-scoped)
+         */
+        documents: {
+            async list(projectId, params) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/documents/`, DocumentListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                        folder_id: params?.folder_id,
+                    },
+                });
+                return { data: response.documents, pageInfo: response.page_info };
+            },
+            async listAll(projectId, options) {
+                return collectAll(this.iterate(projectId, options));
+            },
+            iterate(projectId, options) {
+                return autoPaginate((index, range) => this.list(projectId, { index, range }), options);
+            },
+            async get(projectId, documentId) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/documents/${documentId}/`, z.object({ documents: z.array(DocumentSchema) }));
+                if (response.documents.length === 0) {
+                    throw new ZohoProjectsError(`Document not found: ${documentId}`, 404);
+                }
+                return response.documents[0];
+            },
+            /**
+             * Upload a document
+             */
+            async upload(projectId, file, filename, options) {
+                const FormData = (await import("form-data")).default;
+                const formData = new FormData();
+                formData.append("uploaddoc", file, filename);
+                if (options?.name)
+                    formData.append("name", options.name);
+                if (options?.description)
+                    formData.append("description", options.description);
+                if (options?.folder_id)
+                    formData.append("folder_id", options.folder_id);
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/documents/`, z.object({ documents: z.array(DocumentSchema) }), {
+                    method: "POST",
+                    data: formData,
+                    headers: formData.getHeaders(),
+                });
+                return response.documents[0];
+            },
+            async update(projectId, documentId, data) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/documents/${documentId}/`, z.object({ documents: z.array(DocumentSchema) }), { method: "PUT", data });
+                return response.documents[0];
+            },
+            async delete(projectId, documentId) {
+                await request(`${basePath}/projects/${projectId}/documents/${documentId}/`, { method: "DELETE" });
+            },
+            // Folder operations
+            folders: {
+                async list(projectId, params) {
+                    const response = await requestWithValidation(`${basePath}/projects/${projectId}/folders/`, DocumentFolderListResponseSchema, {
+                        params: {
+                            index: params?.index ?? 0,
+                            range: params?.range ?? DEFAULT_PAGE_SIZE,
+                        },
+                    });
+                    return { data: response.folders, pageInfo: response.page_info };
+                },
+                async get(projectId, folderId) {
+                    const response = await requestWithValidation(`${basePath}/projects/${projectId}/folders/${folderId}/`, z.object({ folders: z.array(DocumentFolderSchema) }));
+                    if (response.folders.length === 0) {
+                        throw new ZohoProjectsError(`Folder not found: ${folderId}`, 404);
+                    }
+                    return response.folders[0];
+                },
+                async create(projectId, data) {
+                    const response = await requestWithValidation(`${basePath}/projects/${projectId}/folders/`, z.object({ folders: z.array(DocumentFolderSchema) }), { method: "POST", data });
+                    return response.folders[0];
+                },
+                async update(projectId, folderId, data) {
+                    const response = await requestWithValidation(`${basePath}/projects/${projectId}/folders/${folderId}/`, z.object({ folders: z.array(DocumentFolderSchema) }), { method: "PUT", data });
+                    return response.folders[0];
+                },
+                async delete(projectId, folderId) {
+                    await request(`${basePath}/projects/${projectId}/folders/${folderId}/`, { method: "DELETE" });
+                },
+            },
+        },
+        /**
+         * Comments API (polymorphic - attaches to multiple entity types)
+         * Supports: tasks, bugs, forums, milestones, events
+         */
+        comments: {
+            /**
+             * Get comments for a task
+             */
+            forTask(projectId, taskId) {
+                return this._forEntity("tasks", projectId, taskId);
+            },
+            /**
+             * Get comments for an issue (bug)
+             */
+            forIssue(projectId, issueId) {
+                return this._forEntity("bugs", projectId, issueId);
+            },
+            /**
+             * Get comments for a forum
+             */
+            forForum(projectId, forumId) {
+                return this._forEntity("forums", projectId, forumId);
+            },
+            /**
+             * Get comments for a phase (milestone)
+             */
+            forPhase(projectId, phaseId) {
+                return this._forEntity("milestones", projectId, phaseId);
+            },
+            /**
+             * Get comments for an event
+             */
+            forEvent(projectId, eventId) {
+                return this._forEntity("events", projectId, eventId);
+            },
+            /**
+             * Internal method to create comment operations for any entity type
+             */
+            _forEntity(entityType, projectId, entityId) {
+                const commentsPath = `${basePath}/projects/${projectId}/${entityType}/${entityId}/comments`;
+                return {
+                    async list(params) {
+                        const response = await requestWithValidation(`${commentsPath}/`, CommentListResponseSchema, {
+                            params: {
+                                index: params?.index ?? 0,
+                                range: params?.range ?? DEFAULT_PAGE_SIZE,
+                            },
+                        });
+                        return { data: response.comments, pageInfo: response.page_info };
+                    },
+                    async listAll(options) {
+                        return collectAll(this.iterate(options));
+                    },
+                    iterate(options) {
+                        return autoPaginate((index, range) => this.list({ index, range }), options);
+                    },
+                    async get(commentId) {
+                        const response = await requestWithValidation(`${commentsPath}/${commentId}/`, z.object({ comments: z.array(CommentSchema) }));
+                        if (response.comments.length === 0) {
+                            throw new ZohoProjectsError(`Comment not found: ${commentId}`, 404);
+                        }
+                        return response.comments[0];
+                    },
+                    async create(data) {
+                        const response = await requestWithValidation(`${commentsPath}/`, z.object({ comments: z.array(CommentSchema) }), { method: "POST", data });
+                        return response.comments[0];
+                    },
+                    async update(commentId, data) {
+                        const response = await requestWithValidation(`${commentsPath}/${commentId}/`, z.object({ comments: z.array(CommentSchema) }), { method: "PUT", data });
+                        return response.comments[0];
+                    },
+                    async delete(commentId) {
+                        await request(`${commentsPath}/${commentId}/`, {
+                            method: "DELETE",
+                        });
+                    },
+                };
+            },
+        },
+        /**
+         * Followers API (polymorphic - attaches to multiple entity types)
+         * Supports: tasks, bugs, forums, milestones, events
+         */
+        followers: {
+            /**
+             * Get followers for a task
+             */
+            forTask(projectId, taskId) {
+                return this._forEntity("tasks", projectId, taskId);
+            },
+            /**
+             * Get followers for an issue (bug)
+             */
+            forIssue(projectId, issueId) {
+                return this._forEntity("bugs", projectId, issueId);
+            },
+            /**
+             * Get followers for a forum
+             */
+            forForum(projectId, forumId) {
+                return this._forEntity("forums", projectId, forumId);
+            },
+            /**
+             * Get followers for a phase (milestone)
+             */
+            forPhase(projectId, phaseId) {
+                return this._forEntity("milestones", projectId, phaseId);
+            },
+            /**
+             * Get followers for an event
+             */
+            forEvent(projectId, eventId) {
+                return this._forEntity("events", projectId, eventId);
+            },
+            /**
+             * Internal method to create follower operations for any entity type
+             */
+            _forEntity(entityType, projectId, entityId) {
+                const followersPath = `${basePath}/projects/${projectId}/${entityType}/${entityId}/followers`;
+                return {
+                    async list(params) {
+                        const response = await requestWithValidation(`${followersPath}/`, FollowerListResponseSchema, {
+                            params: {
+                                index: params?.index ?? 0,
+                                range: params?.range ?? DEFAULT_PAGE_SIZE,
+                            },
+                        });
+                        return { data: response.followers, pageInfo: response.page_info };
+                    },
+                    async listAll(options) {
+                        return collectAll(this.iterate(options));
+                    },
+                    iterate(options) {
+                        return autoPaginate((index, range) => this.list({ index, range }), options);
+                    },
+                    async add(data) {
+                        const response = await requestWithValidation(`${followersPath}/`, z.object({ followers: z.array(FollowerSchema) }), { method: "POST", data });
+                        return response.followers;
+                    },
+                    async remove(userId) {
+                        await request(`${followersPath}/${userId}/`, {
+                            method: "DELETE",
+                        });
+                    },
+                    /**
+                     * Follow this entity as the current user
+                     */
+                    async follow() {
+                        await request(`${followersPath}/me/`, {
+                            method: "POST",
+                        });
+                    },
+                    /**
+                     * Unfollow this entity as the current user
+                     */
+                    async unfollow() {
+                        await request(`${followersPath}/me/`, {
+                            method: "DELETE",
+                        });
+                    },
+                };
+            },
+        },
+        /**
+         * Dashboards API
+         */
+        dashboards: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/dashboards/`, DashboardListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.dashboards, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(dashboardId) {
+                const response = await requestWithValidation(`${basePath}/dashboards/${dashboardId}/`, z.object({ dashboards: z.array(DashboardSchema) }));
+                if (response.dashboards.length === 0) {
+                    throw new ZohoProjectsError(`Dashboard not found: ${dashboardId}`, 404);
+                }
+                return response.dashboards[0];
+            },
+            async create(data) {
+                const response = await requestWithValidation(`${basePath}/dashboards/`, z.object({ dashboards: z.array(DashboardSchema) }), { method: "POST", data });
+                return response.dashboards[0];
+            },
+            async update(dashboardId, data) {
+                const response = await requestWithValidation(`${basePath}/dashboards/${dashboardId}/`, z.object({ dashboards: z.array(DashboardSchema) }), { method: "PUT", data });
+                return response.dashboards[0];
+            },
+            async delete(dashboardId) {
+                await request(`${basePath}/dashboards/${dashboardId}/`, {
+                    method: "DELETE",
+                });
+            },
+            /**
+             * Widget operations for a specific dashboard
+             */
+            widgets(dashboardId) {
+                const widgetsPath = `${basePath}/dashboards/${dashboardId}/widgets`;
+                return {
+                    async list(params) {
+                        const response = await requestWithValidation(`${widgetsPath}/`, WidgetListResponseSchema, {
+                            params: {
+                                index: params?.index ?? 0,
+                                range: params?.range ?? DEFAULT_PAGE_SIZE,
+                            },
+                        });
+                        return { data: response.widgets, pageInfo: response.page_info };
+                    },
+                    async listAll(options) {
+                        return collectAll(this.iterate(options));
+                    },
+                    iterate(options) {
+                        return autoPaginate((index, range) => this.list({ index, range }), options);
+                    },
+                    async get(widgetId) {
+                        const response = await requestWithValidation(`${widgetsPath}/${widgetId}/`, z.object({ widgets: z.array(WidgetSchema) }));
+                        if (response.widgets.length === 0) {
+                            throw new ZohoProjectsError(`Widget not found: ${widgetId}`, 404);
+                        }
+                        return response.widgets[0];
+                    },
+                    async create(data) {
+                        const response = await requestWithValidation(`${widgetsPath}/`, z.object({ widgets: z.array(WidgetSchema) }), { method: "POST", data });
+                        return response.widgets[0];
+                    },
+                    async update(widgetId, data) {
+                        const response = await requestWithValidation(`${widgetsPath}/${widgetId}/`, z.object({ widgets: z.array(WidgetSchema) }), { method: "PUT", data });
+                        return response.widgets[0];
+                    },
+                    async delete(widgetId) {
+                        await request(`${widgetsPath}/${widgetId}/`, {
+                            method: "DELETE",
+                        });
+                    },
+                };
+            },
+        },
+        /**
+         * Reports API
+         * Reports are typically read-only with specialized query parameters
+         */
+        reports: {
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/reports/`, ReportListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.reports, pageInfo: response.page_info };
+            },
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            async get(reportId) {
+                const response = await requestWithValidation(`${basePath}/reports/${reportId}/`, z.object({ reports: z.array(ReportSchema) }));
+                if (response.reports.length === 0) {
+                    throw new ZohoProjectsError(`Report not found: ${reportId}`, 404);
+                }
+                return response.reports[0];
+            },
+            /**
+             * Execute a report and get its data
+             */
+            async execute(reportId, query) {
+                const response = await requestWithValidation(`${basePath}/reports/${reportId}/data/`, ReportDataResponseSchema, {
+                    params: {
+                        index: query?.index ?? 0,
+                        range: query?.range ?? DEFAULT_PAGE_SIZE,
+                        sort_by: query?.sort_by,
+                        sort_order: query?.sort_order,
+                        group_by: query?.group_by,
+                        start_date: query?.start_date,
+                        end_date: query?.end_date,
+                    },
+                });
+                return response;
+            },
+            /**
+             * List reports for a specific project
+             */
+            async listForProject(projectId, params) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/reports/`, ReportListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.reports, pageInfo: response.page_info };
+            },
+        },
+        /**
+         * Search API
+         * Global search across entities
+         */
+        search: {
+            /**
+             * Search across all entities
+             */
+            async query(query) {
+                const response = await requestWithValidation(`${basePath}/search/`, SearchResponseSchema, {
+                    params: {
+                        search_term: query.search_term,
+                        entity_type: query.entity_type,
+                        project_id: query.project_id,
+                        status: query.status,
+                        owner: query.owner,
+                        start_date: query.start_date,
+                        end_date: query.end_date,
+                        index: query.index ?? 0,
+                        range: query.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                const results = response.results || response.search_results || [];
+                return { data: results, pageInfo: response.page_info };
+            },
+            /**
+             * Search within a specific project
+             */
+            async inProject(projectId, query) {
+                return this.query({ ...query, project_id: projectId });
+            },
+            /**
+             * Search for tasks
+             */
+            async tasks(searchTerm, params) {
+                return this.query({
+                    search_term: searchTerm,
+                    entity_type: "task",
+                    ...params,
+                });
+            },
+            /**
+             * Search for issues (bugs)
+             */
+            async issues(searchTerm, params) {
+                return this.query({
+                    search_term: searchTerm,
+                    entity_type: "bug",
+                    ...params,
+                });
+            },
+            /**
+             * Search for projects
+             */
+            async projects(searchTerm, params) {
+                return this.query({
+                    search_term: searchTerm,
+                    entity_type: "project",
+                    ...params,
+                });
+            },
+        },
+        /**
+         * Trash API
+         * Manage deleted items
+         */
+        trash: {
+            /**
+             * List items in trash
+             */
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/trash/`, TrashListResponseSchema, {
+                    params: {
+                        entity_type: params?.entity_type,
+                        project_id: params?.project_id,
+                        deleted_by: params?.deleted_by,
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                const items = response.trash || response.deleted_items || [];
+                return { data: items, pageInfo: response.page_info };
+            },
+            /**
+             * List all items in trash with auto-pagination
+             */
+            async listAll(params, options) {
+                return collectAll(this.iterate(params, options));
+            },
+            /**
+             * Iterate over all trash items with auto-pagination
+             */
+            iterate(params, options) {
+                return autoPaginate((index, range) => this.list({ ...params, index, range }), options);
+            },
+            /**
+             * Restore an item from trash
+             */
+            async restore(entityType, itemId) {
+                const response = await requestWithValidation(`${basePath}/trash/${entityType}/${itemId}/restore/`, TrashRestoreResponseSchema, { method: "POST" });
+                return response;
+            },
+            /**
+             * Permanently delete an item from trash
+             */
+            async permanentDelete(entityType, itemId) {
+                await request(`${basePath}/trash/${entityType}/${itemId}/`, {
+                    method: "DELETE",
+                });
+            },
+            /**
+             * Empty trash (permanently delete all items)
+             */
+            async empty(entityType) {
+                const path = entityType
+                    ? `${basePath}/trash/${entityType}/`
+                    : `${basePath}/trash/`;
+                await request(path, { method: "DELETE" });
+            },
+            /**
+             * List trash for a specific project
+             */
+            async listForProject(projectId, params) {
+                return this.list({ ...params, project_id: projectId });
+            },
+        },
+        /**
+         * Portals API
+         * Note: Portals are accessed at a higher level than portal-specific endpoints
+         */
+        portals: {
+            /**
+             * List all portals accessible to the authenticated user
+             */
+            async list() {
+                const response = await requestWithValidation(`/restapi/portals/`, PortalListResponseSchema);
+                return response.portals;
+            },
+            /**
+             * Get a specific portal by ID
+             */
+            async get(portalId) {
+                const response = await requestWithValidation(`/restapi/portals/${portalId}/`, z.object({ portals: z.array(PortalSchema) }));
+                if (response.portals.length === 0) {
+                    throw new ZohoProjectsError(`Portal not found: ${portalId}`, 404);
+                }
+                return response.portals[0];
+            },
+            /**
+             * Get the current portal (the one configured in the client)
+             */
+            async getCurrent() {
+                return this.get(portalId);
+            },
+        },
+        /**
+         * Modules API
+         * Get module definitions and field metadata
+         */
+        modules: {
+            /**
+             * List all modules in the portal
+             */
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/settings/modules/`, ModuleListResponseSchema, {
+                    params: {
+                        is_customized: params?.is_customized,
+                        is_default: params?.is_default,
+                        is_web_tab: params?.is_web_tab,
+                    },
+                });
+                return response.modules;
+            },
+            /**
+             * Get a specific module by ID
+             */
+            async get(moduleId) {
+                const response = await requestWithValidation(`${basePath}/settings/modules/${moduleId}/`, z.object({ modules: z.array(ModuleSchema) }));
+                if (response.modules.length === 0) {
+                    throw new ZohoProjectsError(`Module not found: ${moduleId}`, 404);
+                }
+                return response.modules[0];
+            },
+            /**
+             * Get fields for a module
+             */
+            async getFields(moduleId) {
+                const response = await requestWithValidation(`${basePath}/settings/modules/${moduleId}/fields/`, ModuleFieldListResponseSchema);
+                return response.fields;
+            },
+            /**
+             * Get a specific field definition
+             */
+            async getField(moduleId, fieldId) {
+                const response = await requestWithValidation(`${basePath}/settings/modules/${moduleId}/fields/${fieldId}/`, z.object({ fields: z.array(ModuleFieldSchema) }));
+                if (response.fields.length === 0) {
+                    throw new ZohoProjectsError(`Field not found: ${fieldId}`, 404);
+                }
+                return response.fields[0];
+            },
+            /**
+             * Get project-specific field values (custom field options specific to a project)
+             */
+            async getProjectFields(projectId, moduleId) {
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/settings/modules/${moduleId}/fields/`, ModuleFieldListResponseSchema);
+                return response.fields;
+            },
+        },
+        /**
+         * Timers API
+         * Start, stop, pause, and resume time tracking
+         */
+        timers: {
+            /**
+             * Get current running timer for the authenticated user
+             */
+            async getCurrent() {
+                const rawResponse = await request(`${basePath}/mytimers/`);
+                if (!rawResponse || rawResponse === "") {
+                    return null;
+                }
+                const result = TimerListResponseSchema.safeParse(rawResponse);
+                if (!result.success || result.data.timers.length === 0) {
+                    return null;
+                }
+                return result.data.timers[0];
+            },
+            /**
+             * List all running timers
+             */
+            async list() {
+                const rawResponse = await request(`${basePath}/mytimers/`);
+                if (!rawResponse || rawResponse === "") {
+                    return [];
+                }
+                const result = TimerListResponseSchema.safeParse(rawResponse);
+                if (!result.success) {
+                    return [];
+                }
+                return result.data.timers;
+            },
+            /**
+             * Start a timer for a task or issue
+             */
+            async start(data) {
+                const response = await requestWithValidation(`${basePath}/projects/${data.project_id}/${data.type.toLowerCase()}s/${data.entity_id}/timer/start/`, TimerResponseSchema, {
+                    method: "POST",
+                    data: {
+                        notes: data.notes,
+                        bill_status: data.bill_status,
+                    },
+                });
+                return response.timer || response.timers?.[0];
+            },
+            /**
+             * Stop a running timer
+             */
+            async stop(data) {
+                let path;
+                if (data.project_id && data.type && data.entity_id) {
+                    path = `${basePath}/projects/${data.project_id}/${data.type.toLowerCase()}s/${data.entity_id}/timer/stop/`;
+                }
+                else {
+                    path = `${basePath}/mytimers/stop/`;
+                }
+                const response = await requestWithValidation(path, TimerResponseSchema, {
+                    method: "POST",
+                    data: {
+                        log_name: data.log_name,
+                        date: data.date,
+                        hours: data.hours,
+                        start_time: data.start_time,
+                        end_time: data.end_time,
+                        bill_status: data.bill_status,
+                        notes: data.notes,
+                    },
+                });
+                return response.timer || response.timers?.[0];
+            },
+            /**
+             * Pause a running timer
+             */
+            async pause(data) {
+                let path;
+                if (data?.type && data?.entity_id) {
+                    path = `${basePath}/projects/${data.log_id}/${data.type.toLowerCase()}s/${data.entity_id}/timer/pause/`;
+                }
+                else {
+                    path = `${basePath}/mytimers/pause/`;
+                }
+                const response = await requestWithValidation(path, TimerResponseSchema, {
+                    method: "POST",
+                    data: {
+                        notes: data?.notes,
+                    },
+                });
+                return response.timer || response.timers?.[0];
+            },
+            /**
+             * Resume a paused timer
+             */
+            async resume(data) {
+                let path;
+                if (data?.type && data?.entity_id) {
+                    path = `${basePath}/projects/${data.log_id}/${data.type.toLowerCase()}s/${data.entity_id}/timer/resume/`;
+                }
+                else {
+                    path = `${basePath}/mytimers/resume/`;
+                }
+                const response = await requestWithValidation(path, TimerResponseSchema, {
+                    method: "POST",
+                    data: {
+                        notes: data?.notes,
+                    },
+                });
+                return response.timer || response.timers?.[0];
+            },
+            /**
+             * Start timer for a task
+             */
+            async startForTask(projectId, taskId, options) {
+                return this.start({
+                    entity_id: taskId,
+                    type: "Task",
+                    project_id: projectId,
+                    notes: options?.notes,
+                    bill_status: options?.bill_status,
+                });
+            },
+            /**
+             * Start timer for an issue
+             */
+            async startForIssue(projectId, issueId, options) {
+                return this.start({
+                    entity_id: issueId,
+                    type: "Issue",
+                    project_id: projectId,
+                    notes: options?.notes,
+                    bill_status: options?.bill_status,
+                });
+            },
+        },
+        /**
+         * Custom Views API
+         * Manage saved filters and views for tasks, issues, etc.
+         */
+        customViews: {
+            /**
+             * List custom views for a specific entity type
+             */
+            async list(entityType, params) {
+                const response = await requestWithValidation(`${basePath}/${entityType}/customviews/`, CustomViewListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.customviews, pageInfo: response.page_info };
+            },
+            /**
+             * Get all custom views with auto-pagination
+             */
+            async listAll(entityType, options) {
+                return collectAll(this.iterate(entityType, options));
+            },
+            /**
+             * Iterate over all custom views with auto-pagination
+             */
+            iterate(entityType, options) {
+                return autoPaginate((index, range) => this.list(entityType, { index, range }), options);
+            },
+            /**
+             * Get a specific custom view
+             */
+            async get(entityType, viewId) {
+                const response = await requestWithValidation(`${basePath}/${entityType}/customviews/${viewId}/`, z.object({ customviews: z.array(CustomViewSchema) }));
+                if (response.customviews.length === 0) {
+                    throw new ZohoProjectsError(`Custom view not found: ${viewId}`, 404);
+                }
+                return response.customviews[0];
+            },
+            /**
+             * Create a custom view
+             */
+            async create(entityType, data) {
+                const response = await requestWithValidation(`${basePath}/${entityType}/customviews/`, z.object({ customviews: z.array(CustomViewSchema) }), { method: "POST", data });
+                return response.customviews[0];
+            },
+            /**
+             * Update a custom view
+             */
+            async update(entityType, viewId, data) {
+                const response = await requestWithValidation(`${basePath}/${entityType}/customviews/${viewId}/`, z.object({ customviews: z.array(CustomViewSchema) }), { method: "PUT", data });
+                return response.customviews[0];
+            },
+            /**
+             * Delete a custom view
+             */
+            async delete(entityType, viewId) {
+                await request(`${basePath}/${entityType}/customviews/${viewId}/`, {
+                    method: "DELETE",
+                });
+            },
+            /**
+             * List task custom views
+             */
+            forTasks() {
+                return {
+                    list: (params) => this.list("tasks", params),
+                    listAll: (options) => this.listAll("tasks", options),
+                    iterate: (options) => this.iterate("tasks", options),
+                    get: (viewId) => this.get("tasks", viewId),
+                    create: (data) => this.create("tasks", data),
+                    update: (viewId, data) => this.update("tasks", viewId, data),
+                    delete: (viewId) => this.delete("tasks", viewId),
+                };
+            },
+            /**
+             * List issue custom views
+             */
+            forIssues() {
+                return {
+                    list: (params) => this.list("issues", params),
+                    listAll: (options) => this.listAll("issues", options),
+                    iterate: (options) => this.iterate("issues", options),
+                    get: (viewId) => this.get("issues", viewId),
+                    create: (data) => this.create("issues", data),
+                    update: (viewId, data) => this.update("issues", viewId, data),
+                    delete: (viewId) => this.delete("issues", viewId),
+                };
+            },
+            /**
+             * List milestone custom views
+             */
+            forMilestones() {
+                return {
+                    list: (params) => this.list("milestones", params),
+                    listAll: (options) => this.listAll("milestones", options),
+                    iterate: (options) => this.iterate("milestones", options),
+                    get: (viewId) => this.get("milestones", viewId),
+                    create: (data) => this.create("milestones", data),
+                    update: (viewId, data) => this.update("milestones", viewId, data),
+                    delete: (viewId) => this.delete("milestones", viewId),
+                };
+            },
+        },
+        /**
+         * Blueprints API
+         * Workflow automation and status transitions
+         */
+        blueprints: {
+            /**
+             * List all blueprints
+             */
+            async list(params) {
+                const response = await requestWithValidation(`${basePath}/settings/blueprints/`, BlueprintListResponseSchema, {
+                    params: {
+                        index: params?.index ?? 0,
+                        range: params?.range ?? DEFAULT_PAGE_SIZE,
+                    },
+                });
+                return { data: response.blueprints, pageInfo: response.page_info };
+            },
+            /**
+             * Get all blueprints with auto-pagination
+             */
+            async listAll(options) {
+                return collectAll(this.iterate(options));
+            },
+            /**
+             * Iterate over all blueprints with auto-pagination
+             */
+            iterate(options) {
+                return autoPaginate((index, range) => this.list({ index, range }), options);
+            },
+            /**
+             * Get a specific blueprint
+             */
+            async get(blueprintId) {
+                const response = await requestWithValidation(`${basePath}/settings/blueprints/${blueprintId}/`, z.object({ blueprints: z.array(BlueprintSchema) }));
+                if (response.blueprints.length === 0) {
+                    throw new ZohoProjectsError(`Blueprint not found: ${blueprintId}`, 404);
+                }
+                return response.blueprints[0];
+            },
+            /**
+             * Get available transitions for an entity (task or issue)
+             */
+            async getNextTransitions(projectId, moduleType, entityId) {
+                const modulePath = moduleType === "Task" ? "tasks" : "bugs";
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/${modulePath}/${entityId}/transitions/`, NextTransitionsResponseSchema);
+                return response;
+            },
+            /**
+             * Get required actions (fields) for a specific transition
+             */
+            async getDuringActions(projectId, moduleType, entityId, transitionId) {
+                const modulePath = moduleType === "Task" ? "tasks" : "bugs";
+                const response = await requestWithValidation(`${basePath}/projects/${projectId}/${modulePath}/${entityId}/transitions/${transitionId}/actions/`, DuringActionsResponseSchema);
+                return response;
+            },
+            /**
+             * Execute a blueprint transition
+             */
+            async executeTransition(projectId, moduleType, transitionId, data) {
+                const modulePath = moduleType === "Task" ? "tasks" : "bugs";
+                await request(`${basePath}/projects/${projectId}/${modulePath}/${data.entity_id}/transitions/${transitionId}/`, {
+                    method: "POST",
+                    data: {
+                        skip_bug_validation: data.skip_bug_validation,
+                        field_values: data.field_values,
+                    },
+                });
+            },
+            /**
+             * Get transitions for a task
+             */
+            async getTaskTransitions(projectId, taskId) {
+                const response = await this.getNextTransitions(projectId, "Task", taskId);
+                return response.transitions;
+            },
+            /**
+             * Get transitions for an issue
+             */
+            async getIssueTransitions(projectId, issueId) {
+                const response = await this.getNextTransitions(projectId, "Issue", issueId);
+                return response.transitions;
+            },
+            /**
+             * Execute a task transition
+             */
+            async executeTaskTransition(projectId, taskId, transitionId, data) {
+                return this.executeTransition(projectId, "Task", transitionId, {
+                    entity_id: taskId,
+                    ...data,
+                });
+            },
+            /**
+             * Execute an issue transition
+             */
+            async executeIssueTransition(projectId, issueId, transitionId, data) {
+                return this.executeTransition(projectId, "Issue", transitionId, {
+                    entity_id: issueId,
+                    ...data,
+                });
+            },
         },
         /**
          * Get the underlying token manager for advanced use cases