backlog-mcp-server 0.16.0 → 0.18.0

package/build/tools/getPullRequests.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { PullRequestSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getPullRequestsSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -15,5 +15,5 @@ declare const getPullRequestsSchema: (t: DescriptionHelper["t"]) => {
     offset: z.ZodOptional<z.ZodNumber>;
     count: z.ZodOptional<z.ZodNumber>;
 };
-export declare const getPullRequestsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPullRequestsSchema>, (typeof PullRequestSchema)["shape"]>;
+export declare const getPullRequestsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPullRequestsSchema>, Entity.PullRequest.PullRequest>;
 export {};

package/build/tools/getPullRequests.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { PullRequestSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
 const getPullRequestsSchema = buildToolSchema((t) => ({
     projectId: z
@@ -49,7 +49,31 @@ export const getPullRequestsTool = (backlog, { t }) => {
         name: 'get_pull_requests',
         description: t('TOOL_GET_PULL_REQUESTS_DESCRIPTION', 'Returns list of pull requests for a repository'),
         schema: z.object(getPullRequestsSchema(t)),
-        outputSchema: PullRequestSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'repositoryId',
+            'number',
+            'summary',
+            'description',
+            'base',
+            'branch',
+            'status',
+            'assignee',
+            'issue',
+            'baseCommit',
+            'branchCommit',
+            'mergeCommit',
+            'closeAt',
+            'mergeAt',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+            'attachments',
+            'stars',
+        ]),
         handler: async ({ projectId, projectKey, repoId, repoName, ...params }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/getPullRequestsCount.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { PullRequestCountSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getPullRequestsCountSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -13,5 +13,5 @@ declare const getPullRequestsCountSchema: (t: DescriptionHelper["t"]) => {
     issueId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     createdUserId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
 };
-export declare const getPullRequestsCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPullRequestsCountSchema>, (typeof PullRequestCountSchema)["shape"]>;
+export declare const getPullRequestsCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPullRequestsCountSchema>, Entity.PullRequest.PullRequestCount>;
 export {};

package/build/tools/getPullRequestsCount.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { PullRequestCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
 const getPullRequestsCountSchema = buildToolSchema((t) => ({
     projectId: z
@@ -41,7 +41,10 @@ export const getPullRequestsCountTool = (backlog, { t }) => {
         name: 'get_pull_requests_count',
         description: t('TOOL_GET_PULL_REQUESTS_COUNT_DESCRIPTION', 'Returns count of pull requests for a repository'),
         schema: z.object(getPullRequestsCountSchema(t)),
-        outputSchema: PullRequestCountSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'count',
+        ]),
         handler: async ({ projectId, projectKey, repoId, repoName, ...params }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/getRelatedIssues.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { RelatedIssueSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getRelatedIssuesSchema: (t: DescriptionHelper["t"]) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
 };
-export declare const getRelatedIssuesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getRelatedIssuesSchema>, (typeof RelatedIssueSchema)["shape"]>;
+export declare const getRelatedIssuesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getRelatedIssuesSchema>, Entity.Issue.RelatedIssue>;
 export {};

package/build/tools/getRelatedIssues.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { RelatedIssueSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getRelatedIssuesSchema = buildToolSchema((t) => ({
     issueId: z
@@ -18,7 +18,38 @@ export const getRelatedIssuesTool = (backlog, { t }) => {
         description: t('TOOL_GET_RELATED_ISSUES_DESCRIPTION', 'Returns list of issues related to a specific issue'),
         schema: z.object(getRelatedIssuesSchema(t)),
         importantFields: ['issueKey', 'summary', 'status', 'type'],
-        outputSchema: RelatedIssueSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'issueKey',
+            'keyId',
+            'issueType',
+            'summary',
+            'description',
+            'resolution',
+            'priority',
+            'status',
+            'assignee',
+            'category',
+            'versions',
+            'milestone',
+            'startDate',
+            'dueDate',
+            'estimatedHours',
+            'actualHours',
+            'parentIssueId',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+            'customFields',
+            'attachments',
+            'sharedFiles',
+            'stars',
+            'childIssueSummary',
+            'type',
+        ]),
         handler: async ({ issueId, issueKey }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
             if (!result.ok) {

package/build/tools/getResolutions.d.ts

@@ -1,7 +1,7 @@
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { ResolutionSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getResolutionsSchema: (t: DescriptionHelper["t"]) => {};
-export declare const getResolutionsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getResolutionsSchema>, (typeof ResolutionSchema)["shape"]>;
+export declare const getResolutionsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getResolutionsSchema>, Entity.Issue.Resolution>;
 export {};

package/build/tools/getResolutions.js

@@ -1,13 +1,14 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { ResolutionSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getResolutionsSchema = buildToolSchema((_t) => ({}));
 export const getResolutionsTool = (backlog, { t }) => {
     return {
         name: 'get_resolutions',
         description: t('TOOL_GET_RESOLUTIONS_DESCRIPTION', 'Returns list of issue resolutions'),
         schema: z.object(getResolutionsSchema(t)),
-        outputSchema: ResolutionSchema,
+        returnsList: true,
+        outputFields: outputFields()(['id', 'name']),
         handler: async () => backlog.getResolutions(),
     };
 };

package/build/tools/getSpace.d.ts

@@ -1,7 +1,7 @@
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { SpaceSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getSpaceSchema: (t: DescriptionHelper["t"]) => {};
-export declare const getSpaceTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getSpaceSchema>, (typeof SpaceSchema)["shape"]>;
+export declare const getSpaceTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getSpaceSchema>, Entity.Space.Space>;
 export {};

package/build/tools/getSpace.js

@@ -1,13 +1,24 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { SpaceSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getSpaceSchema = buildToolSchema((_t) => ({}));
 export const getSpaceTool = (backlog, { t }) => {
     return {
         name: 'get_space',
         description: t('TOOL_GET_SPACE_DESCRIPTION', 'Returns information about the Backlog space'),
         schema: z.object(getSpaceSchema(t)),
-        outputSchema: SpaceSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'spaceKey',
+            'name',
+            'ownerId',
+            'lang',
+            'timezone',
+            'reportSendTime',
+            'textFormattingRule',
+            'created',
+            'updated',
+        ]),
         importantFields: ['spaceKey', 'name', 'lang', 'timezone'],
         handler: async () => backlog.getSpace(),
     };

package/build/tools/getSpaceActivities.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { ActivitySchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getSpaceActivitiesSchema: (t: DescriptionHelper["t"]) => {
     activityTypeId: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         Undefined: number;
@@ -41,5 +41,5 @@ declare const getSpaceActivitiesSchema: (t: DescriptionHelper["t"]) => {
         desc: "desc";
     }>>;
 };
-export declare const getSpaceActivitiesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getSpaceActivitiesSchema>, (typeof ActivitySchema)["shape"]>;
+export declare const getSpaceActivitiesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getSpaceActivitiesSchema>, Entity.Activity.Activity>;
 export {};

package/build/tools/getSpaceActivities.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { ActivitySchema, ActivityTypeSchema, } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
+import { ActivityTypeSchema } from '../types/zod/activityType.js';
 const getSpaceActivitiesSchema = buildToolSchema((t) => ({
     activityTypeId: z
         .array(ActivityTypeSchema)
@@ -30,7 +31,16 @@ export const getSpaceActivitiesTool = (backlog, { t }) => {
         name: 'get_space_activities',
         description: t('TOOL_GET_SPACE_ACTIVITIES_DESCRIPTION', 'Returns list of space activities'),
         schema: z.object(getSpaceActivitiesSchema(t)),
-        outputSchema: ActivitySchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'project',
+            'type',
+            'content',
+            'notifications',
+            'createdUser',
+            'created',
+        ]),
         handler: async ({ activityTypeId, minId, maxId, count, order }) => backlog.getSpaceActivities({
             activityTypeId,
             minId,

package/build/tools/getUserRecentUpdates.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { ActivitySchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getUserRecentUpdatesSchema: (t: DescriptionHelper["t"]) => {
     userId: z.ZodNumber;
     activityTypeId: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -42,5 +42,5 @@ declare const getUserRecentUpdatesSchema: (t: DescriptionHelper["t"]) => {
         desc: "desc";
     }>>>;
 };
-export declare const getUserRecentUpdatesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getUserRecentUpdatesSchema>, (typeof ActivitySchema)["shape"]>;
+export declare const getUserRecentUpdatesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getUserRecentUpdatesSchema>, Entity.Activity.Activity>;
 export {};

package/build/tools/getUserRecentUpdates.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { ActivitySchema, ActivityTypeSchema, } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
+import { ActivityTypeSchema } from '../types/zod/activityType.js';
 const getUserRecentUpdatesSchema = buildToolSchema((t) => ({
     userId: z
         .number()
@@ -35,7 +36,16 @@ export const getUserRecentUpdatesTool = (backlog, { t }) => {
         name: 'get_user_recent_updates',
         description: t('TOOL_GET_USER_RECENT_UPDATES_DESCRIPTION', 'Returns recent updates (activities) for a specific user'),
         schema: z.object(getUserRecentUpdatesSchema(t)),
-        outputSchema: ActivitySchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'project',
+            'type',
+            'content',
+            'notifications',
+            'createdUser',
+            'created',
+        ]),
         importantFields: ['id', 'type', 'content', 'created'],
         handler: async ({ userId, activityTypeId, minId, maxId, count, order }) => backlog.getUserActivities(userId, {
             activityTypeId,

package/build/tools/getUserStarsCount.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { StarCountSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getUserStarsCountSchema: (t: DescriptionHelper["t"]) => {
     userId: z.ZodNumber;
     since: z.ZodOptional<z.ZodString>;
     until: z.ZodOptional<z.ZodString>;
 };
-export declare const getUserStarsCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getUserStarsCountSchema>, (typeof StarCountSchema)["shape"]>;
+export declare const getUserStarsCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getUserStarsCountSchema>, Entity.Star.StarCount>;
 export {};

package/build/tools/getUserStarsCount.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { StarCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getUserStarsCountSchema = buildToolSchema((t) => ({
     userId: z
         .number()
@@ -19,7 +19,8 @@ export const getUserStarsCountTool = (backlog, { t }) => {
         name: 'get_user_stars_count',
         description: t('TOOL_GET_USER_STARS_COUNT_DESCRIPTION', 'Returns the count of stars received by a user'),
         schema: z.object(getUserStarsCountSchema(t)),
-        outputSchema: StarCountSchema,
+        returnsList: false,
+        outputFields: outputFields()(['count']),
         handler: async ({ userId, since, until }) => backlog.getUserStarsCount(userId, { since, until }),
     };
 };

package/build/tools/getUsers.d.ts

@@ -1,7 +1,7 @@
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { UserSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getUsersSchema: (t: DescriptionHelper["t"]) => {};
-export declare const getUsersTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getUsersSchema>, (typeof UserSchema)["shape"]>;
+export declare const getUsersTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getUsersSchema>, Entity.User.User>;
 export {};

package/build/tools/getUsers.js

@@ -1,13 +1,22 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { UserSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getUsersSchema = buildToolSchema((_t) => ({}));
 export const getUsersTool = (backlog, { t }) => {
     return {
         name: 'get_users',
         description: t('TOOL_GET_USERS_DESCRIPTION', 'Returns list of users in the Backlog space'),
         schema: z.object(getUsersSchema(t)),
-        outputSchema: UserSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'userId',
+            'name',
+            'roleType',
+            'lang',
+            'mailAddress',
+            'lastLoginTime',
+        ]),
         importantFields: ['userId', 'name', 'roleType', 'lang'],
         handler: async () => backlog.getUsers(),
     };

package/build/tools/getVersionMilestoneList.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getVersionMilestoneListSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };
-export declare const getVersionMilestoneListTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getVersionMilestoneListSchema>, (typeof VersionSchema)["shape"]>;
+export declare const getVersionMilestoneListTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getVersionMilestoneListSchema>, Entity.Project.Version>;
 export {};

package/build/tools/getVersionMilestoneList.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getVersionMilestoneListSchema = buildToolSchema((t) => ({
     projectId: z
@@ -17,7 +17,17 @@ export const getVersionMilestoneListTool = (backlog, { t }) => {
         name: 'get_version_milestone_list',
         description: t('TOOL_GET_VERSION_MILESTONE_LIST_DESCRIPTION', 'Returns list of versions/milestones in the Backlog space'),
         schema: z.object(getVersionMilestoneListSchema(t)),
-        outputSchema: VersionSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'description',
+            'startDate',
+            'releaseDueDate',
+            'archived',
+            'displayOrder',
+        ]),
         importantFields: [
             'id',
             'name',

package/build/tools/getWatchingListCount.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { WatchingListCountSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getWatchingListCountSchema: (t: DescriptionHelper["t"]) => {
     userId: z.ZodNumber;
 };
-export declare const getWatchingListCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWatchingListCountSchema>, (typeof WatchingListCountSchema)["shape"]>;
+export declare const getWatchingListCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWatchingListCountSchema>, Entity.WatchingList.WatchingListCount>;
 export {};

package/build/tools/getWatchingListCount.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WatchingListCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getWatchingListCountSchema = buildToolSchema((t) => ({
     userId: z
         .number()
@@ -11,7 +11,10 @@ export const getWatchingListCountTool = (backlog, { t }) => {
         name: 'get_watching_list_count',
         description: t('TOOL_GET_WATCHING_LIST_COUNT_DESCRIPTION', 'Returns count of watching items for a user'),
         schema: z.object(getWatchingListCountSchema(t)),
-        outputSchema: WatchingListCountSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'count',
+        ]),
         handler: async ({ userId }) => backlog.getWatchingListCount(userId),
     };
 };

package/build/tools/getWatchingListItems.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { WatchingListItemSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getWatchingListItemsSchema: (t: DescriptionHelper["t"]) => {
     userId: z.ZodNumber;
 };
-export declare const getWatchingListItemsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWatchingListItemsSchema>, (typeof WatchingListItemSchema)["shape"]>;
+export declare const getWatchingListItemsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWatchingListItemsSchema>, Entity.WatchingList.WatchingListItem>;
 export {};

package/build/tools/getWatchingListItems.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WatchingListItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getWatchingListItemsSchema = buildToolSchema((t) => ({
     userId: z
         .number()
@@ -11,7 +11,17 @@ export const getWatchingListItemsTool = (backlog, { t }) => {
         name: 'get_watching_list_items',
         description: t('TOOL_GET_WATCHING_LIST_ITEMS_DESCRIPTION', 'Returns list of watching items for a user'),
         schema: z.object(getWatchingListItemsSchema(t)),
-        outputSchema: WatchingListItemSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'resourceAlreadyRead',
+            'note',
+            'type',
+            'issue',
+            'lastContentUpdated',
+            'created',
+            'updated',
+        ]),
         handler: async ({ userId }) => backlog.getWatchingListItems(userId),
     };
 };

package/build/tools/getWiki.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { WikiSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getWikiSchema: (t: DescriptionHelper["t"]) => {
     wikiId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
 };
-export declare const getWikiTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWikiSchema>, (typeof WikiSchema)["shape"]>;
+export declare const getWikiTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWikiSchema>, Entity.Wiki.Wiki>;
 export {};

package/build/tools/getWiki.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WikiSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getWikiSchema = buildToolSchema((t) => ({
     wikiId: z
         .union([z.string(), z.number()])
@@ -11,7 +11,21 @@ export const getWikiTool = (backlog, { t }) => {
         name: 'get_wiki',
         description: t('TOOL_GET_WIKI_DESCRIPTION', 'Returns information about a specific wiki page'),
         schema: z.object(getWikiSchema(t)),
-        outputSchema: WikiSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'content',
+            'tags',
+            'attachments',
+            'sharedFiles',
+            'stars',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         importantFields: ['id', 'projectId', 'name', 'content'],
         handler: async ({ wikiId }) => {
             const wikiIdNumber = typeof wikiId === 'string' ? parseInt(wikiId, 10) : wikiId;

package/build/tools/getWikiPages.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { WikiListItemSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getWikiPagesSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     keyword: z.ZodOptional<z.ZodString>;
 };
-export declare const getWikiPagesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWikiPagesSchema>, (typeof WikiListItemSchema)["shape"]>;
+export declare const getWikiPagesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWikiPagesSchema>, Entity.Wiki.WikiListItem>;
 export {};

package/build/tools/getWikiPages.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WikiListItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getWikiPagesSchema = buildToolSchema((t) => ({
     projectId: z
@@ -21,7 +21,17 @@ export const getWikiPagesTool = (backlog, { t }) => {
         name: 'get_wiki_pages',
         description: t('TOOL_GET_WIKI_PAGES_DESCRIPTION', 'Returns list of Wiki pages'),
         schema: z.object(getWikiPagesSchema(t)),
-        outputSchema: WikiListItemSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'tags',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         importantFields: ['projectId', 'name', 'tags'],
         handler: async ({ projectId, projectKey, keyword }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);

package/build/tools/getWikisCount.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { WikiCountSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getWikisCountSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };
-export declare const getWikisCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWikisCountSchema>, (typeof WikiCountSchema)["shape"]>;
+export declare const getWikisCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWikisCountSchema>, Entity.Wiki.WikiCount>;
 export {};

package/build/tools/getWikisCount.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WikiCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getWikisCountSchema = buildToolSchema((t) => ({
     projectId: z
@@ -17,7 +17,8 @@ export const getWikisCountTool = (backlog, { t }) => {
         name: 'get_wikis_count',
         description: t('TOOL_GET_WIKIS_COUNT_DESCRIPTION', 'Returns count of wiki pages in a project'),
         schema: z.object(getWikisCountSchema(t)),
-        outputSchema: WikiCountSchema,
+        returnsList: false,
+        outputFields: outputFields()(['count']),
         handler: async ({ projectId, projectKey }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {