@mmtr-tech/yandex-tracker-mcp 0.1.0

package/dist/tools/issues.js

@@ -0,0 +1,437 @@
+import { z } from 'zod';
+import { registerTool } from './index.js';
+const getIssueSchema = z.object({
+    issueId: z.string().min(1).describe('Issue key or id (e.g. TEST-1)'),
+    expand: z.string().optional()
+        .describe('Extra fields: links, comments, transitions, attachments'),
+    fields: z.string().optional()
+        .describe('Comma-separated field names to return (reduces payload size)'),
+});
+const searchIssuesSchema = z
+    .object({
+    query: z.string().min(1).optional()
+        .describe('Tracker query language filter (preferred for flexible search)'),
+    filter: z.record(z.unknown()).optional()
+        .describe('Filter object by field values'),
+    keys: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).optional()
+        .describe('Issue key or list of keys'),
+    queue: z.string().min(1).optional()
+        .describe('Queue key — uses relative pagination; do not combine with query/keys/filter'),
+    order: z.string().optional()
+        .describe('Sort, e.g. "+updatedAt" or "-updatedAt" (with filter)'),
+    perPage: z.coerce.number().int().positive().max(100).optional()
+        .describe('Issues per page (default 50)'),
+    page: z.coerce.number().int().positive().optional()
+        .describe('Page number (page-based pagination for query/filter/keys)'),
+    expand: z.string().optional()
+        .describe('Extra fields: transitions, attachments, comments'),
+    fields: z.string().optional()
+        .describe('Comma-separated fields to include in each issue'),
+})
+    .superRefine((val, ctx) => {
+    const modes = [val.query, val.filter, val.keys, val.queue].filter((v) => v !== undefined);
+    if (modes.length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide exactly one of: query, filter, keys, or queue',
+        });
+    }
+    else if (modes.length > 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Use only one of: query, filter, keys, or queue (API rejects combinations)',
+        });
+    }
+});
+const getIssueCommentsSchema = z.object({
+    issueId: z.string().min(1).describe('Issue key or id'),
+    perPage: z.coerce.number().int().positive().max(100).optional()
+        .describe('Comments per page (default 50)'),
+    afterId: z.coerce.number().int().positive().optional()
+        .describe('Return comments after this comment id (pagination)'),
+    expand: z.string().optional()
+        .describe('Extra fields: attachments, html, all'),
+});
+const issueIdOnlySchema = z.object({
+    issueId: z.string().min(1).describe('Issue key or id (e.g. TEST-1)'),
+});
+const getIssueChangelogSchema = z.object({
+    issueId: z.string().min(1).describe('Issue key or id'),
+    perPage: z.coerce.number().int().positive().max(100).optional()
+        .describe('Changelog entries per page (default 50)'),
+    afterId: z.string().min(1).optional()
+        .describe('Return entries after this changelog id (pagination)'),
+    field: z.string().min(1).optional()
+        .describe('Filter by field id, e.g. status or checklistItems'),
+    type: z.string().min(1).optional()
+        .describe('Filter by change type, e.g. IssueWorkflow, IssueUpdated'),
+});
+const createIssueSchema = z.object({
+    queue: z.string().min(1).describe('Queue key or id where the issue will be created'),
+    summary: z.string().min(1).describe('Issue title'),
+    description: z.string().optional().describe('Issue description'),
+    type: z.string().optional().describe('Issue type key or id (e.g. task, bug)'),
+    priority: z.string().optional().describe('Priority key or id (e.g. normal, critical)'),
+    assignee: z.string().optional().describe('Assignee login or uid'),
+    parent: z.string().optional().describe('Parent issue key or id'),
+    tags: z.array(z.string()).optional().describe('Tags'),
+    markupType: z.string().optional().describe('Set to "md" for YFM markdown in description'),
+    fields: z.record(z.unknown()).optional()
+        .describe('Extra/custom field map merged into create body (local/global queue fields)'),
+});
+const updateIssueSchema = z
+    .object({
+    issueId: z.string().min(1).describe('Issue key or id to update'),
+    summary: z.string().min(1).optional().describe('New title'),
+    description: z.string().optional().describe('New description'),
+    type: z.string().optional().describe('Issue type key or id'),
+    priority: z.string().optional().describe('Priority key or id'),
+    assignee: z.union([z.string().min(1), z.null()]).optional()
+        .describe('Assignee login/uid, or null to clear'),
+    parent: z.union([z.string().min(1), z.null()]).optional()
+        .describe('Parent issue key/id, or null to clear'),
+    tags: z.array(z.string()).optional().describe('Replace tags'),
+    markupType: z.string().optional().describe('Set to "md" for YFM markdown'),
+    version: z.coerce.number().int().positive().optional()
+        .describe('Optimistic concurrency version from get_issue'),
+    fields: z.record(z.unknown()).optional()
+        .describe('Extra/custom fields or Tracker operators (set/add/remove) merged into PATCH body'),
+})
+    .superRefine((val, ctx) => {
+    const { issueId: _id, version: _v, ...fields } = val;
+    if (Object.values(fields).every((v) => v === undefined)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide at least one field to update',
+        });
+    }
+});
+const addIssueCommentSchema = z.object({
+    issueId: z.string().min(1).describe('Issue key or id'),
+    text: z.string().min(1).describe('Comment text'),
+    markupType: z.string().optional().describe('Set to "md" for YFM markdown'),
+    summonees: z.array(z.string().min(1)).optional()
+        .describe('Logins or uids to mention'),
+});
+const executeTransitionSchema = z.object({
+    issueId: z.string().min(1).describe('Issue key or id'),
+    transitionId: z.string().min(1)
+        .describe('Transition id from get_issue_transitions (e.g. close, start_progress)'),
+    comment: z.string().optional().describe('Optional comment for the transition'),
+    resolution: z.string().optional()
+        .describe('Resolution key when required (e.g. fixed, wontFix)'),
+    fields: z.record(z.unknown()).optional()
+        .describe('Extra field values required by the transition screen'),
+});
+export function registerIssueTools() {
+    registerTool({
+        zodSchema: getIssueSchema,
+        schema: {
+            name: 'get_issue',
+            description: 'Get a Yandex Tracker issue by key or id (GET /issues/{issueId}). Use expand/fields to control payload size.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id (e.g. TEST-1)' },
+                    expand: {
+                        type: 'string',
+                        description: 'Extra fields: links, comments, transitions, attachments',
+                    },
+                    fields: {
+                        type: 'string',
+                        description: 'Comma-separated field names to return (reduces payload size)',
+                    },
+                },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getIssue(args);
+        },
+    });
+    registerTool({
+        zodSchema: searchIssuesSchema,
+        schema: {
+            name: 'search_issues',
+            description: 'Search issues (POST /issues/_search). Provide exactly one of query, filter, keys, or queue. Prefer query (Tracker query language). Paginate with perPage/page; default 50 per page. Query examples: "Queue: TEST", "Queue: TEST Assignee: me() Sort by: Updated DESC", "Key: TEST-1", "Queue: TEST Status: open() Resolution: empty()", "Summary: \\"login\\" Queue: TEST".',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'Tracker query language. Examples: Queue: TEST; Queue: TEST Assignee: me() Sort by: Updated DESC; Key: TEST-1; Queue: TEST Status: open()',
+                    },
+                    filter: {
+                        type: 'object',
+                        description: 'Filter object by field values',
+                        additionalProperties: true,
+                    },
+                    keys: {
+                        description: 'Issue key or list of keys',
+                        oneOf: [
+                            { type: 'string' },
+                            { type: 'array', items: { type: 'string' } },
+                        ],
+                    },
+                    queue: {
+                        type: 'string',
+                        description: 'Queue key (relative pagination; exclusive with other modes)',
+                    },
+                    order: {
+                        type: 'string',
+                        description: 'Sort, e.g. "+updatedAt" or "-updatedAt"',
+                    },
+                    perPage: { type: 'number', description: 'Issues per page (default 50)' },
+                    page: { type: 'number', description: 'Page number' },
+                    expand: {
+                        type: 'string',
+                        description: 'Extra fields: transitions, attachments, comments',
+                    },
+                    fields: {
+                        type: 'string',
+                        description: 'Comma-separated fields to include',
+                    },
+                },
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().searchIssues(args);
+        },
+    });
+    registerTool({
+        zodSchema: getIssueCommentsSchema,
+        schema: {
+            name: 'get_issue_comments',
+            description: 'List comments on an issue (GET /issues/{issueId}/comments). Paginated; use afterId for next page.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id' },
+                    perPage: { type: 'number', description: 'Comments per page (default 50)' },
+                    afterId: {
+                        type: 'number',
+                        description: 'Return comments after this comment id',
+                    },
+                    expand: {
+                        type: 'string',
+                        description: 'Extra fields: attachments, html, all',
+                    },
+                },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getIssueComments(args);
+        },
+    });
+    registerTool({
+        zodSchema: issueIdOnlySchema,
+        schema: {
+            name: 'get_issue_links',
+            description: 'List issue links/relations (GET /issues/{issueId}/links).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id (e.g. TEST-1)' },
+                },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getIssueLinks(args.issueId);
+        },
+    });
+    registerTool({
+        zodSchema: issueIdOnlySchema,
+        schema: {
+            name: 'get_issue_transitions',
+            description: 'List available status transitions for an issue (GET /issues/{issueId}/transitions). Use transition id with execute_transition.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id (e.g. TEST-1)' },
+                },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getIssueTransitions(args.issueId);
+        },
+    });
+    registerTool({
+        zodSchema: getIssueChangelogSchema,
+        schema: {
+            name: 'get_issue_changelog',
+            description: 'Get issue change history (GET /issues/{issueId}/changelog). Paginate with perPage/afterId; filter by field or type (e.g. IssueWorkflow, status).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id' },
+                    perPage: { type: 'number', description: 'Entries per page (default 50)' },
+                    afterId: {
+                        type: 'string',
+                        description: 'Return entries after this changelog id',
+                    },
+                    field: {
+                        type: 'string',
+                        description: 'Filter by field id, e.g. status',
+                    },
+                    type: {
+                        type: 'string',
+                        description: 'Filter by change type, e.g. IssueWorkflow',
+                    },
+                },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getIssueChangelog(args);
+        },
+    });
+    registerTool({
+        zodSchema: issueIdOnlySchema,
+        schema: {
+            name: 'get_issue_attachments',
+            description: 'List issue attachment metadata only (via GET /issues/{issueId}?expand=attachments). Returns id, name, size, mimetype, content URL — does not download file bytes.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id (e.g. TEST-1)' },
+                },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getIssueAttachments(args.issueId);
+        },
+    });
+    registerTool({
+        zodSchema: createIssueSchema,
+        schema: {
+            name: 'create_issue',
+            description: 'CREATE a new issue (POST /issues/). Side effect: writes to Tracker. Requires OAuth tracker:write. Returns the created issue.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    queue: { type: 'string', description: 'Queue key or id' },
+                    summary: { type: 'string', description: 'Issue title' },
+                    description: { type: 'string', description: 'Issue description' },
+                    type: { type: 'string', description: 'Issue type key or id' },
+                    priority: { type: 'string', description: 'Priority key or id' },
+                    assignee: { type: 'string', description: 'Assignee login or uid' },
+                    parent: { type: 'string', description: 'Parent issue key or id' },
+                    tags: { type: 'array', items: { type: 'string' }, description: 'Tags' },
+                    markupType: {
+                        type: 'string',
+                        description: 'Set to "md" for YFM markdown in description',
+                    },
+                    fields: {
+                        type: 'object',
+                        additionalProperties: true,
+                        description: 'Extra/custom fields merged into create body',
+                    },
+                },
+                required: ['queue', 'summary'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().createIssue(args);
+        },
+    });
+    registerTool({
+        zodSchema: updateIssueSchema,
+        schema: {
+            name: 'update_issue',
+            description: 'UPDATE issue fields (PATCH /issues/{issueId}). Side effect: writes to Tracker. Does NOT change status — use execute_transition for that. Use fields for custom fields or Tracker operators (set/add/remove).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id' },
+                    summary: { type: 'string', description: 'New title' },
+                    description: { type: 'string', description: 'New description' },
+                    type: { type: 'string', description: 'Issue type key or id' },
+                    priority: { type: 'string', description: 'Priority key or id' },
+                    assignee: {
+                        description: 'Assignee login/uid, or null to clear',
+                        oneOf: [{ type: 'string' }, { type: 'null' }],
+                    },
+                    parent: {
+                        description: 'Parent issue key/id, or null to clear',
+                        oneOf: [{ type: 'string' }, { type: 'null' }],
+                    },
+                    tags: { type: 'array', items: { type: 'string' }, description: 'Replace tags' },
+                    markupType: { type: 'string', description: 'Set to "md" for YFM markdown' },
+                    version: {
+                        type: 'number',
+                        description: 'Optimistic concurrency version from get_issue',
+                    },
+                    fields: {
+                        type: 'object',
+                        additionalProperties: true,
+                        description: 'Extra/custom fields or operators (set/add/remove)',
+                    },
+                },
+                required: ['issueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().updateIssue(args);
+        },
+    });
+    registerTool({
+        zodSchema: addIssueCommentSchema,
+        schema: {
+            name: 'add_issue_comment',
+            description: 'Add a comment to an issue (POST /issues/{issueId}/comments). Side effect: writes to Tracker.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id' },
+                    text: { type: 'string', description: 'Comment text' },
+                    markupType: { type: 'string', description: 'Set to "md" for YFM markdown' },
+                    summonees: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Logins or uids to mention',
+                    },
+                },
+                required: ['issueId', 'text'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().addIssueComment(args);
+        },
+    });
+    registerTool({
+        zodSchema: executeTransitionSchema,
+        schema: {
+            name: 'execute_transition',
+            description: 'Execute a status transition (POST /issues/{issueId}/transitions/{transitionId}/_execute). Side effect: changes issue status. Call get_issue_transitions first to get transitionId.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    issueId: { type: 'string', description: 'Issue key or id' },
+                    transitionId: {
+                        type: 'string',
+                        description: 'Transition id from get_issue_transitions',
+                    },
+                    comment: { type: 'string', description: 'Optional comment' },
+                    resolution: {
+                        type: 'string',
+                        description: 'Resolution key when required (e.g. fixed)',
+                    },
+                    fields: {
+                        type: 'object',
+                        additionalProperties: true,
+                        description: 'Extra field values for the transition screen',
+                    },
+                },
+                required: ['issueId', 'transitionId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().executeTransition(args);
+        },
+    });
+}
+//# sourceMappingURL=issues.js.map

package/dist/tools/queues.d.ts

@@ -0,0 +1,2 @@
+export declare function registerQueueTools(): void;
+//# sourceMappingURL=queues.d.ts.map

package/dist/tools/queues.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { registerTool } from './index.js';
+const listQueuesSchema = z.object({
+    perPage: z.coerce.number().int().positive().max(100).optional()
+        .describe('Queues per page (default 50, max 100)'),
+    page: z.coerce.number().int().positive().optional()
+        .describe('Page number for pagination'),
+    expand: z.string().optional()
+        .describe('Extra fields: projects, components, versions, types, team, workflows'),
+});
+const getQueueSchema = z.object({
+    queueId: z.string().min(1).describe('Queue key or id (e.g. TEST)'),
+    expand: z.string().optional()
+        .describe('Extra fields: projects, components, versions, types, team, workflows'),
+});
+export function registerQueueTools() {
+    registerTool({
+        zodSchema: listQueuesSchema,
+        schema: {
+            name: 'list_queues',
+            description: 'List accessible Yandex Tracker queues (GET /queues/). Paginated; default 50 per page. Prefer small perPage and page through results.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    perPage: {
+                        type: 'number',
+                        description: 'Queues per page (default 50, max 100)',
+                    },
+                    page: {
+                        type: 'number',
+                        description: 'Page number for pagination',
+                    },
+                    expand: {
+                        type: 'string',
+                        description: 'Extra fields: projects, components, versions, types, team, workflows',
+                    },
+                },
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().listQueues(args);
+        },
+    });
+    registerTool({
+        zodSchema: getQueueSchema,
+        schema: {
+            name: 'get_queue',
+            description: 'Get a single queue by key or id (GET /queues/{queueId}).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    queueId: {
+                        type: 'string',
+                        description: 'Queue key or id (e.g. TEST)',
+                    },
+                    expand: {
+                        type: 'string',
+                        description: 'Extra fields: projects, components, versions, types, team, workflows',
+                    },
+                },
+                required: ['queueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getQueue(args);
+        },
+    });
+    registerTool({
+        zodSchema: getQueueSchema.pick({ queueId: true }),
+        schema: {
+            name: 'list_queue_versions',
+            description: 'List versions of a queue (GET /queues/{queueId}/versions).',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    queueId: { type: 'string', description: 'Queue key or id' },
+                },
+                required: ['queueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getQueueVersions(args.queueId);
+        },
+    });
+    registerTool({
+        zodSchema: getQueueSchema.pick({ queueId: true }),
+        schema: {
+            name: 'list_queue_components',
+            description: 'List components of a queue (via GET /queues/{queueId}?expand=components). Returns components array only.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    queueId: { type: 'string', description: 'Queue key or id' },
+                },
+                required: ['queueId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getQueueComponents(args.queueId);
+        },
+    });
+}
+//# sourceMappingURL=queues.js.map

package/dist/tools/users.d.ts

@@ -0,0 +1,2 @@
+export declare function registerUserTools(): void;
+//# sourceMappingURL=users.d.ts.map

package/dist/tools/users.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { registerTool } from './index.js';
+const getMyselfSchema = z.object({});
+const getUserSchema = z.object({
+    userId: z.string().min(1)
+        .describe('User login or uid. If login is digits-only, use login:<digits>'),
+    expand: z.string().optional()
+        .describe('Extra fields: groups'),
+});
+const listUsersSchema = z.object({
+    perPage: z.coerce.number().int().min(1).max(100).optional()
+        .describe('Users per page (1–100, default 50)'),
+    id: z.coerce.number().int().positive().optional()
+        .describe('Start listing after this user uid (pagination cursor)'),
+    email: z.string().email().optional()
+        .describe('Exact email filter — returns matching user(s)'),
+    expand: z.string().optional()
+        .describe('Extra fields: groups'),
+});
+export function registerUserTools() {
+    registerTool({
+        zodSchema: getMyselfSchema,
+        schema: {
+            name: 'get_myself',
+            description: 'Get the current Yandex Tracker user (GET /myself). Use to verify OAuth access and learn who the API acts as.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        execute: async (_args, getClient) => {
+            return await getClient().getMyself();
+        },
+    });
+    registerTool({
+        zodSchema: getUserSchema,
+        schema: {
+            name: 'get_user',
+            description: 'Get a Tracker user by login or uid (GET /users/{userId}). If the login is digits-only, pass login:<digits>. Optional expand=groups.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    userId: {
+                        type: 'string',
+                        description: 'User login or uid. Digits-only login: login:<digits>',
+                    },
+                    expand: {
+                        type: 'string',
+                        description: 'Extra fields: groups',
+                    },
+                },
+                required: ['userId'],
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().getUser(args);
+        },
+    });
+    registerTool({
+        zodSchema: listUsersSchema,
+        schema: {
+            name: 'list_users',
+            description: 'List organization users (GET /users). Paginate with perPage (max 100) and id cursor. Filter by exact email when known.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    perPage: {
+                        type: 'number',
+                        description: 'Users per page (1–100, default 50)',
+                    },
+                    id: {
+                        type: 'number',
+                        description: 'Start listing after this user uid',
+                    },
+                    email: {
+                        type: 'string',
+                        description: 'Exact email filter',
+                    },
+                    expand: {
+                        type: 'string',
+                        description: 'Extra fields: groups',
+                    },
+                },
+            },
+        },
+        execute: async (args, getClient) => {
+            return await getClient().listUsers(args);
+        },
+    });
+}
+//# sourceMappingURL=users.js.map

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+/** Re-export client types for convenience. */
+export type { TrackerClientConfig, ListQueuesParams, GetQueueParams, GetIssueParams, SearchIssuesParams, ListCommentsParams, CreateIssueParams, UpdateIssueParams, AddCommentParams, ExecuteTransitionParams, GetIssueChangelogParams, GetUserParams, ListUsersParams, } from '../client/tracker-client.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/utils/truncate.d.ts

@@ -0,0 +1,20 @@
+/** Default cap for large tool payloads returned to the MCP client. */
+export declare const DEFAULT_MAX_CHARS = 80000;
+export interface TruncatedText {
+    text: string;
+    truncated: boolean;
+    original_length: number;
+    max_chars: number;
+}
+export declare function truncateText(text: string, maxChars?: number): TruncatedText;
+export interface TruncationMeta {
+    truncated: boolean;
+    original_length: number;
+    max_chars: number;
+    note?: string;
+}
+/** Truncate a JSON-serializable value so stringify(result) stays under maxChars. */
+export declare function truncatePayload<T>(value: T, maxChars?: number): T & {
+    _truncation?: TruncationMeta;
+};
+//# sourceMappingURL=truncate.d.ts.map