@mcp-z/mcp-sheets 1.0.0

package/dist/cjs/mcp/tools/lib/dimension-operations.d.cts

@@ -0,0 +1,48 @@
+export declare const DEFAULT_APPEND_COUNT = 1;
+export declare const DEFAULT_ROW_COUNT = 1000;
+export declare const DEFAULT_COLUMN_COUNT = 26;
+export declare const MAX_ROW_COUNT = 10000000;
+export declare const MAX_COLUMN_COUNT = 18278;
+export type DimensionOperation = 'insertDimension' | 'deleteDimension' | 'appendDimension';
+export type DimensionType = 'ROWS' | 'COLUMNS';
+export interface DimensionRequest {
+    operation: DimensionOperation;
+    dimension: DimensionType;
+    startIndex: number;
+    endIndex?: number;
+    inheritFromBefore?: boolean;
+}
+export declare function sortOperations(requests: DimensionRequest[]): DimensionRequest[];
+export declare function buildDimensionRequest(operation: DimensionRequest, sheetId: number): {
+    insertDimension: {
+        range: {
+            endIndex: number;
+            sheetId: number;
+            dimension: DimensionType;
+            startIndex: number;
+        };
+        inheritFromBefore: boolean;
+    };
+    deleteDimension?: undefined;
+    appendDimension?: undefined;
+} | {
+    deleteDimension: {
+        range: {
+            endIndex: number;
+            sheetId: number;
+            dimension: DimensionType;
+            startIndex: number;
+        };
+    };
+    insertDimension?: undefined;
+    appendDimension?: undefined;
+} | {
+    appendDimension: {
+        sheetId: number;
+        dimension: DimensionType;
+        length: number;
+    };
+    insertDimension?: undefined;
+    deleteDimension?: undefined;
+};
+export declare function calculateAffectedCount(operation: DimensionRequest): number;

package/dist/cjs/mcp/tools/lib/dimension-operations.d.ts

@@ -0,0 +1,48 @@
+export declare const DEFAULT_APPEND_COUNT = 1;
+export declare const DEFAULT_ROW_COUNT = 1000;
+export declare const DEFAULT_COLUMN_COUNT = 26;
+export declare const MAX_ROW_COUNT = 10000000;
+export declare const MAX_COLUMN_COUNT = 18278;
+export type DimensionOperation = 'insertDimension' | 'deleteDimension' | 'appendDimension';
+export type DimensionType = 'ROWS' | 'COLUMNS';
+export interface DimensionRequest {
+    operation: DimensionOperation;
+    dimension: DimensionType;
+    startIndex: number;
+    endIndex?: number;
+    inheritFromBefore?: boolean;
+}
+export declare function sortOperations(requests: DimensionRequest[]): DimensionRequest[];
+export declare function buildDimensionRequest(operation: DimensionRequest, sheetId: number): {
+    insertDimension: {
+        range: {
+            endIndex: number;
+            sheetId: number;
+            dimension: DimensionType;
+            startIndex: number;
+        };
+        inheritFromBefore: boolean;
+    };
+    deleteDimension?: undefined;
+    appendDimension?: undefined;
+} | {
+    deleteDimension: {
+        range: {
+            endIndex: number;
+            sheetId: number;
+            dimension: DimensionType;
+            startIndex: number;
+        };
+    };
+    insertDimension?: undefined;
+    appendDimension?: undefined;
+} | {
+    appendDimension: {
+        sheetId: number;
+        dimension: DimensionType;
+        length: number;
+    };
+    insertDimension?: undefined;
+    deleteDimension?: undefined;
+};
+export declare function calculateAffectedCount(operation: DimensionRequest): number;

package/dist/cjs/mcp/tools/lib/dimension-operations.js

@@ -0,0 +1,177 @@
+// Google Sheets dimension constants
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_APPEND_COUNT () {
+        return DEFAULT_APPEND_COUNT;
+    },
+    get DEFAULT_COLUMN_COUNT () {
+        return DEFAULT_COLUMN_COUNT;
+    },
+    get DEFAULT_ROW_COUNT () {
+        return DEFAULT_ROW_COUNT;
+    },
+    get MAX_COLUMN_COUNT () {
+        return MAX_COLUMN_COUNT;
+    },
+    get MAX_ROW_COUNT () {
+        return MAX_ROW_COUNT;
+    },
+    get buildDimensionRequest () {
+        return buildDimensionRequest;
+    },
+    get calculateAffectedCount () {
+        return calculateAffectedCount;
+    },
+    get sortOperations () {
+        return sortOperations;
+    }
+});
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var DEFAULT_APPEND_COUNT = 1; // Default number of rows/columns to append
+var DEFAULT_ROW_COUNT = 1000; // Google Sheets default for new sheets
+var DEFAULT_COLUMN_COUNT = 26; // Google Sheets default for new sheets (A-Z)
+var MAX_ROW_COUNT = 10000000; // Google Sheets maximum
+var MAX_COLUMN_COUNT = 18278; // Google Sheets maximum (ZZZ in base-26)
+function sortOperations(requests) {
+    // Sort by: 1) operation type (delete -> insert -> append), 2) proper index ordering to prevent conflicts
+    return _to_consumable_array(requests).sort(function(a, b) {
+        // Operation type priority: deleteDimension (0), insertDimension (1), appendDimension (2)
+        var operationPriority = {
+            deleteDimension: 0,
+            insertDimension: 1,
+            appendDimension: 2
+        };
+        var aPriority = operationPriority[a.operation];
+        var bPriority = operationPriority[b.operation];
+        if (aPriority !== bPriority) {
+            return aPriority - bPriority;
+        }
+        // Within same operation type, sort by appropriate index
+        if (a.operation === 'deleteDimension') {
+            var _a_endIndex, _b_endIndex;
+            // For deletes, process higher START indices first to avoid index shifting issues
+            // This ensures we delete from the end towards the beginning
+            var aStart = a.startIndex;
+            var bStart = b.startIndex;
+            if (aStart !== bStart) {
+                return bStart - aStart; // Higher start index first
+            }
+            // If start indices are equal, process higher end index first for consistency
+            var aEnd = (_a_endIndex = a.endIndex) !== null && _a_endIndex !== void 0 ? _a_endIndex : a.startIndex + 1;
+            var bEnd = (_b_endIndex = b.endIndex) !== null && _b_endIndex !== void 0 ? _b_endIndex : b.startIndex + 1;
+            return bEnd - aEnd;
+        }
+        // For inserts and appends, process lower indices first
+        // This ensures we modify from the beginning towards the end
+        return a.startIndex - b.startIndex;
+    });
+}
+function buildDimensionRequest(operation, sheetId) {
+    var operationType = operation.operation, dimension = operation.dimension, startIndex = operation.startIndex, endIndex = operation.endIndex, inheritFromBefore = operation.inheritFromBefore;
+    var dimensionRange = _object_spread({
+        sheetId: sheetId,
+        dimension: dimension,
+        startIndex: startIndex
+    }, endIndex !== undefined && {
+        endIndex: endIndex
+    });
+    switch(operationType){
+        case 'insertDimension':
+            return {
+                insertDimension: {
+                    range: dimensionRange,
+                    inheritFromBefore: inheritFromBefore !== null && inheritFromBefore !== void 0 ? inheritFromBefore : false
+                }
+            };
+        case 'deleteDimension':
+            return {
+                deleteDimension: {
+                    range: dimensionRange
+                }
+            };
+        case 'appendDimension':
+            return {
+                appendDimension: {
+                    sheetId: sheetId,
+                    dimension: dimension,
+                    length: DEFAULT_APPEND_COUNT
+                }
+            };
+        default:
+            throw new Error("Unsupported operation type: ".concat(operationType));
+    }
+}
+function calculateAffectedCount(operation) {
+    var operationType = operation.operation, startIndex = operation.startIndex, endIndex = operation.endIndex;
+    switch(operationType){
+        case 'insertDimension':
+        case 'deleteDimension':
+            return endIndex !== undefined ? endIndex - startIndex : 1;
+        case 'appendDimension':
+            return DEFAULT_APPEND_COUNT;
+        default:
+            return 0;
+    }
+}
+/* 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/lib/dimension-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-sheets/src/mcp/tools/lib/dimension-operations.ts"],"sourcesContent":["// Google Sheets dimension constants\nexport const DEFAULT_APPEND_COUNT = 1; // Default number of rows/columns to append\nexport const DEFAULT_ROW_COUNT = 1000; // Google Sheets default for new sheets\nexport const DEFAULT_COLUMN_COUNT = 26; // Google Sheets default for new sheets (A-Z)\nexport const MAX_ROW_COUNT = 10000000; // Google Sheets maximum\nexport const MAX_COLUMN_COUNT = 18278; // Google Sheets maximum (ZZZ in base-26)\n\n// Type definitions for dimension operations\nexport type DimensionOperation = 'insertDimension' | 'deleteDimension' | 'appendDimension';\nexport type DimensionType = 'ROWS' | 'COLUMNS';\n\nexport interface DimensionRequest {\n  operation: DimensionOperation;\n  dimension: DimensionType;\n  startIndex: number;\n  endIndex?: number;\n  inheritFromBefore?: boolean;\n}\n\n// Helper function to sort operations for optimal execution order\nexport function sortOperations(requests: DimensionRequest[]): DimensionRequest[] {\n  // Sort by: 1) operation type (delete -> insert -> append), 2) proper index ordering to prevent conflicts\n  return [...requests].sort((a, b) => {\n    // Operation type priority: deleteDimension (0), insertDimension (1), appendDimension (2)\n    const operationPriority = {\n      deleteDimension: 0,\n      insertDimension: 1,\n      appendDimension: 2,\n    };\n\n    const aPriority = operationPriority[a.operation];\n    const bPriority = operationPriority[b.operation];\n\n    if (aPriority !== bPriority) {\n      return aPriority - bPriority;\n    }\n\n    // Within same operation type, sort by appropriate index\n    if (a.operation === 'deleteDimension') {\n      // For deletes, process higher START indices first to avoid index shifting issues\n      // This ensures we delete from the end towards the beginning\n      const aStart = a.startIndex;\n      const bStart = b.startIndex;\n      if (aStart !== bStart) {\n        return bStart - aStart; // Higher start index first\n      }\n      // If start indices are equal, process higher end index first for consistency\n      const aEnd = a.endIndex ?? a.startIndex + 1;\n      const bEnd = b.endIndex ?? b.startIndex + 1;\n      return bEnd - aEnd;\n    }\n    // For inserts and appends, process lower indices first\n    // This ensures we modify from the beginning towards the end\n    return a.startIndex - b.startIndex;\n  });\n}\n\n// Helper function to build Google Sheets API dimension request\nexport function buildDimensionRequest(operation: DimensionRequest, sheetId: number) {\n  const { operation: operationType, dimension, startIndex, endIndex, inheritFromBefore } = operation;\n\n  const dimensionRange = {\n    sheetId,\n    dimension,\n    startIndex,\n    ...(endIndex !== undefined && { endIndex }),\n  };\n\n  switch (operationType) {\n    case 'insertDimension':\n      return {\n        insertDimension: {\n          range: dimensionRange,\n          inheritFromBefore: inheritFromBefore ?? false,\n        },\n      };\n    case 'deleteDimension':\n      return {\n        deleteDimension: {\n          range: dimensionRange,\n        },\n      };\n    case 'appendDimension':\n      return {\n        appendDimension: {\n          sheetId,\n          dimension,\n          length: DEFAULT_APPEND_COUNT,\n        },\n      };\n    default:\n      throw new Error(`Unsupported operation type: ${operationType}`);\n  }\n}\n\n// Helper function to calculate affected count for each operation\nexport function calculateAffectedCount(operation: DimensionRequest): number {\n  const { operation: operationType, startIndex, endIndex } = operation;\n\n  switch (operationType) {\n    case 'insertDimension':\n    case 'deleteDimension':\n      return endIndex !== undefined ? endIndex - startIndex : 1;\n    case 'appendDimension':\n      return DEFAULT_APPEND_COUNT;\n    default:\n      return 0;\n  }\n}\n"],"names":["DEFAULT_APPEND_COUNT","DEFAULT_COLUMN_COUNT","DEFAULT_ROW_COUNT","MAX_COLUMN_COUNT","MAX_ROW_COUNT","buildDimensionRequest","calculateAffectedCount","sortOperations","requests","sort","a","b","operationPriority","deleteDimension","insertDimension","appendDimension","aPriority","operation","bPriority","aStart","startIndex","bStart","aEnd","endIndex","bEnd","sheetId","operationType","dimension","inheritFromBefore","dimensionRange","undefined","range","length","Error"],"mappings":"AAAA,oCAAoC;;;;;;;;;;;;QACvBA;eAAAA;;QAEAC;eAAAA;;QADAC;eAAAA;;QAGAC;eAAAA;;QADAC;eAAAA;;QAsDGC;eAAAA;;QAsCAC;eAAAA;;QA5EAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAnBT,IAAMP,uBAAuB,GAAG,2CAA2C;AAC3E,IAAME,oBAAoB,MAAM,uCAAuC;AACvE,IAAMD,uBAAuB,IAAI,6CAA6C;AAC9E,IAAMG,gBAAgB,UAAU,wBAAwB;AACxD,IAAMD,mBAAmB,OAAO,yCAAyC;AAezE,SAASI,eAAeC,QAA4B;IACzD,yGAAyG;IACzG,OAAO,AAAC,qBAAGA,UAAUC,IAAI,CAAC,SAACC,GAAGC;QAC5B,yFAAyF;QACzF,IAAMC,oBAAoB;YACxBC,iBAAiB;YACjBC,iBAAiB;YACjBC,iBAAiB;QACnB;QAEA,IAAMC,YAAYJ,iBAAiB,CAACF,EAAEO,SAAS,CAAC;QAChD,IAAMC,YAAYN,iBAAiB,CAACD,EAAEM,SAAS,CAAC;QAEhD,IAAID,cAAcE,WAAW;YAC3B,OAAOF,YAAYE;QACrB;QAEA,wDAAwD;QACxD,IAAIR,EAAEO,SAAS,KAAK,mBAAmB;gBASxBP,aACAC;YATb,iFAAiF;YACjF,4DAA4D;YAC5D,IAAMQ,SAAST,EAAEU,UAAU;YAC3B,IAAMC,SAASV,EAAES,UAAU;YAC3B,IAAID,WAAWE,QAAQ;gBACrB,OAAOA,SAASF,QAAQ,2BAA2B;YACrD;YACA,6EAA6E;YAC7E,IAAMG,QAAOZ,cAAAA,EAAEa,QAAQ,cAAVb,yBAAAA,cAAcA,EAAEU,UAAU,GAAG;YAC1C,IAAMI,QAAOb,cAAAA,EAAEY,QAAQ,cAAVZ,yBAAAA,cAAcA,EAAES,UAAU,GAAG;YAC1C,OAAOI,OAAOF;QAChB;QACA,uDAAuD;QACvD,4DAA4D;QAC5D,OAAOZ,EAAEU,UAAU,GAAGT,EAAES,UAAU;IACpC;AACF;AAGO,SAASf,sBAAsBY,SAA2B,EAAEQ,OAAe;IAChF,IAAQR,AAAWS,gBAAsET,UAAjFA,WAA0BU,YAAuDV,UAAvDU,WAAWP,aAA4CH,UAA5CG,YAAYG,WAAgCN,UAAhCM,UAAUK,oBAAsBX,UAAtBW;IAEnE,IAAMC,iBAAiB;QACrBJ,SAAAA;QACAE,WAAAA;QACAP,YAAAA;OACIG,aAAaO,aAAa;QAAEP,UAAAA;IAAS;IAG3C,OAAQG;QACN,KAAK;YACH,OAAO;gBACLZ,iBAAiB;oBACfiB,OAAOF;oBACPD,iBAAiB,EAAEA,8BAAAA,+BAAAA,oBAAqB;gBAC1C;YACF;QACF,KAAK;YACH,OAAO;gBACLf,iBAAiB;oBACfkB,OAAOF;gBACT;YACF;QACF,KAAK;YACH,OAAO;gBACLd,iBAAiB;oBACfU,SAAAA;oBACAE,WAAAA;oBACAK,QAAQhC;gBACV;YACF;QACF;YACE,MAAM,IAAIiC,MAAM,AAAC,+BAA4C,OAAdP;IACnD;AACF;AAGO,SAASpB,uBAAuBW,SAA2B;IAChE,IAAQA,AAAWS,gBAAwCT,UAAnDA,WAA0BG,aAAyBH,UAAzBG,YAAYG,WAAaN,UAAbM;IAE9C,OAAQG;QACN,KAAK;QACL,KAAK;YACH,OAAOH,aAAaO,YAAYP,WAAWH,aAAa;QAC1D,KAAK;YACH,OAAOpB;QACT;YACE,OAAO;IACX;AACF"}

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

@@ -0,0 +1,58 @@
+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>;
+    rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    headers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deduplicateBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, 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, rows, headers, deduplicateBy }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly 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.";
+        readonly inputSchema: z.ZodObject<{
+            id: z.ZodString;
+            gid: z.ZodCoercedString<unknown>;
+            rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+            headers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deduplicateBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, 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-append.d.ts

@@ -0,0 +1,58 @@
+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>;
+    rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    headers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deduplicateBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, 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, rows, headers, deduplicateBy }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly 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.";
+        readonly inputSchema: z.ZodObject<{
+            id: z.ZodString;
+            gid: z.ZodCoercedString<unknown>;
+            rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+            headers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deduplicateBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, 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 {};