@mcp-z/mcp-sheets 1.0.0

package/dist/cjs/mcp/tools/rows-append.js

@@ -0,0 +1,335 @@
+"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 _googleapis = require("googleapis");
+var _zod = require("zod");
+var _index = require("../../schemas/index.js");
+var _dataoperations = require("../../spreadsheet/data-operations.js");
+var _sheetoperations = require("../../spreadsheet/sheet-operations.js");
+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({
+    id: _index.SpreadsheetIdSchema,
+    gid: _index.SheetGidSchema,
+    rows: _zod.z.array(_zod.z.array(_zod.z.union([
+        _zod.z.string(),
+        _zod.z.number(),
+        _zod.z.boolean(),
+        _zod.z.null()
+    ])).min(1)).min(1).describe('Array of rows, where each row is an array of cell values. Use null to skip a cell (preserve existing value), empty string "" to clear it.'),
+    headers: _zod.z.array(_zod.z.string()).optional().describe('Column order/names - used for blank sheets or column mapping'),
+    deduplicateBy: _zod.z.array(_zod.z.string()).optional().describe('Column names to use as composite key for deduplication')
+});
+var successBranchSchema = _zod.z.object({
+    type: _zod.z.literal('success'),
+    id: _index.SpreadsheetIdOutput,
+    gid: _index.SheetGidOutput,
+    sheetTitle: _zod.z.string().describe('Sheet tab name'),
+    updatedRows: _zod.z.number().describe('Number of rows appended'),
+    rowsSkipped: _zod.z.number().optional().describe('Number of duplicate rows skipped'),
+    sheetUrl: _zod.z.string().optional().describe('URL to view the sheet')
+});
+var outputSchema = _zod.z.discriminatedUnion('type', [
+    successBranchSchema,
+    AuthRequiredBranchSchema
+]);
+var config = {
+    description: 'Add new rows to the bottom of an existing sheet with smart header handling and optional deduplication. BEST FOR: Structured database operations where spreadsheet has headers defining schema and rows represent records.',
+    inputSchema: inputSchema,
+    outputSchema: _zod.z.object({
+        result: outputSchema
+    })
+};
+function handler(_0, _1) {
+    return _async_to_generator(function(param, extra) {
+        var id, gid, rows, headers, deduplicateBy, logger, _ref, _spreadsheetResponse_data_sheets, _sheet_properties, sheets, spreadsheetResponse, sheet, sheetTitle, processedRows, currentHeaders, rowsSkipped, existingKeySet, headerResult, effectiveKeyColumns, appendResult, updatedRows, sheetUrl, result, error, message;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    id = param.id, gid = param.gid, rows = param.rows, headers = param.headers, deduplicateBy = param.deduplicateBy;
+                    logger = extra.logger;
+                    logger.info('sheets.rows.append called', {
+                        id: id,
+                        gid: gid,
+                        rowCount: rows.length,
+                        headers: headers,
+                        deduplicateBy: deduplicateBy
+                    });
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        6,
+                        ,
+                        7
+                    ]);
+                    sheets = _googleapis.google.sheets({
+                        version: 'v4',
+                        auth: extra.authContext.auth
+                    });
+                    return [
+                        4,
+                        sheets.spreadsheets.get({
+                            spreadsheetId: id,
+                            fields: 'sheets.properties.sheetId,sheets.properties.title'
+                        })
+                    ];
+                case 2:
+                    spreadsheetResponse = _state.sent();
+                    sheet = (_spreadsheetResponse_data_sheets = spreadsheetResponse.data.sheets) === null || _spreadsheetResponse_data_sheets === void 0 ? void 0 : _spreadsheetResponse_data_sheets.find(function(s) {
+                        var _s_properties;
+                        return String((_s_properties = s.properties) === null || _s_properties === void 0 ? void 0 : _s_properties.sheetId) === gid;
+                    });
+                    if (!sheet) {
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, 'Sheet not found');
+                    }
+                    sheetTitle = (_ref = sheet === null || sheet === void 0 ? void 0 : (_sheet_properties = sheet.properties) === null || _sheet_properties === void 0 ? void 0 : _sheet_properties.title) !== null && _ref !== void 0 ? _ref : '';
+                    // Smart header handling and data processing
+                    processedRows = rows;
+                    currentHeaders = [];
+                    rowsSkipped = 0;
+                    existingKeySet = new Set();
+                    if (!(headers && headers.length > 0)) return [
+                        3,
+                        4
+                    ];
+                    return [
+                        4,
+                        (0, _sheetoperations.ensureTabAndHeaders)(sheets, {
+                            spreadsheetId: id,
+                            sheetTitle: sheetTitle,
+                            requiredHeader: headers,
+                            keyColumns: deduplicateBy || [],
+                            logger: logger
+                        })
+                    ];
+                case 3:
+                    headerResult = _state.sent();
+                    currentHeaders = headerResult.header;
+                    existingKeySet = headerResult.keySet;
+                    // Map data rows to match current header order
+                    processedRows = (0, _dataoperations.mapRowsToHeader)({
+                        rows: rows,
+                        header: currentHeaders,
+                        canonical: headers
+                    });
+                    _state.label = 4;
+                case 4:
+                    // Append rows with optional deduplication
+                    // If headers are empty but deduplication is requested, skip deduplication for empty spreadsheets
+                    effectiveKeyColumns = currentHeaders.length === 0 && deduplicateBy && deduplicateBy.length > 0 ? [] : deduplicateBy || [];
+                    return [
+                        4,
+                        (0, _dataoperations.appendRows)(sheets, {
+                            spreadsheetId: id,
+                            sheetTitle: sheetTitle,
+                            rows: processedRows,
+                            keySet: existingKeySet,
+                            keyColumns: effectiveKeyColumns,
+                            header: currentHeaders,
+                            logger: logger
+                        })
+                    ];
+                case 5:
+                    appendResult = _state.sent();
+                    rowsSkipped = appendResult.rowsSkipped || 0;
+                    // Only count data rows, not headers - headers are metadata, not items
+                    updatedRows = appendResult.updatedRows || 0;
+                    sheetUrl = "https://docs.google.com/spreadsheets/d/".concat(id, "/edit#gid=").concat(gid);
+                    logger.info('sheets.rows.append completed', {
+                        id: id,
+                        gid: gid,
+                        updatedRows: updatedRows,
+                        rowsSkipped: rowsSkipped
+                    });
+                    result = {
+                        type: 'success',
+                        id: id,
+                        gid: gid,
+                        sheetTitle: sheetTitle,
+                        updatedRows: updatedRows,
+                        rowsSkipped: rowsSkipped,
+                        sheetUrl: sheetUrl
+                    };
+                    return [
+                        2,
+                        {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result)
+                                }
+                            ],
+                            structuredContent: {
+                                result: result
+                            }
+                        }
+                    ];
+                case 6:
+                    error = _state.sent();
+                    message = _instanceof(error, Error) ? error.message : String(error);
+                    logger.error('sheets.rows.append error', {
+                        error: message
+                    });
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error appending rows: ".concat(message), {
+                        stack: _instanceof(error, Error) ? error.stack : undefined
+                    });
+                case 7:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function createTool() {
+    return {
+        name: 'rows-append',
+        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/rows-append.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-sheets/src/mcp/tools/rows-append.ts"],"sourcesContent":["import 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 { google } from 'googleapis';\nimport { z } from 'zod';\nimport { SheetGidOutput, SheetGidSchema, SpreadsheetIdOutput, SpreadsheetIdSchema } from '../../schemas/index.js';\nimport { appendRows, mapRowsToHeader } from '../../spreadsheet/data-operations.js';\nimport { ensureTabAndHeaders } from '../../spreadsheet/sheet-operations.js';\n\nconst inputSchema = z.object({\n  id: SpreadsheetIdSchema,\n  gid: SheetGidSchema,\n  rows: z\n    .array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])).min(1))\n    .min(1)\n    .describe('Array of rows, where each row is an array of cell values. Use null to skip a cell (preserve existing value), empty string \"\" to clear it.'),\n  headers: z.array(z.string()).optional().describe('Column order/names - used for blank sheets or column mapping'),\n  deduplicateBy: z.array(z.string()).optional().describe('Column names to use as composite key for deduplication'),\n});\n\nconst successBranchSchema = z.object({\n  type: z.literal('success'),\n  id: SpreadsheetIdOutput,\n  gid: SheetGidOutput,\n  sheetTitle: z.string().describe('Sheet tab name'),\n  updatedRows: z.number().describe('Number of rows appended'),\n  rowsSkipped: z.number().optional().describe('Number of duplicate rows skipped'),\n  sheetUrl: z.string().optional().describe('URL to view the sheet'),\n});\n\nconst outputSchema = z.discriminatedUnion('type', [successBranchSchema, AuthRequiredBranchSchema]);\n\nconst config = {\n  description: 'Add new rows to the bottom of an existing sheet with smart header handling and optional deduplication. BEST FOR: Structured database operations where spreadsheet has headers defining schema and rows represent records.',\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({ id, gid, rows, headers, deduplicateBy }: Input, extra: EnrichedExtra): Promise<CallToolResult> {\n  const logger = extra.logger;\n  logger.info('sheets.rows.append called', { id, gid, rowCount: rows.length, headers, deduplicateBy });\n\n  try {\n    const sheets = google.sheets({ version: 'v4', auth: extra.authContext.auth });\n\n    // Get sheet details using the gid\n    const spreadsheetResponse = await sheets.spreadsheets.get({\n      spreadsheetId: id,\n      fields: 'sheets.properties.sheetId,sheets.properties.title',\n    });\n\n    const sheet = spreadsheetResponse.data.sheets?.find((s) => String(s.properties?.sheetId) === gid);\n\n    if (!sheet) {\n      throw new McpError(ErrorCode.InvalidParams, 'Sheet not found');\n    }\n\n    const sheetTitle = sheet?.properties?.title ?? '';\n\n    // Smart header handling and data processing\n    let processedRows = rows;\n    let currentHeaders: string[] = [];\n    let rowsSkipped = 0;\n    let existingKeySet: Set<string> = new Set();\n\n    if (headers && headers.length > 0) {\n      // Use ensureTabAndHeaders to handle header logic\n      const headerResult = await ensureTabAndHeaders(sheets, {\n        spreadsheetId: id,\n        sheetTitle,\n        requiredHeader: headers,\n        keyColumns: deduplicateBy || [],\n        logger,\n      });\n\n      currentHeaders = headerResult.header;\n      existingKeySet = headerResult.keySet;\n\n      // Map data rows to match current header order\n      processedRows = mapRowsToHeader({ rows, header: currentHeaders, canonical: headers }) as (string | number | boolean | null)[][];\n    }\n\n    // Append rows with optional deduplication\n    // If headers are empty but deduplication is requested, skip deduplication for empty spreadsheets\n    const effectiveKeyColumns = currentHeaders.length === 0 && deduplicateBy && deduplicateBy.length > 0 ? [] : deduplicateBy || [];\n\n    const appendResult = await appendRows(sheets, {\n      spreadsheetId: id,\n      sheetTitle,\n      rows: processedRows,\n      keySet: existingKeySet,\n      keyColumns: effectiveKeyColumns,\n      header: currentHeaders,\n      logger,\n    });\n\n    rowsSkipped = appendResult.rowsSkipped || 0;\n    // Only count data rows, not headers - headers are metadata, not items\n    const updatedRows = appendResult.updatedRows || 0;\n\n    const sheetUrl = `https://docs.google.com/spreadsheets/d/${id}/edit#gid=${gid}`;\n\n    logger.info('sheets.rows.append completed', { id, gid, updatedRows, rowsSkipped });\n\n    const result: Output = {\n      type: 'success' as const,\n      id,\n      gid,\n      sheetTitle,\n      updatedRows,\n      rowsSkipped, // Always include rowsSkipped, even when 0\n      sheetUrl,\n    };\n\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.rows.append error', { error: message });\n\n    throw new McpError(ErrorCode.InternalError, `Error appending rows: ${message}`, {\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n  }\n}\n\nexport default function createTool() {\n  return {\n    name: 'rows-append',\n    config,\n    handler,\n  } satisfies ToolModule;\n}\n"],"names":["createTool","AuthRequiredBranchSchema","schemas","inputSchema","z","object","id","SpreadsheetIdSchema","gid","SheetGidSchema","rows","array","union","string","number","boolean","null","min","describe","headers","optional","deduplicateBy","successBranchSchema","type","literal","SpreadsheetIdOutput","SheetGidOutput","sheetTitle","updatedRows","rowsSkipped","sheetUrl","outputSchema","discriminatedUnion","config","description","result","handler","extra","logger","spreadsheetResponse","sheet","sheets","processedRows","currentHeaders","existingKeySet","headerResult","effectiveKeyColumns","appendResult","error","message","info","rowCount","length","google","version","auth","authContext","spreadsheets","get","spreadsheetId","fields","data","find","s","String","properties","sheetId","McpError","ErrorCode","InvalidParams","title","Set","ensureTabAndHeaders","requiredHeader","keyColumns","header","keySet","mapRowsToHeader","canonical","appendRows","content","text","JSON","stringify","structuredContent","Error","InternalError","stack","undefined","name"],"mappings":"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"}

package/dist/cjs/mcp/tools/rows-csv-append.d.cts

@@ -0,0 +1,67 @@
+/** Import CSV data to Google Sheets with database-style row append and deduplication */
+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>;
+    sourceUri: z.ZodString;
+    sourceHasHeaders: z.ZodDefault<z.ZodBoolean>;
+    headerMap: z.ZodArray<z.ZodObject<{
+        source: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        target: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strip>>;
+    deduplicateBy: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    id: z.ZodString;
+    gid: z.ZodString;
+    sheetTitle: z.ZodString;
+    updatedRows: z.ZodNumber;
+    rowsSkipped: z.ZodOptional<z.ZodNumber>;
+    sheetUrl: z.ZodOptional<z.ZodString>;
+}, 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, sourceUri, sourceHasHeaders, headerMap, deduplicateBy }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Import CSV to Google Sheets with column mapping and optional deduplication. Streams data for large files.";
+        readonly inputSchema: z.ZodObject<{
+            id: z.ZodString;
+            gid: z.ZodCoercedString<unknown>;
+            sourceUri: z.ZodString;
+            sourceHasHeaders: z.ZodDefault<z.ZodBoolean>;
+            headerMap: z.ZodArray<z.ZodObject<{
+                source: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                target: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            }, z.core.$strip>>;
+            deduplicateBy: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                id: z.ZodString;
+                gid: z.ZodString;
+                sheetTitle: z.ZodString;
+                updatedRows: z.ZodNumber;
+                rowsSkipped: z.ZodOptional<z.ZodNumber>;
+                sheetUrl: z.ZodOptional<z.ZodString>;
+            }, 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/rows-csv-append.d.ts

@@ -0,0 +1,67 @@
+/** Import CSV data to Google Sheets with database-style row append and deduplication */
+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>;
+    sourceUri: z.ZodString;
+    sourceHasHeaders: z.ZodDefault<z.ZodBoolean>;
+    headerMap: z.ZodArray<z.ZodObject<{
+        source: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        target: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strip>>;
+    deduplicateBy: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    id: z.ZodString;
+    gid: z.ZodString;
+    sheetTitle: z.ZodString;
+    updatedRows: z.ZodNumber;
+    rowsSkipped: z.ZodOptional<z.ZodNumber>;
+    sheetUrl: z.ZodOptional<z.ZodString>;
+}, 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, sourceUri, sourceHasHeaders, headerMap, deduplicateBy }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Import CSV to Google Sheets with column mapping and optional deduplication. Streams data for large files.";
+        readonly inputSchema: z.ZodObject<{
+            id: z.ZodString;
+            gid: z.ZodCoercedString<unknown>;
+            sourceUri: z.ZodString;
+            sourceHasHeaders: z.ZodDefault<z.ZodBoolean>;
+            headerMap: z.ZodArray<z.ZodObject<{
+                source: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                target: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            }, z.core.$strip>>;
+            deduplicateBy: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                id: z.ZodString;
+                gid: z.ZodString;
+                sheetTitle: z.ZodString;
+                updatedRows: z.ZodNumber;
+                rowsSkipped: z.ZodOptional<z.ZodNumber>;
+                sheetUrl: z.ZodOptional<z.ZodString>;
+            }, 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 {};