@mcp-z/mcp-sheets 1.0.0

package/dist/cjs/mcp/tools/csv-get-columns.js

@@ -0,0 +1,386 @@
+/** Get column names from CSV file (peek at first row only) */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createTool;
+    }
+});
+var _oauthgoogle = require("@mcp-z/oauth-google");
+var _types = require("@modelcontextprotocol/sdk/types.js");
+var _csvparse = require("csv-parse");
+var _zod = require("zod");
+var _csvstreaming = require("../../spreadsheet/csv-streaming.js");
+function _async_iterator(iterable) {
+    var method, async, sync, retry = 2;
+    for("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;){
+        if (async && null != (method = iterable[async])) return method.call(iterable);
+        if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+        async = "@@asyncIterator", sync = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator(s) {
+    function AsyncFromSyncIteratorContinuation(r) {
+        if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+        var done = r.done;
+        return Promise.resolve(r.value).then(function(value) {
+            return {
+                value: value,
+                done: done
+            };
+        });
+    }
+    return AsyncFromSyncIterator = function(s) {
+        this.s = s, this.n = s.next;
+    }, AsyncFromSyncIterator.prototype = {
+        s: null,
+        n: null,
+        next: function() {
+            return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+        },
+        return: function(value) {
+            var ret = this.s.return;
+            return void 0 === ret ? Promise.resolve({
+                value: value,
+                done: !0
+            }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+        },
+        throw: function(value) {
+            var thr = this.s.return;
+            return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+        }
+    }, new AsyncFromSyncIterator(s);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var AuthRequiredBranchSchema = _oauthgoogle.schemas.AuthRequiredBranchSchema;
+var inputSchema = _zod.z.object({
+    sourceUri: _zod.z.string().trim().min(1).describe('CSV file URI (file://, http://, https://)')
+});
+// Success branch schema - uses columns: for consistency with standard vocabulary
+var successBranchSchema = _zod.z.object({
+    type: _zod.z.literal('success'),
+    columns: _zod.z.array(_zod.z.string()).describe('First row values (column names) or empty if no rows'),
+    isEmpty: _zod.z.boolean().describe('True if CSV has zero rows')
+});
+var outputSchema = _zod.z.discriminatedUnion('type', [
+    successBranchSchema,
+    AuthRequiredBranchSchema
+]);
+var config = {
+    description: 'Get first row from CSV file (streaming, no memory overhead). Returns columns array and isEmpty flag.',
+    inputSchema: inputSchema,
+    outputSchema: _zod.z.object({
+        result: outputSchema
+    })
+};
+function handler(_0, _1) {
+    return _async_to_generator(function(param, extra) {
+        var sourceUri, _logger_debug, logger, _logger_info, readStream, parser, firstRow, rowCount, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, row, err, columns, isEmpty, result, error, _logger_error, message;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    sourceUri = param.sourceUri;
+                    logger = extra.logger;
+                    (_logger_debug = logger.debug) === null || _logger_debug === void 0 ? void 0 : _logger_debug.call(logger, 'sheets.csv.get-columns called', {
+                        sourceUri: sourceUri
+                    });
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        15,
+                        ,
+                        16
+                    ]);
+                    return [
+                        4,
+                        (0, _csvstreaming.getCsvReadStream)(sourceUri)
+                    ];
+                case 2:
+                    readStream = _state.sent();
+                    // Create CSV parser without treating first row as column names
+                    // We just want to read the raw first row
+                    parser = readStream.pipe((0, _csvparse.parse)({
+                        columns: false,
+                        skip_empty_lines: true,
+                        trim: true,
+                        cast: true,
+                        relax_column_count: true
+                    }));
+                    // Read only the first row
+                    firstRow = [];
+                    rowCount = 0;
+                    _iteratorAbruptCompletion = false, _didIteratorError = false;
+                    _state.label = 3;
+                case 3:
+                    _state.trys.push([
+                        3,
+                        8,
+                        9,
+                        14
+                    ]);
+                    _iterator = _async_iterator(parser);
+                    _state.label = 4;
+                case 4:
+                    return [
+                        4,
+                        _iterator.next()
+                    ];
+                case 5:
+                    if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                        3,
+                        7
+                    ];
+                    _value = _step.value;
+                    row = _value;
+                    firstRow = row;
+                    rowCount++;
+                    return [
+                        3,
+                        7
+                    ]; // Only read first row
+                case 6:
+                    _iteratorAbruptCompletion = false;
+                    return [
+                        3,
+                        4
+                    ];
+                case 7:
+                    return [
+                        3,
+                        14
+                    ];
+                case 8:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        14
+                    ];
+                case 9:
+                    _state.trys.push([
+                        9,
+                        ,
+                        12,
+                        13
+                    ]);
+                    if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                        3,
+                        11
+                    ];
+                    return [
+                        4,
+                        _iterator.return()
+                    ];
+                case 10:
+                    _state.sent();
+                    _state.label = 11;
+                case 11:
+                    return [
+                        3,
+                        13
+                    ];
+                case 12:
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                    return [
+                        7
+                    ];
+                case 13:
+                    return [
+                        7
+                    ];
+                case 14:
+                    // Convert first row to strings (column names)
+                    columns = firstRow.map(function(value) {
+                        return String(value !== null && value !== void 0 ? value : '');
+                    });
+                    isEmpty = rowCount === 0;
+                    result = {
+                        type: 'success',
+                        columns: columns,
+                        isEmpty: isEmpty
+                    };
+                    (_logger_info = logger.info) === null || _logger_info === void 0 ? void 0 : _logger_info.call(logger, 'sheets.csv.get-columns completed', {
+                        sourceUri: sourceUri,
+                        columnCount: columns.length,
+                        isEmpty: isEmpty
+                    });
+                    return [
+                        2,
+                        {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result)
+                                }
+                            ],
+                            structuredContent: {
+                                result: result
+                            }
+                        }
+                    ];
+                case 15:
+                    error = _state.sent();
+                    message = _instanceof(error, Error) ? error.message : String(error);
+                    (_logger_error = logger.error) === null || _logger_error === void 0 ? void 0 : _logger_error.call(logger, 'sheets.csv.get-columns error', {
+                        error: message
+                    });
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error getting CSV columns: ".concat(message), {
+                        stack: _instanceof(error, Error) ? error.stack : undefined
+                    });
+                case 16:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function createTool() {
+    return {
+        name: 'csv-get-columns',
+        config: config,
+        handler: handler
+    };
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/mcp/tools/csv-get-columns.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-sheets/src/mcp/tools/csv-get-columns.ts"],"sourcesContent":["/** Get column names from CSV file (peek at first row only) */\n\nimport type { EnrichedExtra } from '@mcp-z/oauth-google';\nimport { schemas } from '@mcp-z/oauth-google';\n\nconst { AuthRequiredBranchSchema } = schemas;\n\nimport type { ToolModule } from '@mcp-z/server';\nimport type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';\nimport { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';\nimport { parse } from 'csv-parse';\nimport { z } from 'zod';\nimport { getCsvReadStream } from '../../spreadsheet/csv-streaming.js';\n\nconst inputSchema = z.object({\n  sourceUri: z.string().trim().min(1).describe('CSV file URI (file://, http://, https://)'),\n});\n\n// Success branch schema - uses columns: for consistency with standard vocabulary\nconst successBranchSchema = z.object({\n  type: z.literal('success'),\n  columns: z.array(z.string()).describe('First row values (column names) or empty if no rows'),\n  isEmpty: z.boolean().describe('True if CSV has zero rows'),\n});\n\nconst outputSchema = z.discriminatedUnion('type', [successBranchSchema, AuthRequiredBranchSchema]);\n\nconst config = {\n  description: 'Get first row from CSV file (streaming, no memory overhead). Returns columns array and isEmpty flag.',\n  inputSchema,\n  outputSchema: z.object({\n    result: outputSchema,\n  }),\n} as const;\n\nexport type Input = z.infer<typeof inputSchema>;\nexport type Output = z.infer<typeof outputSchema>;\n\nasync function handler({ sourceUri }: Input, extra: EnrichedExtra): Promise<CallToolResult> {\n  const logger = extra.logger;\n  logger.debug?.('sheets.csv.get-columns called', { sourceUri });\n\n  try {\n    // Get readable stream from CSV URI (no temp files!)\n    const readStream = await getCsvReadStream(sourceUri);\n\n    // Create CSV parser without treating first row as column names\n    // We just want to read the raw first row\n    const parser = readStream.pipe(\n      parse({\n        columns: false, // Don't treat first row as headers\n        skip_empty_lines: true,\n        trim: true,\n        cast: true, // Auto-convert numbers/booleans\n        relax_column_count: true,\n      })\n    );\n\n    // Read only the first row\n    let firstRow: unknown[] = [];\n    let rowCount = 0;\n\n    for await (const row of parser) {\n      firstRow = row;\n      rowCount++;\n      break; // Only read first row\n    }\n\n    // Convert first row to strings (column names)\n    const columns = firstRow.map((value) => String(value ?? ''));\n    const isEmpty = rowCount === 0;\n\n    const result: Output = {\n      type: 'success' as const,\n      columns,\n      isEmpty,\n    };\n\n    logger.info?.('sheets.csv.get-columns completed', { sourceUri, columnCount: columns.length, isEmpty });\n    return {\n      content: [{ type: 'text' as const, text: JSON.stringify(result) }],\n      structuredContent: { result },\n    };\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    logger.error?.('sheets.csv.get-columns error', { error: message });\n    throw new McpError(ErrorCode.InternalError, `Error getting CSV columns: ${message}`, {\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n  }\n}\n\nexport default function createTool() {\n  return {\n    name: 'csv-get-columns',\n    config,\n    handler,\n  } satisfies ToolModule;\n}\n"],"names":["createTool","AuthRequiredBranchSchema","schemas","inputSchema","z","object","sourceUri","string","trim","min","describe","successBranchSchema","type","literal","columns","array","isEmpty","boolean","outputSchema","discriminatedUnion","config","description","result","handler","extra","logger","readStream","parser","firstRow","rowCount","row","error","message","debug","getCsvReadStream","pipe","parse","skip_empty_lines","cast","relax_column_count","map","value","String","info","columnCount","length","content","text","JSON","stringify","structuredContent","Error","McpError","ErrorCode","InternalError","stack","undefined","name"],"mappings":"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"}

package/dist/cjs/mcp/tools/dimensions-batch-update.d.cts

@@ -0,0 +1,118 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-google';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    id: z.ZodString;
+    gid: z.ZodCoercedString<unknown>;
+    requests: z.ZodArray<z.ZodObject<{
+        operation: z.ZodEnum<{
+            insertDimension: "insertDimension";
+            deleteDimension: "deleteDimension";
+            appendDimension: "appendDimension";
+        }>;
+        dimension: z.ZodEnum<{
+            ROWS: "ROWS";
+            COLUMNS: "COLUMNS";
+        }>;
+        startIndex: z.ZodNumber;
+        endIndex: z.ZodOptional<z.ZodNumber>;
+        inheritFromBefore: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    id: z.ZodString;
+    gid: z.ZodString;
+    spreadsheetTitle: z.ZodString;
+    spreadsheetUrl: z.ZodString;
+    sheetTitle: z.ZodString;
+    sheetUrl: z.ZodString;
+    totalOperations: z.ZodNumber;
+    operationResults: z.ZodArray<z.ZodObject<{
+        operation: z.ZodEnum<{
+            insertDimension: "insertDimension";
+            deleteDimension: "deleteDimension";
+            appendDimension: "appendDimension";
+        }>;
+        dimension: z.ZodEnum<{
+            ROWS: "ROWS";
+            COLUMNS: "COLUMNS";
+        }>;
+        startIndex: z.ZodNumber;
+        endIndex: z.ZodOptional<z.ZodNumber>;
+        affectedCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    updatedDimensions: z.ZodObject<{
+        rows: z.ZodNumber;
+        columns: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler({ id, gid, requests }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Batch update sheet dimensions by inserting, deleting, or appending rows/columns. Operations are atomic (all succeed or all fail) and execute in optimal order automatically.";
+        readonly inputSchema: z.ZodObject<{
+            id: z.ZodString;
+            gid: z.ZodCoercedString<unknown>;
+            requests: z.ZodArray<z.ZodObject<{
+                operation: z.ZodEnum<{
+                    insertDimension: "insertDimension";
+                    deleteDimension: "deleteDimension";
+                    appendDimension: "appendDimension";
+                }>;
+                dimension: z.ZodEnum<{
+                    ROWS: "ROWS";
+                    COLUMNS: "COLUMNS";
+                }>;
+                startIndex: z.ZodNumber;
+                endIndex: z.ZodOptional<z.ZodNumber>;
+                inheritFromBefore: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                id: z.ZodString;
+                gid: z.ZodString;
+                spreadsheetTitle: z.ZodString;
+                spreadsheetUrl: z.ZodString;
+                sheetTitle: z.ZodString;
+                sheetUrl: z.ZodString;
+                totalOperations: z.ZodNumber;
+                operationResults: z.ZodArray<z.ZodObject<{
+                    operation: z.ZodEnum<{
+                        insertDimension: "insertDimension";
+                        deleteDimension: "deleteDimension";
+                        appendDimension: "appendDimension";
+                    }>;
+                    dimension: z.ZodEnum<{
+                        ROWS: "ROWS";
+                        COLUMNS: "COLUMNS";
+                    }>;
+                    startIndex: z.ZodNumber;
+                    endIndex: z.ZodOptional<z.ZodNumber>;
+                    affectedCount: z.ZodNumber;
+                }, z.core.$strip>>;
+                updatedDimensions: z.ZodObject<{
+                    rows: z.ZodNumber;
+                    columns: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};

package/dist/cjs/mcp/tools/dimensions-batch-update.d.ts

@@ -0,0 +1,118 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-google';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    id: z.ZodString;
+    gid: z.ZodCoercedString<unknown>;
+    requests: z.ZodArray<z.ZodObject<{
+        operation: z.ZodEnum<{
+            insertDimension: "insertDimension";
+            deleteDimension: "deleteDimension";
+            appendDimension: "appendDimension";
+        }>;
+        dimension: z.ZodEnum<{
+            ROWS: "ROWS";
+            COLUMNS: "COLUMNS";
+        }>;
+        startIndex: z.ZodNumber;
+        endIndex: z.ZodOptional<z.ZodNumber>;
+        inheritFromBefore: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    id: z.ZodString;
+    gid: z.ZodString;
+    spreadsheetTitle: z.ZodString;
+    spreadsheetUrl: z.ZodString;
+    sheetTitle: z.ZodString;
+    sheetUrl: z.ZodString;
+    totalOperations: z.ZodNumber;
+    operationResults: z.ZodArray<z.ZodObject<{
+        operation: z.ZodEnum<{
+            insertDimension: "insertDimension";
+            deleteDimension: "deleteDimension";
+            appendDimension: "appendDimension";
+        }>;
+        dimension: z.ZodEnum<{
+            ROWS: "ROWS";
+            COLUMNS: "COLUMNS";
+        }>;
+        startIndex: z.ZodNumber;
+        endIndex: z.ZodOptional<z.ZodNumber>;
+        affectedCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    updatedDimensions: z.ZodObject<{
+        rows: z.ZodNumber;
+        columns: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler({ id, gid, requests }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Batch update sheet dimensions by inserting, deleting, or appending rows/columns. Operations are atomic (all succeed or all fail) and execute in optimal order automatically.";
+        readonly inputSchema: z.ZodObject<{
+            id: z.ZodString;
+            gid: z.ZodCoercedString<unknown>;
+            requests: z.ZodArray<z.ZodObject<{
+                operation: z.ZodEnum<{
+                    insertDimension: "insertDimension";
+                    deleteDimension: "deleteDimension";
+                    appendDimension: "appendDimension";
+                }>;
+                dimension: z.ZodEnum<{
+                    ROWS: "ROWS";
+                    COLUMNS: "COLUMNS";
+                }>;
+                startIndex: z.ZodNumber;
+                endIndex: z.ZodOptional<z.ZodNumber>;
+                inheritFromBefore: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                id: z.ZodString;
+                gid: z.ZodString;
+                spreadsheetTitle: z.ZodString;
+                spreadsheetUrl: z.ZodString;
+                sheetTitle: z.ZodString;
+                sheetUrl: z.ZodString;
+                totalOperations: z.ZodNumber;
+                operationResults: z.ZodArray<z.ZodObject<{
+                    operation: z.ZodEnum<{
+                        insertDimension: "insertDimension";
+                        deleteDimension: "deleteDimension";
+                        appendDimension: "appendDimension";
+                    }>;
+                    dimension: z.ZodEnum<{
+                        ROWS: "ROWS";
+                        COLUMNS: "COLUMNS";
+                    }>;
+                    startIndex: z.ZodNumber;
+                    endIndex: z.ZodOptional<z.ZodNumber>;
+                    affectedCount: z.ZodNumber;
+                }, z.core.$strip>>;
+                updatedDimensions: z.ZodObject<{
+                    rows: z.ZodNumber;
+                    columns: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};