@divyacon/piece-google-docs 0.0.0-stage → 0.1.0

package/src/lib/actions/insert-text.action.ts

@@ -0,0 +1,62 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { insertTextActionOutputSchema } from '../output-schemas';
+
+export const insertText = createAction({
+  auth: googleDocsAuth,
+  name: 'insert_text',
+  displayName: 'Insert Text',
+  description: 'Insert text into a Google Docs document at a position or at the end',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Inserts text into a Google Docs document. If "index" is omitted the text is appended to the end of the document body; if "index" is provided the text is inserted at that character index — obtain a valid index from Get Document End Index first (indices cannot be guessed, must fall inside an existing paragraph, and must be below the body end index). Not idempotent: each call inserts the text again.',
+    idempotent: false,
+  },
+  outputSchema: insertTextActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to insert text into.',
+      required: true,
+    }),
+    text: Property.LongText({
+      displayName: 'Text',
+      description: 'The text to insert.',
+      required: true,
+    }),
+    index: Property.Number({
+      displayName: 'Index',
+      description:
+        'Character index to insert at. Leave empty to append to the end of the document. Get a valid index from Get Document End Index.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { documentId, text, index } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request =
+      index === undefined || index === null
+        ? { insertText: { text, endOfSegmentLocation: {} } }
+        : { insertText: { text, location: { index } } };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return {
+        success: true,
+        documentId,
+        insertedCharacters: text.length,
+        mode: index === undefined || index === null ? 'append' : 'insert_at_index',
+      };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'insert text into'));
+    }
+  },
+});

package/src/lib/actions/read-document.action.ts

@@ -0,0 +1,40 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs } from '@googleapis/docs';
+import { readDocumentActionOutputSchema } from '../output-schemas';
+
+export const readDocument = createAction({
+  displayName: 'Read Document',
+  auth: googleDocsAuth,
+  name: 'read_document',
+  description: 'Read a document from Google Docs',
+  audience: 'human',
+  aiMetadata: {
+    description:
+      'Fetches the full content and structure of a Google Docs document by its ID. Use when an agent needs to inspect, summarize, or extract text from a known document. Requires the document ID (not a name or URL); read-only and idempotent.',
+    idempotent: true,
+  },
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to read',
+      required: true,
+    }),
+  },
+  outputSchema: readDocumentActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+    const response = await docs.documents.get({
+      documentId: context.propsValue.documentId,
+    });
+
+    if (response.status !== 200) {
+      console.error(response);
+      throw new Error('Error reading document');
+    }
+
+    return response.data;
+  },
+});

package/src/lib/actions/replace-all-text.action.ts

@@ -0,0 +1,95 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs } from '@googleapis/docs';
+import { replaceAllTextActionOutputSchema } from '../output-schemas';
+
+export const replaceAllText = createAction({
+	auth: googleDocsAuth,
+	name: 'replace_all_text',
+	displayName: 'Replace All Text in Document',
+	description:
+		'Replace every occurrence of a literal string in a Google Docs document with another string.',
+	audience: 'ai',
+	aiMetadata: {
+		// Idempotent matches the sibling create_document_based_on_template, which
+		// wraps the identical replaceAllText request and is labeled idempotent:true:
+		// re-running with the same find/replace leaves the same end state (the
+		// second run matches zero occurrences). Caveat noted below for the
+		// overlapping find/replace-literals edge case.
+		description:
+			'Find-and-replaces every occurrence of a literal string across a whole Google Docs document. Pick this for a bare ad-hoc text edit; use Edit Template File instead for placeholder-token merges or image swaps. Idempotent for normal use (a repeat run matches nothing and leaves the same end state); the exception is overlapping find/replace literals (e.g. replacing "a" with "ab"), which can re-match on a second run.',
+		idempotent: true,
+	},
+	outputSchema: replaceAllTextActionOutputSchema,
+	props: {
+		documentId: Property.ShortText({
+			displayName: 'Document ID',
+			description:
+				"The ID of the document to edit, found in its URL: 'https://docs.google.com/document/d/<documentId>/edit'.",
+			required: true,
+		}),
+		find_text: Property.ShortText({
+			displayName: 'Find Text',
+			description: 'The literal text to search for in the document.',
+			required: true,
+		}),
+		replace_text: Property.ShortText({
+			displayName: 'Replace With',
+			description: 'The text to replace every matched occurrence with.',
+			required: true,
+		}),
+		match_case: Property.Checkbox({
+			displayName: 'Match Case',
+			description: 'When enabled, the search is case-sensitive.',
+			required: false,
+			defaultValue: false,
+		}),
+	},
+	async run(context) {
+		const { documentId, find_text, replace_text, match_case } =
+			context.propsValue;
+
+		const authClient = await createGoogleClient(context.auth);
+		const docs = googleDocs({ version: 'v1', auth: authClient });
+
+		try {
+			const response = await docs.documents.batchUpdate({
+				documentId,
+				requestBody: {
+					requests: [
+						{
+							replaceAllText: {
+								containsText: {
+									text: find_text,
+									matchCase: match_case ?? false,
+								},
+								replaceText: replace_text,
+							},
+						},
+					],
+				},
+			});
+
+			const occurrencesChanged =
+				response.data.replies?.[0]?.replaceAllText?.occurrencesChanged ?? 0;
+
+			return {
+				documentId,
+				occurrencesChanged,
+			};
+		} catch (e) {
+			const error = e as { code?: number; message?: string };
+			if (error.code === 403) {
+				throw new Error(
+					'Permission denied editing the document. Ensure the connected account has edit access to this document.'
+				);
+			}
+			if (error.code === 404) {
+				throw new Error(
+					`Document not found for ID '${documentId}'. Verify the document ID.`
+				);
+			}
+			throw e;
+		}
+	},
+});

package/src/lib/actions/replace-body-with-markdown.action.ts

@@ -0,0 +1,76 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { replaceBodyWithMarkdownActionOutputSchema } from '../output-schemas';
+
+export const replaceBodyWithMarkdown = createAction({
+  auth: googleDocsAuth,
+  name: 'replace_body_with_markdown',
+  displayName: 'Replace Body with Markdown',
+  description: 'Replace the entire body of a Google Docs document with Markdown content',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Clears the entire body of an existing Google Docs document and repopulates it from Markdown text, converting headings (#, ##, ###), bullet lists (-, *, +), and paragraphs into native Google Docs formatting. Use when an agent wants to overwrite a document wholesale with freshly generated Markdown (the format LLMs produce natively) in one call. Inline styling such as bold/italic is inserted as plain text. Not supported when the body contains a table or table of contents — the action errors clearly instead of partially failing. Destructive and not idempotent: the previous body content is deleted.',
+    idempotent: false,
+  },
+  outputSchema: replaceBodyWithMarkdownActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to overwrite.',
+      required: true,
+    }),
+    markdown: Property.LongText({
+      displayName: 'Markdown Content',
+      description: 'Markdown text. Supports headings (#/##/###), bullet lists (-/*/+), and paragraphs.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { documentId, markdown } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    let bodyEnd: number;
+    let hasStructuralElement = false;
+    try {
+      const response = await docs.documents.get({ documentId });
+      const content = response.data.body?.content ?? [];
+      const lastElement = content[content.length - 1];
+      bodyEnd = lastElement?.endIndex ?? 1;
+      // A single deleteContentRange cannot remove a table or table of contents
+      // that the range crosses, so a wholesale body replace is unsupported then.
+      hasStructuralElement = content.some((element) => element.table || element.tableOfContents);
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'read'));
+    }
+
+    if (hasStructuralElement) {
+      throw new Error(
+        'Cannot replace the body wholesale because it contains a table or table of contents, which deleteContentRange cannot remove. Remove those elements first, or edit the document with the targeted table/section atomics.'
+      );
+    }
+
+    const requests: docs_v1.Schema$Request[] = [];
+    // The body always ends in an undeletable trailing newline, so the deletable
+    // range is [1, bodyEnd-1); only delete when there is real content to remove.
+    if (bodyEnd > 2) {
+      requests.push({ deleteContentRange: { range: { startIndex: 1, endIndex: bodyEnd - 1 } } });
+    }
+    requests.push(...docsCommon.markdownToBatchRequests(markdown));
+
+    try {
+      await docs.documents.batchUpdate({ documentId, requestBody: { requests } });
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'replace the body of'));
+    }
+
+    return {
+      success: true,
+      documentId,
+      url: `https://docs.google.com/document/d/${documentId}/edit`,
+    };
+  },
+});

package/src/lib/actions/replace-image.action.ts

@@ -0,0 +1,60 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { replaceImageActionOutputSchema } from '../output-schemas';
+
+export const replaceImage = createAction({
+	auth: googleDocsAuth,
+	name: 'replace_image',
+	displayName: 'Replace Image',
+	description: 'Replace an existing inline image in a Google Docs document with a new image from a URI.',
+	audience: 'ai',
+	aiMetadata: {
+		description:
+			'Swaps an existing inline image (identified by its object ID) for a new image at the given URI. Use this to update a specific image in a document without altering surrounding content. The imageObjectId must come from the document\'s inlineObjects map — obtain it by calling Read Document first. Re-running with the same URI leaves the document in the same visual state, so it is idempotent.',
+		idempotent: true,
+	},
+	outputSchema: replaceImageActionOutputSchema,
+	props: {
+		documentId: Property.ShortText({
+			displayName: 'Document ID',
+			description: 'The ID of the document containing the image to replace.',
+			required: true,
+		}),
+		imageObjectId: Property.ShortText({
+			displayName: 'Image Object ID',
+			description:
+				'The object ID of the inline image to replace. This is a hidden ID found in the document\'s inlineObjects map — obtain it by calling Read Document and inspecting the inlineObjects field.',
+			required: true,
+		}),
+		uri: Property.ShortText({
+			displayName: 'New Image URI',
+			description: 'A publicly accessible URL of the replacement image. Google must be able to fetch this URL at the time of the call.',
+			required: true,
+		}),
+	},
+	async run(context) {
+		const { documentId, imageObjectId, uri } = context.propsValue;
+		const authClient = await createGoogleClient(context.auth);
+		const docs = googleDocs({ version: 'v1', auth: authClient });
+
+		const request: docs_v1.Schema$Request = {
+			replaceImage: {
+				imageObjectId,
+				uri,
+				imageReplaceMethod: 'CENTER_CROP',
+			},
+		};
+
+		try {
+			await docs.documents.batchUpdate({
+				documentId,
+				requestBody: { requests: [request] },
+			});
+			return { success: true, documentId, imageObjectId };
+		} catch (error) {
+			throw new Error(docsCommon.formatError(error, 'replace image in'));
+		}
+	},
+});

package/src/lib/actions/replace-section-with-markdown.action.ts

@@ -0,0 +1,104 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { replaceSectionWithMarkdownActionOutputSchema } from '../output-schemas';
+
+export const replaceSectionWithMarkdown = createAction({
+  auth: googleDocsAuth,
+  name: 'replace_section_with_markdown',
+  displayName: 'Replace Section with Markdown',
+  description: 'Replace a character range of a Google Docs document with Markdown content',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Deletes the content between a start and end character index and replaces it with text rendered from Markdown (headings #/##/###, bullet lists -/*/+, paragraphs converted to native Google Docs formatting). Use when an agent wants to overwrite one section of a document — not the whole body — with freshly generated Markdown. Obtain start and end indices from Read Document first; indices cannot be guessed. If the end index reaches the document end it is clamped to exclude the undeletable terminal newline. Inline styling such as bold/italic is inserted as plain text. Destructive and not idempotent.',
+    idempotent: false,
+  },
+  outputSchema: replaceSectionWithMarkdownActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to edit.',
+      required: true,
+    }),
+    startIndex: Property.Number({
+      displayName: 'Start Index',
+      description: 'Inclusive start character index of the section to replace. Obtain from Read Document.',
+      required: true,
+    }),
+    endIndex: Property.Number({
+      displayName: 'End Index',
+      description:
+        'Exclusive end character index of the section to replace. Must be greater than Start Index and obtained from Read Document.',
+      required: true,
+    }),
+    markdown: Property.LongText({
+      displayName: 'Markdown Content',
+      description: 'Markdown text. Supports headings (#/##/###), bullet lists (-/*/+), and paragraphs.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { documentId, startIndex, markdown } = context.propsValue;
+    let { endIndex } = context.propsValue;
+    if (endIndex <= startIndex) {
+      throw new Error('End Index must be greater than Start Index.');
+    }
+
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    // The body's terminal newline cannot be deleted, so if the caller passed an
+    // end index at/after the body end (e.g. the value from Get Document End Index)
+    // clamp it to one before the end — otherwise deleteContentRange 400s.
+    let content: docs_v1.Schema$StructuralElement[];
+    try {
+      const response = await docs.documents.get({ documentId });
+      content = response.data.body?.content ?? [];
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'read'));
+    }
+    const bodyEnd = content[content.length - 1]?.endIndex ?? endIndex;
+    if (endIndex > bodyEnd - 1) {
+      endIndex = bodyEnd - 1;
+    }
+    if (endIndex <= startIndex) {
+      throw new Error('The section to replace is empty after clamping the end index to the document end.');
+    }
+    // A single deleteContentRange cannot remove a table or table of contents
+    // that the range crosses, so a section replace over one is unsupported.
+    const crossesStructuralElement = content.some(
+      (element) =>
+        (element.table || element.tableOfContents) &&
+        (element.startIndex ?? 0) < endIndex &&
+        (element.endIndex ?? 0) > startIndex
+    );
+    if (crossesStructuralElement) {
+      throw new Error(
+        'Cannot replace this section because it contains or overlaps a table or table of contents, which deleteContentRange cannot remove. Choose a range that excludes it, or edit it with the targeted table atomics.'
+      );
+    }
+
+    // Delete the section first, then insert the markdown at the now-empty
+    // startIndex; the converter builds its inserts from that base index.
+    const requests: docs_v1.Schema$Request[] = [
+      { deleteContentRange: { range: { startIndex, endIndex } } },
+      ...docsCommon.markdownToBatchRequests(markdown, startIndex),
+    ];
+
+    try {
+      await docs.documents.batchUpdate({ documentId, requestBody: { requests } });
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'replace a section of'));
+    }
+
+    return {
+      success: true,
+      documentId,
+      replacedFrom: startIndex,
+      replacedTo: endIndex,
+      url: `https://docs.google.com/document/d/${documentId}/edit`,
+    };
+  },
+});

package/src/lib/actions/search-documents.action.ts

@@ -0,0 +1,131 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { searchDocumentsActionOutputSchema } from '../output-schemas';
+
+export const searchDocuments = createAction({
+	auth: googleDocsAuth,
+	name: 'search_documents',
+	displayName: 'Search Documents',
+	description:
+		'Search Google Drive for Google Docs documents by name or full-text content.',
+	audience: 'ai',
+	aiMetadata: {
+		description:
+			"Searches Drive for Google Docs documents by name and/or full-text content, returning multiple ordered results with their IDs. Pick this over Find Document to discover documents by their content (not just an exact name) or to get more than one match; Find Document returns only the first name match and can also create-if-missing. Read-only and idempotent. At least one of name/content text is required.",
+		idempotent: true,
+	},
+	outputSchema: searchDocumentsActionOutputSchema,
+	props: {
+		name_contains: Property.ShortText({
+			displayName: 'Name Contains',
+			description:
+				'Return documents whose name contains this text. Provide this and/or Content Contains.',
+			required: false,
+		}),
+		full_text_contains: Property.ShortText({
+			displayName: 'Content Contains',
+			description:
+				'Return documents whose full text content contains this text. Provide this and/or Name Contains.',
+			required: false,
+		}),
+		max_results: Property.Number({
+			displayName: 'Max Results',
+			description: 'Maximum number of documents to return (1-100).',
+			required: false,
+			defaultValue: 10,
+		}),
+		order_by: Property.StaticDropdown({
+			displayName: 'Order By',
+			description: 'How to sort the results.',
+			required: false,
+			defaultValue: 'modifiedTime desc',
+			options: {
+				options: [
+					{ label: 'Last modified (newest first)', value: 'modifiedTime desc' },
+					{ label: 'Last modified (oldest first)', value: 'modifiedTime' },
+					{ label: 'Created (newest first)', value: 'createdTime desc' },
+					{ label: 'Created (oldest first)', value: 'createdTime' },
+					{ label: 'Name (A-Z)', value: 'name' },
+					{ label: 'Name (Z-A)', value: 'name desc' },
+				],
+			},
+		}),
+		page_token: Property.ShortText({
+			displayName: 'Page Token',
+			description:
+				'Token for the next page of results, taken from the nextPageToken of a previous call. Leave empty for the first page.',
+			required: false,
+		}),
+	},
+	async run(context) {
+		const { name_contains, full_text_contains, max_results, order_by, page_token } =
+			context.propsValue;
+
+		if (!name_contains && !full_text_contains) {
+			throw new Error(
+				'Provide at least one of "Name Contains" or "Content Contains" to search.'
+			);
+		}
+
+		const pageSize = Math.min(Math.max(max_results ?? 10, 1), 100);
+
+		const matchClauses: string[] = [];
+		if (name_contains) {
+			matchClauses.push(
+				`name contains '${name_contains.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+			);
+		}
+		if (full_text_contains) {
+			matchClauses.push(
+				`fullText contains '${full_text_contains.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+			);
+		}
+
+		const query = [
+			`mimeType='application/vnd.google-apps.document'`,
+			`(${matchClauses.join(' or ')})`,
+			'trashed=false',
+		].join(' and ');
+
+		const authClient = await createGoogleClient(context.auth);
+		const drive = googleDrive({ version: 'v3', auth: authClient });
+
+		try {
+			const response = await drive.files.list({
+				q: query,
+				orderBy: order_by ?? 'modifiedTime desc',
+				pageSize,
+				pageToken: page_token || undefined,
+				supportsAllDrives: true,
+				includeItemsFromAllDrives: true,
+				corpora: 'allDrives',
+				fields:
+					'nextPageToken, files(id, name, mimeType, createdTime, modifiedTime, webViewLink, owners(emailAddress))',
+			});
+
+			const documents = (response.data.files ?? []).map((file) => ({
+				id: file.id ?? '',
+				name: file.name ?? '',
+				createdTime: file.createdTime ?? '',
+				modifiedTime: file.modifiedTime ?? '',
+				webViewLink: file.webViewLink ?? '',
+				ownerEmail: file.owners?.[0]?.emailAddress ?? '',
+			}));
+
+			return {
+				documents,
+				count: documents.length,
+				nextPageToken: response.data.nextPageToken ?? null,
+			};
+		} catch (e) {
+			const error = e as { code?: number; message?: string };
+			if (error.code === 403) {
+				throw new Error(
+					'Permission denied searching Drive. Ensure the connected account has Drive access.'
+				);
+			}
+			throw e;
+		}
+	},
+});

package/src/lib/actions/unmerge-table-cells.action.ts

@@ -0,0 +1,88 @@
+import { googleDocsAuth, createGoogleClient } from '../auth';
+import { docsCommon } from '../common';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { docs as googleDocs, docs_v1 } from '@googleapis/docs';
+import { unmergeTableCellsActionOutputSchema } from '../output-schemas';
+
+export const unmergeTableCells = createAction({
+  auth: googleDocsAuth,
+  name: 'unmerge_table_cells',
+  displayName: 'Unmerge Table Cells',
+  description: 'Unmerge previously merged table cells in a Google Docs document',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Unmerges a range of previously merged table cells in a Google Docs document. The range is specified by the anchor cell (rowIndex, columnIndex) and the span (rowSpan, columnSpan) to unmerge. Requires the table start index from Read Document — cannot be guessed. Idempotent: unmerging already-unmerged cells is a no-op.',
+    idempotent: true,
+  },
+  outputSchema: unmergeTableCellsActionOutputSchema,
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document containing the table.',
+      required: true,
+    }),
+    tableStartIndex: Property.Number({
+      displayName: 'Table Start Index',
+      description: 'Obtain the table start index from Read Document — cannot be guessed.',
+      required: true,
+    }),
+    rowIndex: Property.Number({
+      displayName: 'Row Index',
+      description: 'Zero-based row index of the top-left anchor cell of the merged region.',
+      required: true,
+    }),
+    columnIndex: Property.Number({
+      displayName: 'Column Index',
+      description: 'Zero-based column index of the top-left anchor cell of the merged region.',
+      required: true,
+    }),
+    rowSpan: Property.Number({
+      displayName: 'Row Span',
+      description: 'Number of rows covered by the merged region to unmerge.',
+      required: true,
+    }),
+    columnSpan: Property.Number({
+      displayName: 'Column Span',
+      description: 'Number of columns covered by the merged region to unmerge.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { documentId, tableStartIndex, rowIndex, columnIndex, rowSpan, columnSpan } = context.propsValue;
+    const authClient = await createGoogleClient(context.auth);
+    const docs = googleDocs({ version: 'v1', auth: authClient });
+
+    const request: docs_v1.Schema$Request = {
+      unmergeTableCells: {
+        tableRange: {
+          tableCellLocation: {
+            tableStartLocation: { index: tableStartIndex },
+            rowIndex,
+            columnIndex,
+          },
+          rowSpan,
+          columnSpan,
+        },
+      },
+    };
+
+    try {
+      await docs.documents.batchUpdate({
+        documentId,
+        requestBody: { requests: [request] },
+      });
+      return {
+        success: true,
+        documentId,
+        tableStartIndex,
+        rowIndex,
+        columnIndex,
+        rowSpan,
+        columnSpan,
+      };
+    } catch (error) {
+      throw new Error(docsCommon.formatError(error, 'unmerge table cells in'));
+    }
+  },
+});