google-tools-mcp 1.2.11 → 2.0.0

package/dist/tools/slides/duplicateSlide.js

@@ -1,37 +1,37 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'duplicateSlide',
-        description: 'Duplicate a slide in a Google Slides presentation.',
-        parameters: z.object({
-            presentationId: z.string().describe('Presentation ID'),
-            slideObjectId: z.string().describe('Object ID of the slide to duplicate'),
-        }),
-        execute: async (args, { log }) => {
-            const slidesApi = await getSlidesClient();
-
-            try {
-                const response = await slidesApi.presentations.batchUpdate({
-                    presentationId: args.presentationId,
-                    requestBody: {
-                        requests: [{ duplicateObject: { objectId: args.slideObjectId } }],
-                    },
-                });
-
-                const newId = response.data.replies?.[0]?.duplicateObject?.objectId;
-                return JSON.stringify({
-                    success: true,
-                    originalId: args.slideObjectId,
-                    duplicateId: newId || null,
-                    message: `Duplicated slide ${args.slideObjectId}${newId ? ` -> ${newId}` : ''}`,
-                });
-            } catch (error) {
-                log.error(`Error duplicating slide: ${error.message || error}`);
-                throw new UserError(`Failed to duplicate slide: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'duplicateSlide',
+        description: 'Duplicate a slide in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideObjectId: z.string().describe('Object ID of the slide to duplicate'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const response = await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [{ duplicateObject: { objectId: args.slideObjectId } }],
+                    },
+                });
+
+                const newId = response.data.replies?.[0]?.duplicateObject?.objectId;
+                return JSON.stringify({
+                    success: true,
+                    originalId: args.slideObjectId,
+                    duplicateId: newId || null,
+                    message: `Duplicated slide ${args.slideObjectId}${newId ? ` -> ${newId}` : ''}`,
+                });
+            } catch (error) {
+                log.error(`Error duplicating slide: ${error.message || error}`);
+                throw new UserError(`Failed to duplicate slide: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/exportThumbnail.js

@@ -1,42 +1,42 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'exportSlideThumbnail',
-        description: 'Export a slide as a thumbnail image URL (PNG or JPEG) from a Google Slides presentation.',
-        parameters: z.object({
-            presentationId: z.string().describe('Presentation ID'),
-            slideObjectId: z.string().describe('Slide object ID'),
-            mimeType: z.enum(['PNG', 'JPEG']).optional().default('PNG').describe('Image format'),
-            size: z.enum(['SMALL', 'MEDIUM', 'LARGE']).optional().default('LARGE').describe('Thumbnail size'),
-        }),
-        execute: async (args, { log }) => {
-            const slidesApi = await getSlidesClient();
-
-            try {
-                const response = await slidesApi.presentations.pages.getThumbnail({
-                    presentationId: args.presentationId,
-                    pageObjectId: args.slideObjectId,
-                    'thumbnailProperties.mimeType': args.mimeType,
-                    'thumbnailProperties.thumbnailSize': args.size,
-                });
-
-                const url = response.data?.contentUrl;
-                if (!url) throw new UserError('No thumbnail URL returned by Google Slides API.');
-
-                return JSON.stringify({
-                    slideObjectId: args.slideObjectId,
-                    mimeType: args.mimeType,
-                    size: args.size,
-                    thumbnailUrl: url,
-                });
-            } catch (error) {
-                if (error instanceof UserError) throw error;
-                log.error(`Error exporting thumbnail: ${error.message || error}`);
-                throw new UserError(`Failed to export thumbnail: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'exportSlideThumbnail',
+        description: 'Export a slide as a thumbnail image URL (PNG or JPEG) from a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideObjectId: z.string().describe('Slide object ID'),
+            mimeType: z.enum(['PNG', 'JPEG']).optional().default('PNG').describe('Image format'),
+            size: z.enum(['SMALL', 'MEDIUM', 'LARGE']).optional().default('LARGE').describe('Thumbnail size'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const response = await slidesApi.presentations.pages.getThumbnail({
+                    presentationId: args.presentationId,
+                    pageObjectId: args.slideObjectId,
+                    'thumbnailProperties.mimeType': args.mimeType,
+                    'thumbnailProperties.thumbnailSize': args.size,
+                });
+
+                const url = response.data?.contentUrl;
+                if (!url) throw new UserError('No thumbnail URL returned by Google Slides API.');
+
+                return JSON.stringify({
+                    slideObjectId: args.slideObjectId,
+                    mimeType: args.mimeType,
+                    size: args.size,
+                    thumbnailUrl: url,
+                });
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error exporting thumbnail: ${error.message || error}`);
+                throw new UserError(`Failed to export thumbnail: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/formatParagraph.js

@@ -1,72 +1,72 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'formatSlidesParagraph',
-        description:
-            'Apply paragraph formatting (alignment, line spacing, bullets) to a text element in Google Slides.',
-        parameters: z.object({
-            presentationId: z.string().describe('Presentation ID'),
-            objectId: z.string().describe('Object ID of the text element'),
-            alignment: z.enum(['START', 'CENTER', 'END', 'JUSTIFIED']).optional().describe('Text alignment'),
-            lineSpacing: z.number().optional().describe('Line spacing multiplier (e.g. 1.5)'),
-            bulletStyle: z
-                .enum(['NONE', 'DISC', 'ARROW', 'SQUARE', 'DIAMOND', 'STAR', 'NUMBERED'])
-                .optional()
-                .describe('Bullet style'),
-        }),
-        execute: async (args, { log }) => {
-            const slidesApi = await getSlidesClient();
-            const requests = [];
-
-            if (args.alignment) {
-                requests.push({
-                    updateParagraphStyle: {
-                        objectId: args.objectId,
-                        style: { alignment: args.alignment },
-                        fields: 'alignment',
-                    },
-                });
-            }
-
-            if (args.lineSpacing !== undefined) {
-                requests.push({
-                    updateParagraphStyle: {
-                        objectId: args.objectId,
-                        style: { lineSpacing: args.lineSpacing },
-                        fields: 'lineSpacing',
-                    },
-                });
-            }
-
-            if (args.bulletStyle) {
-                if (args.bulletStyle === 'NONE') {
-                    requests.push({ deleteParagraphBullets: { objectId: args.objectId } });
-                } else if (args.bulletStyle === 'NUMBERED') {
-                    requests.push({
-                        createParagraphBullets: { objectId: args.objectId, bulletPreset: 'NUMBERED_DIGIT_ALPHA_ROMAN' },
-                    });
-                } else {
-                    requests.push({
-                        createParagraphBullets: { objectId: args.objectId, bulletPreset: `BULLET_${args.bulletStyle}_CIRCLE_SQUARE` },
-                    });
-                }
-            }
-
-            if (requests.length === 0) throw new UserError('No formatting options specified');
-
-            try {
-                await slidesApi.presentations.batchUpdate({
-                    presentationId: args.presentationId,
-                    requestBody: { requests },
-                });
-                return JSON.stringify({ success: true, message: `Applied paragraph formatting to ${args.objectId}` });
-            } catch (error) {
-                log.error(`Error formatting paragraph: ${error.message || error}`);
-                throw new UserError(`Failed to format paragraph: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'formatSlidesParagraph',
+        description:
+            'Apply paragraph formatting (alignment, line spacing, bullets) to a text element in Google Slides.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            objectId: z.string().describe('Object ID of the text element'),
+            alignment: z.enum(['START', 'CENTER', 'END', 'JUSTIFIED']).optional().describe('Text alignment'),
+            lineSpacing: z.number().optional().describe('Line spacing multiplier (e.g. 1.5)'),
+            bulletStyle: z
+                .enum(['NONE', 'DISC', 'ARROW', 'SQUARE', 'DIAMOND', 'STAR', 'NUMBERED'])
+                .optional()
+                .describe('Bullet style'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            const requests = [];
+
+            if (args.alignment) {
+                requests.push({
+                    updateParagraphStyle: {
+                        objectId: args.objectId,
+                        style: { alignment: args.alignment },
+                        fields: 'alignment',
+                    },
+                });
+            }
+
+            if (args.lineSpacing !== undefined) {
+                requests.push({
+                    updateParagraphStyle: {
+                        objectId: args.objectId,
+                        style: { lineSpacing: args.lineSpacing },
+                        fields: 'lineSpacing',
+                    },
+                });
+            }
+
+            if (args.bulletStyle) {
+                if (args.bulletStyle === 'NONE') {
+                    requests.push({ deleteParagraphBullets: { objectId: args.objectId } });
+                } else if (args.bulletStyle === 'NUMBERED') {
+                    requests.push({
+                        createParagraphBullets: { objectId: args.objectId, bulletPreset: 'NUMBERED_DIGIT_ALPHA_ROMAN' },
+                    });
+                } else {
+                    requests.push({
+                        createParagraphBullets: { objectId: args.objectId, bulletPreset: `BULLET_${args.bulletStyle}_CIRCLE_SQUARE` },
+                    });
+                }
+            }
+
+            if (requests.length === 0) throw new UserError('No formatting options specified');
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+                return JSON.stringify({ success: true, message: `Applied paragraph formatting to ${args.objectId}` });
+            } catch (error) {
+                log.error(`Error formatting paragraph: ${error.message || error}`);
+                throw new UserError(`Failed to format paragraph: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/formatText.js

@@ -1,84 +1,84 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'formatSlidesText',
-        description:
-            'Apply text formatting (bold, italic, underline, font size, color, etc.) to a text element in Google Slides. Use getPresentation to find element objectIds first.',
-        parameters: z.object({
-            presentationId: z.string().describe('Presentation ID'),
-            objectId: z.string().describe('Object ID of the text element'),
-            startIndex: z.number().min(0).optional().describe('Start character index (0-based). Omit with endIndex to format all text.'),
-            endIndex: z.number().min(0).optional().describe('End character index (0-based)'),
-            bold: z.boolean().optional().describe('Make text bold'),
-            italic: z.boolean().optional().describe('Make text italic'),
-            underline: z.boolean().optional().describe('Underline text'),
-            strikethrough: z.boolean().optional().describe('Strikethrough text'),
-            fontSize: z.number().optional().describe('Font size in points'),
-            fontFamily: z.string().optional().describe('Font family name (e.g. "Arial", "Roboto")'),
-            foregroundColor: z
-                .object({
-                    red: z.number().min(0).max(1).optional(),
-                    green: z.number().min(0).max(1).optional(),
-                    blue: z.number().min(0).max(1).optional(),
-                })
-                .optional()
-                .describe('Text color as RGB values (0-1)'),
-        }),
-        execute: async (args, { log }) => {
-            const slidesApi = await getSlidesClient();
-
-            const textStyle = {};
-            const fields = [];
-
-            if (args.bold !== undefined) { textStyle.bold = args.bold; fields.push('bold'); }
-            if (args.italic !== undefined) { textStyle.italic = args.italic; fields.push('italic'); }
-            if (args.underline !== undefined) { textStyle.underline = args.underline; fields.push('underline'); }
-            if (args.strikethrough !== undefined) { textStyle.strikethrough = args.strikethrough; fields.push('strikethrough'); }
-            if (args.fontSize !== undefined) {
-                textStyle.fontSize = { magnitude: args.fontSize, unit: 'PT' };
-                fields.push('fontSize');
-            }
-            if (args.fontFamily !== undefined) { textStyle.fontFamily = args.fontFamily; fields.push('fontFamily'); }
-            if (args.foregroundColor) {
-                textStyle.foregroundColor = {
-                    opaqueColor: {
-                        rgbColor: {
-                            red: args.foregroundColor.red || 0,
-                            green: args.foregroundColor.green || 0,
-                            blue: args.foregroundColor.blue || 0,
-                        },
-                    },
-                };
-                fields.push('foregroundColor');
-            }
-
-            if (fields.length === 0) throw new UserError('No formatting options specified');
-
-            const request = {
-                updateTextStyle: {
-                    objectId: args.objectId,
-                    style: textStyle,
-                    fields: fields.join(','),
-                    textRange:
-                        args.startIndex !== undefined && args.endIndex !== undefined
-                            ? { type: 'FIXED_RANGE', startIndex: args.startIndex, endIndex: args.endIndex }
-                            : { type: 'ALL' },
-                },
-            };
-
-            try {
-                await slidesApi.presentations.batchUpdate({
-                    presentationId: args.presentationId,
-                    requestBody: { requests: [request] },
-                });
-                return JSON.stringify({ success: true, message: `Applied text formatting to ${args.objectId}` });
-            } catch (error) {
-                log.error(`Error formatting text: ${error.message || error}`);
-                throw new UserError(`Failed to format text: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'formatSlidesText',
+        description:
+            'Apply text formatting (bold, italic, underline, font size, color, etc.) to a text element in Google Slides. Use getPresentation to find element objectIds first.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            objectId: z.string().describe('Object ID of the text element'),
+            startIndex: z.number().min(0).optional().describe('Start character index (0-based). Omit with endIndex to format all text.'),
+            endIndex: z.number().min(0).optional().describe('End character index (0-based)'),
+            bold: z.boolean().optional().describe('Make text bold'),
+            italic: z.boolean().optional().describe('Make text italic'),
+            underline: z.boolean().optional().describe('Underline text'),
+            strikethrough: z.boolean().optional().describe('Strikethrough text'),
+            fontSize: z.number().optional().describe('Font size in points'),
+            fontFamily: z.string().optional().describe('Font family name (e.g. "Arial", "Roboto")'),
+            foregroundColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                })
+                .optional()
+                .describe('Text color as RGB values (0-1)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            const textStyle = {};
+            const fields = [];
+
+            if (args.bold !== undefined) { textStyle.bold = args.bold; fields.push('bold'); }
+            if (args.italic !== undefined) { textStyle.italic = args.italic; fields.push('italic'); }
+            if (args.underline !== undefined) { textStyle.underline = args.underline; fields.push('underline'); }
+            if (args.strikethrough !== undefined) { textStyle.strikethrough = args.strikethrough; fields.push('strikethrough'); }
+            if (args.fontSize !== undefined) {
+                textStyle.fontSize = { magnitude: args.fontSize, unit: 'PT' };
+                fields.push('fontSize');
+            }
+            if (args.fontFamily !== undefined) { textStyle.fontFamily = args.fontFamily; fields.push('fontFamily'); }
+            if (args.foregroundColor) {
+                textStyle.foregroundColor = {
+                    opaqueColor: {
+                        rgbColor: {
+                            red: args.foregroundColor.red || 0,
+                            green: args.foregroundColor.green || 0,
+                            blue: args.foregroundColor.blue || 0,
+                        },
+                    },
+                };
+                fields.push('foregroundColor');
+            }
+
+            if (fields.length === 0) throw new UserError('No formatting options specified');
+
+            const request = {
+                updateTextStyle: {
+                    objectId: args.objectId,
+                    style: textStyle,
+                    fields: fields.join(','),
+                    textRange:
+                        args.startIndex !== undefined && args.endIndex !== undefined
+                            ? { type: 'FIXED_RANGE', startIndex: args.startIndex, endIndex: args.endIndex }
+                            : { type: 'ALL' },
+                },
+            };
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests: [request] },
+                });
+                return JSON.stringify({ success: true, message: `Applied text formatting to ${args.objectId}` });
+            } catch (error) {
+                log.error(`Error formatting text: ${error.message || error}`);
+                throw new UserError(`Failed to format text: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/getPresentation.js

@@ -1,87 +1,87 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'getPresentation',
-        description:
-            'Get the content of a Google Slides presentation with element IDs for formatting. Optionally retrieve a single slide by index.',
-        parameters: z.object({
-            presentationId: z.string().describe('Presentation ID'),
-            slideIndex: z.number().min(0).optional().describe('Specific slide index (0-based). Omit to get all slides.'),
-        }),
-        execute: async (args, { log }) => {
-            const slidesApi = await getSlidesClient();
-            log.info(`Reading presentation: ${args.presentationId}`);
-
-            try {
-                const presentation = await slidesApi.presentations.get({
-                    presentationId: args.presentationId,
-                });
-
-                if (!presentation.data.slides) {
-                    throw new UserError('No slides found in presentation');
-                }
-
-                const allSlides = presentation.data.slides;
-                const slides =
-                    args.slideIndex !== undefined ? [allSlides[args.slideIndex]] : allSlides;
-
-                const result = {
-                    title: presentation.data.title,
-                    presentationId: args.presentationId,
-                    totalSlides: allSlides.length,
-                    slides: slides.map((slide, idx) => {
-                        if (!slide?.objectId) return null;
-                        const slideInfo = {
-                            index: args.slideIndex ?? idx,
-                            objectId: slide.objectId,
-                            elements: [],
-                        };
-
-                        for (const el of slide.pageElements || []) {
-                            if (!el.objectId) continue;
-                            if (el.shape?.text) {
-                                let text = '';
-                                for (const te of el.shape.text.textElements || []) {
-                                    if (te.textRun?.content) text += te.textRun.content;
-                                }
-                                slideInfo.elements.push({
-                                    type: 'text',
-                                    objectId: el.objectId,
-                                    placeholderType: el.shape.placeholder?.type || null,
-                                    text: text.trim(),
-                                });
-                            } else if (el.shape) {
-                                slideInfo.elements.push({
-                                    type: 'shape',
-                                    objectId: el.objectId,
-                                    shapeType: el.shape.shapeType || 'Unknown',
-                                });
-                            } else if (el.image) {
-                                slideInfo.elements.push({ type: 'image', objectId: el.objectId });
-                            } else if (el.video) {
-                                slideInfo.elements.push({ type: 'video', objectId: el.objectId });
-                            } else if (el.table) {
-                                slideInfo.elements.push({
-                                    type: 'table',
-                                    objectId: el.objectId,
-                                    rows: el.table.rows,
-                                    columns: el.table.columns,
-                                });
-                            }
-                        }
-                        return slideInfo;
-                    }).filter(Boolean),
-                };
-
-                return JSON.stringify(result, null, 2);
-            } catch (error) {
-                if (error instanceof UserError) throw error;
-                log.error(`Error reading presentation: ${error.message || error}`);
-                throw new UserError(`Failed to read presentation: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'getPresentation',
+        description:
+            'Get the content of a Google Slides presentation with element IDs for formatting. Optionally retrieve a single slide by index.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideIndex: z.number().min(0).optional().describe('Specific slide index (0-based). Omit to get all slides.'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            log.info(`Reading presentation: ${args.presentationId}`);
+
+            try {
+                const presentation = await slidesApi.presentations.get({
+                    presentationId: args.presentationId,
+                });
+
+                if (!presentation.data.slides) {
+                    throw new UserError('No slides found in presentation');
+                }
+
+                const allSlides = presentation.data.slides;
+                const slides =
+                    args.slideIndex !== undefined ? [allSlides[args.slideIndex]] : allSlides;
+
+                const result = {
+                    title: presentation.data.title,
+                    presentationId: args.presentationId,
+                    totalSlides: allSlides.length,
+                    slides: slides.map((slide, idx) => {
+                        if (!slide?.objectId) return null;
+                        const slideInfo = {
+                            index: args.slideIndex ?? idx,
+                            objectId: slide.objectId,
+                            elements: [],
+                        };
+
+                        for (const el of slide.pageElements || []) {
+                            if (!el.objectId) continue;
+                            if (el.shape?.text) {
+                                let text = '';
+                                for (const te of el.shape.text.textElements || []) {
+                                    if (te.textRun?.content) text += te.textRun.content;
+                                }
+                                slideInfo.elements.push({
+                                    type: 'text',
+                                    objectId: el.objectId,
+                                    placeholderType: el.shape.placeholder?.type || null,
+                                    text: text.trim(),
+                                });
+                            } else if (el.shape) {
+                                slideInfo.elements.push({
+                                    type: 'shape',
+                                    objectId: el.objectId,
+                                    shapeType: el.shape.shapeType || 'Unknown',
+                                });
+                            } else if (el.image) {
+                                slideInfo.elements.push({ type: 'image', objectId: el.objectId });
+                            } else if (el.video) {
+                                slideInfo.elements.push({ type: 'video', objectId: el.objectId });
+                            } else if (el.table) {
+                                slideInfo.elements.push({
+                                    type: 'table',
+                                    objectId: el.objectId,
+                                    rows: el.table.rows,
+                                    columns: el.table.columns,
+                                });
+                            }
+                        }
+                        return slideInfo;
+                    }).filter(Boolean),
+                };
+
+                return JSON.stringify(result, null, 2);
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error reading presentation: ${error.message || error}`);
+                throw new UserError(`Failed to read presentation: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}