@mastra/connect 0.5.0 → 0.6.0-alpha.1

package/dist/providers/google-sheet/tools/batch-clear-values.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const batchClearValuesInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    ranges: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const batchClearValuesOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    clearedRanges: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare function batchClearValuesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    ranges: string[];
+}, {
+    spreadsheetId: string;
+    clearedRanges: string[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_batch_clear_values", unknown>;
+//# sourceMappingURL=batch-clear-values.d.ts.map

package/dist/providers/google-sheet/tools/batch-clear-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-clear-values.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/batch-clear-values.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,2BAA2B;;;iBAKtC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;+IAuBxD"}

package/dist/providers/google-sheet/tools/batch-get-values-by-data-filter.d.ts

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const batchGetValuesByDataFilterInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    dataFilters: z.ZodArray<z.ZodObject<{
+        a1Range: z.ZodOptional<z.ZodString>;
+        gridRange: z.ZodOptional<z.ZodObject<{
+            sheetId: z.ZodOptional<z.ZodNumber>;
+            startRowIndex: z.ZodOptional<z.ZodNumber>;
+            endRowIndex: z.ZodOptional<z.ZodNumber>;
+            startColumnIndex: z.ZodOptional<z.ZodNumber>;
+            endColumnIndex: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        developerMetadataLookup: z.ZodOptional<z.ZodObject<{
+            locationType: z.ZodOptional<z.ZodEnum<{
+                COLUMN: "COLUMN";
+                ROW: "ROW";
+                SHEET: "SHEET";
+                SPREADSHEET: "SPREADSHEET";
+            }>>;
+            metadataLocation: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+            locationMatchingStrategy: z.ZodOptional<z.ZodEnum<{
+                EXACT_LOCATION: "EXACT_LOCATION";
+                INTERSECTING_LOCATION: "INTERSECTING_LOCATION";
+            }>>;
+            metadataId: z.ZodOptional<z.ZodNumber>;
+            metadataKey: z.ZodOptional<z.ZodString>;
+            metadataValue: z.ZodOptional<z.ZodString>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                DOCUMENT: "DOCUMENT";
+                PROJECT: "PROJECT";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    majorDimension: z.ZodOptional<z.ZodEnum<{
+        COLUMNS: "COLUMNS";
+        ROWS: "ROWS";
+    }>>;
+    valueRenderOption: z.ZodOptional<z.ZodEnum<{
+        FORMATTED_VALUE: "FORMATTED_VALUE";
+        FORMULA: "FORMULA";
+        UNFORMATTED_VALUE: "UNFORMATTED_VALUE";
+    }>>;
+    dateTimeRenderOption: z.ZodOptional<z.ZodEnum<{
+        FORMATTED_STRING: "FORMATTED_STRING";
+        SERIAL_NUMBER: "SERIAL_NUMBER";
+    }>>;
+}, z.core.$strip>;
+export declare const batchGetValuesByDataFilterOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    valueRanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        valueRange: z.ZodOptional<z.ZodObject<{
+            range: z.ZodOptional<z.ZodString>;
+            majorDimension: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+                COLUMNS: "COLUMNS";
+                ROWS: "ROWS";
+            }>, z.ZodString]>>;
+            values: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        dataFilters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            a1Range: z.ZodOptional<z.ZodString>;
+            gridRange: z.ZodOptional<z.ZodObject<{
+                sheetId: z.ZodOptional<z.ZodNumber>;
+                startRowIndex: z.ZodOptional<z.ZodNumber>;
+                endRowIndex: z.ZodOptional<z.ZodNumber>;
+                startColumnIndex: z.ZodOptional<z.ZodNumber>;
+                endColumnIndex: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            developerMetadataLookup: z.ZodOptional<z.ZodObject<{
+                locationType: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+                    COLUMN: "COLUMN";
+                    ROW: "ROW";
+                    SHEET: "SHEET";
+                    SPREADSHEET: "SPREADSHEET";
+                }>, z.ZodString]>>;
+                metadataLocation: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+                locationMatchingStrategy: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+                    EXACT_LOCATION: "EXACT_LOCATION";
+                    INTERSECTING_LOCATION: "INTERSECTING_LOCATION";
+                }>, z.ZodString]>>;
+                metadataId: z.ZodOptional<z.ZodNumber>;
+                metadataKey: z.ZodOptional<z.ZodString>;
+                metadataValue: z.ZodOptional<z.ZodString>;
+                visibility: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+                    DOCUMENT: "DOCUMENT";
+                    PROJECT: "PROJECT";
+                }>, z.ZodString]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare function batchGetValuesByDataFilterTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    dataFilters: {
+        a1Range?: string | undefined;
+        gridRange?: {
+            sheetId?: number | undefined;
+            startRowIndex?: number | undefined;
+            endRowIndex?: number | undefined;
+            startColumnIndex?: number | undefined;
+            endColumnIndex?: number | undefined;
+        } | undefined;
+        developerMetadataLookup?: {
+            locationType?: "COLUMN" | "ROW" | "SHEET" | "SPREADSHEET" | undefined;
+            metadataLocation?: {
+                [x: string]: unknown;
+            } | undefined;
+            locationMatchingStrategy?: "EXACT_LOCATION" | "INTERSECTING_LOCATION" | undefined;
+            metadataId?: number | undefined;
+            metadataKey?: string | undefined;
+            metadataValue?: string | undefined;
+            visibility?: "DOCUMENT" | "PROJECT" | undefined;
+        } | undefined;
+    }[];
+    majorDimension?: "COLUMNS" | "ROWS" | undefined;
+    valueRenderOption?: "FORMATTED_VALUE" | "FORMULA" | "UNFORMATTED_VALUE" | undefined;
+    dateTimeRenderOption?: "FORMATTED_STRING" | "SERIAL_NUMBER" | undefined;
+}, {
+    spreadsheetId: string;
+    valueRanges?: {
+        valueRange?: {
+            range?: string | undefined;
+            majorDimension?: string | undefined;
+            values?: unknown[][] | undefined;
+        } | undefined;
+        dataFilters?: {
+            a1Range?: string | undefined;
+            gridRange?: {
+                sheetId?: number | undefined;
+                startRowIndex?: number | undefined;
+                endRowIndex?: number | undefined;
+                startColumnIndex?: number | undefined;
+                endColumnIndex?: number | undefined;
+            } | undefined;
+            developerMetadataLookup?: {
+                locationType?: string | undefined;
+                metadataLocation?: {
+                    [x: string]: unknown;
+                } | undefined;
+                locationMatchingStrategy?: string | undefined;
+                metadataId?: number | undefined;
+                metadataKey?: string | undefined;
+                metadataValue?: string | undefined;
+                visibility?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+    }[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_batch_get_values_by_data_filter", unknown>;
+//# sourceMappingURL=batch-get-values-by-data-filter.d.ts.map

package/dist/providers/google-sheet/tools/batch-get-values-by-data-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-get-values-by-data-filter.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/batch-get-values-by-data-filter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AA8CxE,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBhD,CAAC;AAaH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjD,CAAC;AAEH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4JAkClE"}

package/dist/providers/google-sheet/tools/batch-get-values.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const batchGetValuesInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    ranges: z.ZodArray<z.ZodString>;
+    majorDimension: z.ZodOptional<z.ZodEnum<{
+        COLUMNS: "COLUMNS";
+        ROWS: "ROWS";
+    }>>;
+    valueRenderOption: z.ZodOptional<z.ZodEnum<{
+        FORMATTED_VALUE: "FORMATTED_VALUE";
+        FORMULA: "FORMULA";
+        UNFORMATTED_VALUE: "UNFORMATTED_VALUE";
+    }>>;
+    dateTimeRenderOption: z.ZodOptional<z.ZodEnum<{
+        FORMATTED_STRING: "FORMATTED_STRING";
+        SERIAL_NUMBER: "SERIAL_NUMBER";
+    }>>;
+}, z.core.$strip>;
+export declare const batchGetValuesOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    valueRanges: z.ZodArray<z.ZodObject<{
+        range: z.ZodString;
+        majorDimension: z.ZodOptional<z.ZodString>;
+        values: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodAny>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function batchGetValuesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    ranges: string[];
+    majorDimension?: "COLUMNS" | "ROWS" | undefined;
+    valueRenderOption?: "FORMATTED_VALUE" | "FORMULA" | "UNFORMATTED_VALUE" | undefined;
+    dateTimeRenderOption?: "FORMATTED_STRING" | "SERIAL_NUMBER" | undefined;
+}, {
+    spreadsheetId: string;
+    valueRanges: {
+        range: string;
+        majorDimension?: string | undefined;
+        values?: any[][] | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_batch_get_values", unknown>;
+//# sourceMappingURL=batch-get-values.d.ts.map

package/dist/providers/google-sheet/tools/batch-get-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-get-values.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/batch-get-values.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;iBAmBpC,CAAC;AAaH,eAAO,MAAM,0BAA0B;;;;;;;iBAGrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;6IAsDtD"}

package/dist/providers/google-sheet/tools/batch-update-spreadsheet.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const batchUpdateSpreadsheetInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    requests: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const batchUpdateSpreadsheetOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    replies: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    updatedRange: z.ZodOptional<z.ZodString>;
+    updatedCells: z.ZodOptional<z.ZodNumber>;
+    updatedColumns: z.ZodOptional<z.ZodNumber>;
+    updatedRows: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function batchUpdateSpreadsheetTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    requests: Record<string, unknown>[];
+}, {
+    spreadsheetId: string;
+    replies: Record<string, unknown>[];
+    updatedRange?: string | undefined;
+    updatedCells?: number | undefined;
+    updatedColumns?: number | undefined;
+    updatedRows?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_batch_update_spreadsheet", unknown>;
+//# sourceMappingURL=batch-update-spreadsheet.d.ts.map

package/dist/providers/google-sheet/tools/batch-update-spreadsheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-update-spreadsheet.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/batch-update-spreadsheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,iCAAiC;;;iBAG5C,CAAC;AAIH,eAAO,MAAM,kCAAkC;;;;;;;iBAO7C,CAAC;AAEH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;qJA6B9D"}

package/dist/providers/google-sheet/tools/clear-values.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const clearValuesInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    range: z.ZodString;
+}, z.core.$strip>;
+export declare const clearValuesOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    clearedRange: z.ZodString;
+}, z.core.$strip>;
+export declare function clearValuesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    range: string;
+}, {
+    spreadsheetId: string;
+    clearedRange: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_clear_values", unknown>;
+//# sourceMappingURL=clear-values.d.ts.map

package/dist/providers/google-sheet/tools/clear-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-values.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/clear-values.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;yIAqBnD"}

package/dist/providers/google-sheet/tools/copy-sheet.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const copySheetInputSchema: z.ZodObject<{
+    sourceSpreadsheetId: z.ZodString;
+    sheetId: z.ZodNumber;
+    destinationSpreadsheetId: z.ZodString;
+}, z.core.$strip>;
+export declare const copySheetOutputSchema: z.ZodObject<{
+    sheetId: z.ZodNumber;
+    title: z.ZodString;
+    index: z.ZodNumber;
+    sheetType: z.ZodString;
+    rowCount: z.ZodOptional<z.ZodNumber>;
+    columnCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function copySheetTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    sourceSpreadsheetId: string;
+    sheetId: number;
+    destinationSpreadsheetId: string;
+}, {
+    sheetId: number;
+    title: string;
+    index: number;
+    sheetType: string;
+    rowCount?: number | undefined;
+    columnCount?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_copy_sheet", unknown>;
+//# sourceMappingURL=copy-sheet.d.ts.map

package/dist/providers/google-sheet/tools/copy-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-sheet.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/copy-sheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;iBAM/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;iBAOhC,CAAC;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;uIAuCjD"}

package/dist/providers/google-sheet/tools/create-column.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createColumnInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    sheetId: z.ZodOptional<z.ZodNumber>;
+    columnIndex: z.ZodNumber;
+    inheritFromBefore: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createColumnOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    sheetId: z.ZodNumber;
+    columnIndex: z.ZodNumber;
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function createColumnTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    sheetId?: number | undefined;
+    columnIndex: number;
+    inheritFromBefore?: boolean | undefined;
+}, {
+    spreadsheetId: string;
+    sheetId: number;
+    columnIndex: number;
+    success: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_create_column", unknown>;
+//# sourceMappingURL=create-column.d.ts.map

package/dist/providers/google-sheet/tools/create-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-column.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/create-column.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;;;iBAclC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAC;AAEH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;0IAyCpD"}

package/dist/providers/google-sheet/tools/create-spreadsheet-row.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createSpreadsheetRowInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    sheetId: z.ZodNumber;
+    sheetName: z.ZodString;
+    rowIndex: z.ZodNumber;
+    values: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const createSpreadsheetRowOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    sheetId: z.ZodNumber;
+    rowIndex: z.ZodNumber;
+    values: z.ZodArray<z.ZodString>;
+    updatedRange: z.ZodString;
+}, z.core.$strip>;
+export declare function createSpreadsheetRowTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    sheetId: number;
+    sheetName: string;
+    rowIndex: number;
+    values: string[];
+}, {
+    spreadsheetId: string;
+    sheetId: number;
+    rowIndex: number;
+    values: string[];
+    updatedRange: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_create_spreadsheet_row", unknown>;
+//# sourceMappingURL=create-spreadsheet-row.d.ts.map

package/dist/providers/google-sheet/tools/create-spreadsheet-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-spreadsheet-row.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/create-spreadsheet-row.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,+BAA+B;;;;;;iBAU1C,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;iBAM3C,CAAC;AAEH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;mJAyD5D"}

package/dist/providers/google-sheet/tools/create-spreadsheet.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createSpreadsheetInputSchema: z.ZodObject<{
+    properties: z.ZodObject<{
+        title: z.ZodString;
+        locale: z.ZodOptional<z.ZodString>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    sheets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        properties: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            gridProperties: z.ZodOptional<z.ZodObject<{
+                rowCount: z.ZodOptional<z.ZodNumber>;
+                columnCount: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+}, z.core.$strip>;
+export declare const createSpreadsheetOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    spreadsheetUrl: z.ZodString;
+    properties: z.ZodOptional<z.ZodAny>;
+}, z.core.$loose>;
+export declare function createSpreadsheetTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    properties: {
+        [x: string]: unknown;
+        title: string;
+        locale?: string | undefined;
+        timeZone?: string | undefined;
+    };
+    sheets?: {
+        [x: string]: unknown;
+        properties?: {
+            [x: string]: unknown;
+            title?: string | undefined;
+            gridProperties?: {
+                rowCount?: number | undefined;
+                columnCount?: number | undefined;
+            } | undefined;
+        } | undefined;
+    }[] | undefined;
+}, {
+    [x: string]: unknown;
+    spreadsheetId: string;
+    spreadsheetUrl: string;
+    properties?: any;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_create_spreadsheet", unknown>;
+//# sourceMappingURL=create-spreadsheet.d.ts.map

package/dist/providers/google-sheet/tools/create-spreadsheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-spreadsheet.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/create-spreadsheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AA4BxE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;iBAGvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;iBAM1B,CAAC;AAEjB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;+IAyBzD"}

package/dist/providers/google-sheet/tools/delete-worksheet.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteWorksheetInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    worksheetName: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteWorksheetOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare function deleteWorksheetTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    worksheetName: string;
+}, {
+    success: boolean;
+    message: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_delete_worksheet", unknown>;
+//# sourceMappingURL=delete-worksheet.d.ts.map

package/dist/providers/google-sheet/tools/delete-worksheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-worksheet.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/delete-worksheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;iBAKrC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;6IAqDvD"}

package/dist/providers/google-sheet/tools/get-spreadsheet-by-data-filter.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getSpreadsheetByDataFilterInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    dataFilters: z.ZodArray<z.ZodObject<{
+        developerMetadataLookup: z.ZodOptional<z.ZodObject<{
+            locationType: z.ZodOptional<z.ZodEnum<{
+                COLUMN: "COLUMN";
+                ROW: "ROW";
+                SHEET: "SHEET";
+                SPREADSHEET: "SPREADSHEET";
+            }>>;
+            metadataLocation: z.ZodOptional<z.ZodObject<{
+                spreadsheet: z.ZodOptional<z.ZodBoolean>;
+                sheetId: z.ZodOptional<z.ZodNumber>;
+                dimensionRange: z.ZodOptional<z.ZodObject<{
+                    sheetId: z.ZodNumber;
+                    dimension: z.ZodEnum<{
+                        COLUMNS: "COLUMNS";
+                        ROWS: "ROWS";
+                    }>;
+                    startIndex: z.ZodOptional<z.ZodNumber>;
+                    endIndex: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            locationMatchingStrategy: z.ZodOptional<z.ZodEnum<{
+                EXACT_LOCATION: "EXACT_LOCATION";
+                INTERSECTING_LOCATION: "INTERSECTING_LOCATION";
+            }>>;
+            metadataId: z.ZodOptional<z.ZodNumber>;
+            metadataKey: z.ZodOptional<z.ZodString>;
+            metadataValue: z.ZodOptional<z.ZodString>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                DOCUMENT: "DOCUMENT";
+                PROJECT: "PROJECT";
+            }>>;
+        }, z.core.$strip>>;
+        a1Range: z.ZodOptional<z.ZodString>;
+        gridRange: z.ZodOptional<z.ZodObject<{
+            sheetId: z.ZodOptional<z.ZodNumber>;
+            startRowIndex: z.ZodOptional<z.ZodNumber>;
+            endRowIndex: z.ZodOptional<z.ZodNumber>;
+            startColumnIndex: z.ZodOptional<z.ZodNumber>;
+            endColumnIndex: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    includeGridData: z.ZodOptional<z.ZodBoolean>;
+    excludeTablesInBandedRanges: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const getSpreadsheetByDataFilterOutputSchema: z.ZodUnknown;
+export declare function getSpreadsheetByDataFilterTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    dataFilters: {
+        developerMetadataLookup?: {
+            locationType?: "COLUMN" | "ROW" | "SHEET" | "SPREADSHEET" | undefined;
+            metadataLocation?: {
+                spreadsheet?: boolean | undefined;
+                sheetId?: number | undefined;
+                dimensionRange?: {
+                    sheetId: number;
+                    dimension: "COLUMNS" | "ROWS";
+                    startIndex?: number | undefined;
+                    endIndex?: number | undefined;
+                } | undefined;
+            } | undefined;
+            locationMatchingStrategy?: "EXACT_LOCATION" | "INTERSECTING_LOCATION" | undefined;
+            metadataId?: number | undefined;
+            metadataKey?: string | undefined;
+            metadataValue?: string | undefined;
+            visibility?: "DOCUMENT" | "PROJECT" | undefined;
+        } | undefined;
+        a1Range?: string | undefined;
+        gridRange?: {
+            sheetId?: number | undefined;
+            startRowIndex?: number | undefined;
+            endRowIndex?: number | undefined;
+            startColumnIndex?: number | undefined;
+            endColumnIndex?: number | undefined;
+        } | undefined;
+    }[];
+    includeGridData?: boolean | undefined;
+    excludeTablesInBandedRanges?: boolean | undefined;
+}, unknown, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_get_spreadsheet_by_data_filter", unknown>;
+//# sourceMappingURL=get-spreadsheet-by-data-filter.d.ts.map

package/dist/providers/google-sheet/tools/get-spreadsheet-by-data-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-spreadsheet-by-data-filter.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/get-spreadsheet-by-data-filter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AA2CxE,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAahD,CAAC;AAEH,eAAO,MAAM,sCAAsC,cAEuB,CAAC;AAE3E,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oKAuBlE"}

package/dist/providers/google-sheet/tools/get-values.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getValuesInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    range: z.ZodString;
+}, z.core.$strip>;
+export declare const getValuesOutputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    range: z.ZodString;
+    majorDimension: z.ZodUnion<[z.ZodEnum<{
+        COLUMNS: "COLUMNS";
+        ROWS: "ROWS";
+    }>, z.ZodString]>;
+    values: z.ZodAny;
+}, z.core.$strip>;
+export declare function getValuesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    range: string;
+}, {
+    spreadsheetId: string;
+    range: string;
+    majorDimension: string;
+    values: any;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_get_values", unknown>;
+//# sourceMappingURL=get-values.d.ts.map

package/dist/providers/google-sheet/tools/get-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-values.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/get-values.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;iBAO/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;iBAKhC,CAAC;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;uIA8BjD"}

package/dist/providers/google-sheet/tools/search-developer-metadata.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const searchDeveloperMetadataInputSchema: z.ZodObject<{
+    spreadsheetId: z.ZodString;
+    dataFilters: z.ZodArray<z.ZodObject<{
+        developerMetadataLookup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        a1Range: z.ZodOptional<z.ZodString>;
+        gridRange: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export declare const searchDeveloperMetadataOutputSchema: z.ZodObject<{
+    matchedDeveloperMetadata: z.ZodArray<z.ZodObject<{
+        developerMetadata: z.ZodObject<{
+            metadataId: z.ZodNumber;
+            metadataKey: z.ZodString;
+            metadataValue: z.ZodString;
+            location: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            visibility: z.ZodString;
+        }, z.core.$strip>;
+        dataFilters: z.ZodArray<z.ZodObject<{
+            developerMetadataLookup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            a1Range: z.ZodOptional<z.ZodString>;
+            gridRange: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function searchDeveloperMetadataTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    spreadsheetId: string;
+    dataFilters: {
+        [x: string]: unknown;
+        developerMetadataLookup?: Record<string, unknown> | undefined;
+        a1Range?: string | undefined;
+        gridRange?: Record<string, unknown> | undefined;
+    }[];
+}, {
+    matchedDeveloperMetadata: {
+        developerMetadata: {
+            metadataId: number;
+            metadataKey: string;
+            metadataValue: string;
+            location: Record<string, unknown>;
+            visibility: string;
+        };
+        dataFilters: {
+            [x: string]: unknown;
+            developerMetadataLookup?: Record<string, unknown> | undefined;
+            a1Range?: string | undefined;
+            gridRange?: Record<string, unknown> | undefined;
+        }[];
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "google_sheet_search_developer_metadata", unknown>;
+//# sourceMappingURL=search-developer-metadata.d.ts.map

package/dist/providers/google-sheet/tools/search-developer-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-developer-metadata.d.ts","sourceRoot":"","sources":["../../../../src/providers/google-sheet/tools/search-developer-metadata.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,kCAAkC;;;;;;;iBAW7C,CAAC;AAuBH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;iBAE9C,CAAC;AAEH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;sJAsB/D"}