slates 0.0.2 → 1.0.0-rc.1

package/example/google-sheets/readme.md

@@ -0,0 +1 @@
+Hello world

package/example/google-sheets/slate.json

@@ -0,0 +1,4 @@
+{
+  "name": "@w1/s1",
+  "version": "1.2.0"
+}

package/example/google-sheets/spec.ts

@@ -0,0 +1,13 @@
+import { SlateSpecification } from 'slates';
+import { auth } from './auth';
+import { config } from './config';
+
+export let spec = SlateSpecification.create({
+  key: 'google-sheets',
+  name: 'Google Sheets',
+  description:
+    'Cloud-based spreadsheet application for creating, editing, and collaborating on spreadsheets.',
+  metadata: {},
+  config,
+  auth
+});

package/example/google-sheets/tools/append-values.ts

@@ -0,0 +1,74 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { SheetsClient } from '../lib/client';
+import { spec } from '../spec';
+
+export let appendValuesTool = SlateTool.create(spec, {
+  name: 'Append Values',
+  key: 'append_values',
+  description: `Appends rows of data to a table in a Google Sheets spreadsheet.
+Finds the last row with data in the specified range and appends new rows below it. Ideal for adding records to a data table.`,
+  instructions: [
+    'Specify a range that covers the table (e.g., "Sheet1!A:E" for columns A through E)',
+    'New rows will be appended after the last row with data'
+  ],
+  tags: {
+    destructive: false,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      spreadsheetId: z.string().describe('ID of the spreadsheet'),
+      range: z.string().describe('Range defining the table to append to (e.g., "Sheet1!A:E")'),
+      values: z
+        .array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])))
+        .describe('2D array of rows to append'),
+      valueInputOption: z
+        .enum(['RAW', 'USER_ENTERED'])
+        .optional()
+        .describe('How input values should be interpreted'),
+      insertDataOption: z
+        .enum(['OVERWRITE', 'INSERT_ROWS'])
+        .optional()
+        .describe('Whether to overwrite or insert new rows')
+    })
+  )
+  .output(
+    z.object({
+      spreadsheetId: z.string().optional().describe('ID of the spreadsheet'),
+      tableRange: z.string().optional().describe('Range of the table that was appended to'),
+      updatedRange: z.string().optional().describe('The actual range that was written'),
+      updatedRows: z.number().optional().describe('Number of rows appended'),
+      updatedColumns: z.number().optional().describe('Number of columns in appended rows'),
+      updatedCells: z.number().optional().describe('Total cells written')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new SheetsClient({ token: ctx.auth.token });
+
+    let result = await client.appendValues(
+      ctx.input.spreadsheetId,
+      ctx.input.range,
+      ctx.input.values,
+      {
+        valueInputOption: ctx.input.valueInputOption || 'USER_ENTERED',
+        insertDataOption: ctx.input.insertDataOption
+      }
+    );
+
+    let output = {
+      spreadsheetId: result.spreadsheetId,
+      tableRange: result.tableRange,
+      updatedRange: result.updates?.updatedRange,
+      updatedRows: result.updates?.updatedRows,
+      updatedColumns: result.updates?.updatedColumns,
+      updatedCells: result.updates?.updatedCells
+    };
+
+    return {
+      output,
+      message: `Appended **${output.updatedRows || ctx.input.values.length}** row(s) to range \`${ctx.input.range}\`.`
+    };
+  })
+  .build();

package/example/google-sheets/tools/clear-values.ts

@@ -0,0 +1,45 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { SheetsClient } from '../lib/client';
+import { spec } from '../spec';
+
+export let clearValuesTool = SlateTool.create(spec, {
+  name: 'Clear Values',
+  key: 'clear_values',
+  description: `Clears cell values from specified ranges in a Google Sheets spreadsheet.
+Removes values but preserves formatting, data validation, and other cell properties.`,
+  tags: {
+    destructive: true,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      spreadsheetId: z.string().describe('ID of the spreadsheet'),
+      ranges: z
+        .array(z.string())
+        .describe('Ranges to clear in A1 notation (e.g., ["Sheet1!A1:B10", "Sheet2!C1:D5"])')
+    })
+  )
+  .output(
+    z.object({
+      spreadsheetId: z.string().optional().describe('ID of the spreadsheet'),
+      clearedRanges: z.array(z.string()).optional().describe('Ranges that were cleared')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new SheetsClient({ token: ctx.auth.token });
+
+    let result = await client.batchClearValues(ctx.input.spreadsheetId, ctx.input.ranges);
+
+    let output = {
+      spreadsheetId: result.spreadsheetId,
+      clearedRanges: result.clearedRanges
+    };
+
+    return {
+      output,
+      message: `Cleared **${ctx.input.ranges.length}** range(s): ${ctx.input.ranges.map(r => `\`${r}\``).join(', ')}.`
+    };
+  })
+  .build();

package/example/google-sheets/tools/copy-paste.ts

@@ -0,0 +1,99 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { SheetsClient } from '../lib/client';
+import { spec } from '../spec';
+
+export let copyPasteTool = SlateTool.create(spec, {
+  name: 'Copy and Paste',
+  key: 'copy_paste',
+  description: `Copies a range of cells and pastes them to another location in a Google Sheets spreadsheet.
+Supports various paste types including values only, format only, formulas only, and transposing data.`,
+  tags: {
+    destructive: false,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      spreadsheetId: z.string().describe('ID of the spreadsheet'),
+      sourceSheetId: z.number().describe('Sheet ID of the source range'),
+      sourceStartRowIndex: z.number().describe('Source start row index (0-based)'),
+      sourceEndRowIndex: z.number().describe('Source end row index (exclusive)'),
+      sourceStartColumnIndex: z.number().describe('Source start column index (0-based)'),
+      sourceEndColumnIndex: z.number().describe('Source end column index (exclusive)'),
+      destinationSheetId: z.number().describe('Sheet ID of the destination range'),
+      destinationStartRowIndex: z.number().describe('Destination start row index (0-based)'),
+      destinationEndRowIndex: z.number().describe('Destination end row index (exclusive)'),
+      destinationStartColumnIndex: z
+        .number()
+        .describe('Destination start column index (0-based)'),
+      destinationEndColumnIndex: z
+        .number()
+        .describe('Destination end column index (exclusive)'),
+      pasteType: z
+        .enum([
+          'PASTE_NORMAL',
+          'PASTE_VALUES',
+          'PASTE_FORMAT',
+          'PASTE_NO_BORDERS',
+          'PASTE_FORMULA',
+          'PASTE_DATA_VALIDATION',
+          'PASTE_CONDITIONAL_FORMATTING'
+        ])
+        .optional()
+        .describe(
+          'What to paste: NORMAL (all), VALUES (values only), FORMAT (formatting only), etc.'
+        ),
+      pasteOrientation: z
+        .enum(['NORMAL', 'TRANSPOSE'])
+        .optional()
+        .describe('Whether to transpose rows and columns')
+    })
+  )
+  .output(
+    z.object({
+      operationPerformed: z.string().describe('Description of the copy/paste operation'),
+      sourceRange: z.string().describe('Description of the source range'),
+      destinationRange: z.string().describe('Description of the destination range')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new SheetsClient({ token: ctx.auth.token });
+
+    await client.copyPaste(
+      ctx.input.spreadsheetId,
+      {
+        sheetId: ctx.input.sourceSheetId,
+        startRowIndex: ctx.input.sourceStartRowIndex,
+        endRowIndex: ctx.input.sourceEndRowIndex,
+        startColumnIndex: ctx.input.sourceStartColumnIndex,
+        endColumnIndex: ctx.input.sourceEndColumnIndex
+      },
+      {
+        sheetId: ctx.input.destinationSheetId,
+        startRowIndex: ctx.input.destinationStartRowIndex,
+        endRowIndex: ctx.input.destinationEndRowIndex,
+        startColumnIndex: ctx.input.destinationStartColumnIndex,
+        endColumnIndex: ctx.input.destinationEndColumnIndex
+      },
+      ctx.input.pasteType,
+      ctx.input.pasteOrientation
+    );
+
+    let sourceRows = ctx.input.sourceEndRowIndex - ctx.input.sourceStartRowIndex;
+    let sourceCols = ctx.input.sourceEndColumnIndex - ctx.input.sourceStartColumnIndex;
+    let destRows = ctx.input.destinationEndRowIndex - ctx.input.destinationStartRowIndex;
+    let destCols = ctx.input.destinationEndColumnIndex - ctx.input.destinationStartColumnIndex;
+
+    let output = {
+      operationPerformed: `Copied and pasted (${ctx.input.pasteType || 'PASTE_NORMAL'}${ctx.input.pasteOrientation === 'TRANSPOSE' ? ', transposed' : ''})`,
+      sourceRange: `${sourceRows} row(s) x ${sourceCols} column(s)`,
+      destinationRange: `${destRows} row(s) x ${destCols} column(s)`
+    };
+
+    return {
+      output,
+      message: `Copied **${sourceRows * sourceCols}** cells and pasted to destination.`
+    };
+  })
+  .build();

package/example/google-sheets/tools/create-spreadsheet.ts

@@ -0,0 +1,72 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { SheetsClient } from '../lib/client';
+import { spec } from '../spec';
+
+export let createSpreadsheetTool = SlateTool.create(spec, {
+  name: 'Create Spreadsheet',
+  key: 'create_spreadsheet',
+  description: `Creates a new Google Sheets spreadsheet with optional initial sheets.
+Use this to programmatically create spreadsheets with custom titles, locales, and time zones.`,
+  tags: {
+    destructive: false,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      title: z.string().describe('Title of the new spreadsheet'),
+      locale: z.string().optional().describe('Locale of the spreadsheet (e.g., "en_US")'),
+      timeZone: z
+        .string()
+        .optional()
+        .describe('Time zone of the spreadsheet (e.g., "America/New_York")'),
+      autoRecalc: z
+        .enum(['ON_CHANGE', 'MINUTE', 'HOUR'])
+        .optional()
+        .describe('When to recalculate formulas')
+    })
+  )
+  .output(
+    z.object({
+      spreadsheetId: z.string().describe('ID of the created spreadsheet'),
+      title: z.string().describe('Title of the spreadsheet'),
+      spreadsheetUrl: z.string().optional().describe('URL to open the spreadsheet'),
+      sheets: z
+        .array(
+          z.object({
+            sheetId: z.number().describe('ID of the sheet'),
+            title: z.string().describe('Title of the sheet'),
+            index: z.number().describe('Index position of the sheet')
+          })
+        )
+        .describe('Sheets in the spreadsheet')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new SheetsClient({ token: ctx.auth.token });
+
+    let result = await client.createSpreadsheet({
+      title: ctx.input.title,
+      locale: ctx.input.locale,
+      timeZone: ctx.input.timeZone,
+      autoRecalc: ctx.input.autoRecalc
+    });
+
+    let output = {
+      spreadsheetId: result.spreadsheetId,
+      title: result.properties.title,
+      spreadsheetUrl: result.spreadsheetUrl,
+      sheets: (result.sheets || []).map(sheet => ({
+        sheetId: sheet.properties.sheetId,
+        title: sheet.properties.title,
+        index: sheet.properties.index
+      }))
+    };
+
+    return {
+      output,
+      message: `Created spreadsheet **"${output.title}"** with ID \`${output.spreadsheetId}\`.`
+    };
+  })
+  .build();

package/example/google-sheets/tools/find-replace.ts

@@ -0,0 +1,68 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { SheetsClient } from '../lib/client';
+import { spec } from '../spec';
+
+export let findReplaceTool = SlateTool.create(spec, {
+  name: 'Find and Replace',
+  key: 'find_replace',
+  description: `Finds and replaces text or values in a Google Sheets spreadsheet.
+Supports case-sensitive matching, whole cell matching, regex patterns, and searching in formulas.`,
+  tags: {
+    destructive: false,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      spreadsheetId: z.string().describe('ID of the spreadsheet'),
+      find: z.string().describe('Text or pattern to find'),
+      replacement: z.string().describe('Text to replace with'),
+      matchCase: z.boolean().optional().describe('Case-sensitive search'),
+      matchEntireCell: z.boolean().optional().describe('Match entire cell content only'),
+      searchByRegex: z.boolean().optional().describe('Treat find string as regex pattern'),
+      includeFormulas: z.boolean().optional().describe('Search within formula text'),
+      sheetId: z.number().optional().describe('Limit search to specific sheet'),
+      allSheets: z.boolean().optional().describe('Search all sheets (default behavior)')
+    })
+  )
+  .output(
+    z.object({
+      valuesChanged: z.number().optional().describe('Number of values changed'),
+      formulasChanged: z.number().optional().describe('Number of formulas changed'),
+      rowsChanged: z.number().optional().describe('Number of rows affected'),
+      sheetsChanged: z.number().optional().describe('Number of sheets affected'),
+      occurrencesChanged: z.number().optional().describe('Total occurrences replaced')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new SheetsClient({ token: ctx.auth.token });
+
+    let result = await client.findReplace(
+      ctx.input.spreadsheetId,
+      ctx.input.find,
+      ctx.input.replacement,
+      {
+        matchCase: ctx.input.matchCase,
+        matchEntireCell: ctx.input.matchEntireCell,
+        searchByRegex: ctx.input.searchByRegex,
+        includeFormulas: ctx.input.includeFormulas,
+        sheetId: ctx.input.sheetId,
+        allSheets: ctx.input.allSheets
+      }
+    );
+
+    let output = {
+      valuesChanged: result.valuesChanged,
+      formulasChanged: result.formulasChanged,
+      rowsChanged: result.rowsChanged,
+      sheetsChanged: result.sheetsChanged,
+      occurrencesChanged: result.occurrencesChanged
+    };
+
+    return {
+      output,
+      message: `Replaced **${output.occurrencesChanged || 0}** occurrence(s) of "${ctx.input.find}" with "${ctx.input.replacement}".`
+    };
+  })
+  .build();

package/example/google-sheets/tools/format-cells.ts

@@ -0,0 +1,137 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { SheetsClient } from '../lib/client';
+import { spec } from '../spec';
+
+let colorSchema = z
+  .object({
+    red: z.number().min(0).max(1).optional().describe('Red component (0-1)'),
+    green: z.number().min(0).max(1).optional().describe('Green component (0-1)'),
+    blue: z.number().min(0).max(1).optional().describe('Blue component (0-1)'),
+    alpha: z.number().min(0).max(1).optional().describe('Alpha/opacity (0-1)')
+  })
+  .optional();
+
+export let formatCellsTool = SlateTool.create(spec, {
+  name: 'Format Cells',
+  key: 'format_cells',
+  description: `Applies formatting to cells in a Google Sheets spreadsheet.
+Supports text formatting (bold, italic, font, color), cell background, alignment, number formats, and borders.`,
+  instructions: [
+    'Colors use RGB values from 0 to 1 (e.g., red: 1, green: 0, blue: 0 for pure red)',
+    'Number format patterns follow Google Sheets format codes'
+  ],
+  tags: {
+    destructive: false,
+    readOnly: false
+  }
+})
+  .input(
+    z.object({
+      spreadsheetId: z.string().describe('ID of the spreadsheet'),
+      sheetId: z.number().describe('ID of the sheet containing the cells'),
+      startRowIndex: z.number().describe('Start row index (0-based)'),
+      endRowIndex: z.number().describe('End row index (exclusive)'),
+      startColumnIndex: z.number().describe('Start column index (0-based)'),
+      endColumnIndex: z.number().describe('End column index (exclusive)'),
+      backgroundColor: colorSchema.describe('Background color'),
+      textFormat: z
+        .object({
+          foregroundColor: colorSchema.describe('Text color'),
+          fontFamily: z.string().optional().describe('Font family (e.g., "Arial")'),
+          fontSize: z.number().optional().describe('Font size in points'),
+          bold: z.boolean().optional().describe('Bold text'),
+          italic: z.boolean().optional().describe('Italic text'),
+          strikethrough: z.boolean().optional().describe('Strikethrough text'),
+          underline: z.boolean().optional().describe('Underlined text')
+        })
+        .optional()
+        .describe('Text formatting'),
+      horizontalAlignment: z
+        .enum(['LEFT', 'CENTER', 'RIGHT'])
+        .optional()
+        .describe('Horizontal alignment'),
+      verticalAlignment: z
+        .enum(['TOP', 'MIDDLE', 'BOTTOM'])
+        .optional()
+        .describe('Vertical alignment'),
+      wrapStrategy: z
+        .enum(['OVERFLOW_CELL', 'CLIP', 'WRAP'])
+        .optional()
+        .describe('Text wrapping'),
+      numberFormat: z
+        .object({
+          type: z
+            .enum([
+              'TEXT',
+              'NUMBER',
+              'PERCENT',
+              'CURRENCY',
+              'DATE',
+              'TIME',
+              'DATE_TIME',
+              'SCIENTIFIC'
+            ])
+            .describe('Format type'),
+          pattern: z.string().optional().describe('Format pattern (e.g., "#,##0.00")')
+        })
+        .optional()
+        .describe('Number format')
+    })
+  )
+  .output(
+    z.object({
+      formatted: z.boolean().describe('Whether formatting was applied successfully'),
+      range: z.string().describe('Description of the formatted range')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new SheetsClient({ token: ctx.auth.token });
+
+    let format: Record<string, unknown> = {};
+
+    if (ctx.input.backgroundColor) {
+      format.backgroundColor = ctx.input.backgroundColor;
+    }
+    if (ctx.input.textFormat) {
+      format.textFormat = ctx.input.textFormat;
+    }
+    if (ctx.input.horizontalAlignment) {
+      format.horizontalAlignment = ctx.input.horizontalAlignment;
+    }
+    if (ctx.input.verticalAlignment) {
+      format.verticalAlignment = ctx.input.verticalAlignment;
+    }
+    if (ctx.input.wrapStrategy) {
+      format.wrapStrategy = ctx.input.wrapStrategy;
+    }
+    if (ctx.input.numberFormat) {
+      format.numberFormat = ctx.input.numberFormat;
+    }
+
+    await client.formatCells(
+      ctx.input.spreadsheetId,
+      {
+        sheetId: ctx.input.sheetId,
+        startRowIndex: ctx.input.startRowIndex,
+        endRowIndex: ctx.input.endRowIndex,
+        startColumnIndex: ctx.input.startColumnIndex,
+        endColumnIndex: ctx.input.endColumnIndex
+      },
+      format
+    );
+
+    let rowCount = ctx.input.endRowIndex - ctx.input.startRowIndex;
+    let colCount = ctx.input.endColumnIndex - ctx.input.startColumnIndex;
+
+    let output = {
+      formatted: true,
+      range: `${rowCount} row(s) x ${colCount} column(s) starting at row ${ctx.input.startRowIndex}, column ${ctx.input.startColumnIndex}`
+    };
+
+    return {
+      output,
+      message: `Applied formatting to **${rowCount * colCount}** cells.`
+    };
+  })
+  .build();

package/example/google-sheets/tools/get-spreadsheet.ts

@@ -0,0 +1,108 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { SheetsClient } from '../lib/client';
+import { spec } from '../spec';
+
+export let getSpreadsheetTool = SlateTool.create(spec, {
+  name: 'Get Spreadsheet',
+  key: 'get_spreadsheet',
+  description: `Retrieves metadata and structure of a Google Sheets spreadsheet.
+Returns spreadsheet properties, sheet list, and named ranges. Optionally include cell data for specific ranges.`,
+  tags: {
+    destructive: false,
+    readOnly: true
+  }
+})
+  .input(
+    z.object({
+      spreadsheetId: z.string().describe('ID of the spreadsheet to retrieve'),
+      ranges: z
+        .array(z.string())
+        .optional()
+        .describe('Optional ranges to include grid data for (e.g., ["Sheet1!A1:B10"])'),
+      includeGridData: z
+        .boolean()
+        .optional()
+        .describe('Include cell data for specified ranges')
+    })
+  )
+  .output(
+    z.object({
+      spreadsheetId: z.string().describe('ID of the spreadsheet'),
+      title: z.string().describe('Title of the spreadsheet'),
+      locale: z.string().optional().describe('Locale of the spreadsheet'),
+      timeZone: z.string().optional().describe('Time zone of the spreadsheet'),
+      spreadsheetUrl: z.string().optional().describe('URL to open the spreadsheet'),
+      sheets: z
+        .array(
+          z.object({
+            sheetId: z.number().describe('ID of the sheet'),
+            title: z.string().describe('Title of the sheet'),
+            index: z.number().describe('Index position of the sheet'),
+            sheetType: z.string().optional().describe('Type of the sheet'),
+            rowCount: z.number().optional().describe('Number of rows'),
+            columnCount: z.number().optional().describe('Number of columns'),
+            frozenRowCount: z.number().optional().describe('Number of frozen rows'),
+            frozenColumnCount: z.number().optional().describe('Number of frozen columns'),
+            hidden: z.boolean().optional().describe('Whether the sheet is hidden')
+          })
+        )
+        .describe('Sheets in the spreadsheet'),
+      namedRanges: z
+        .array(
+          z.object({
+            namedRangeId: z.string().optional().describe('ID of the named range'),
+            name: z.string().optional().describe('Name of the range'),
+            sheetId: z.number().optional().describe('Sheet containing the range'),
+            startRowIndex: z.number().optional().describe('Start row (0-indexed)'),
+            endRowIndex: z.number().optional().describe('End row (exclusive)'),
+            startColumnIndex: z.number().optional().describe('Start column (0-indexed)'),
+            endColumnIndex: z.number().optional().describe('End column (exclusive)')
+          })
+        )
+        .optional()
+        .describe('Named ranges in the spreadsheet')
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = new SheetsClient({ token: ctx.auth.token });
+
+    let result = await client.getSpreadsheet(ctx.input.spreadsheetId, {
+      ranges: ctx.input.ranges,
+      includeGridData: ctx.input.includeGridData
+    });
+
+    let output = {
+      spreadsheetId: result.spreadsheetId,
+      title: result.properties.title,
+      locale: result.properties.locale,
+      timeZone: result.properties.timeZone,
+      spreadsheetUrl: result.spreadsheetUrl,
+      sheets: (result.sheets || []).map(sheet => ({
+        sheetId: sheet.properties.sheetId,
+        title: sheet.properties.title,
+        index: sheet.properties.index,
+        sheetType: sheet.properties.sheetType,
+        rowCount: sheet.properties.gridProperties?.rowCount,
+        columnCount: sheet.properties.gridProperties?.columnCount,
+        frozenRowCount: sheet.properties.gridProperties?.frozenRowCount,
+        frozenColumnCount: sheet.properties.gridProperties?.frozenColumnCount,
+        hidden: sheet.properties.hidden
+      })),
+      namedRanges: result.namedRanges?.map(nr => ({
+        namedRangeId: nr.namedRangeId,
+        name: nr.name,
+        sheetId: nr.range?.sheetId,
+        startRowIndex: nr.range?.startRowIndex,
+        endRowIndex: nr.range?.endRowIndex,
+        startColumnIndex: nr.range?.startColumnIndex,
+        endColumnIndex: nr.range?.endColumnIndex
+      }))
+    };
+
+    return {
+      output,
+      message: `Retrieved spreadsheet **"${output.title}"** with ${output.sheets.length} sheet(s).`
+    };
+  })
+  .build();

package/example/google-sheets/tools/index.ts

@@ -0,0 +1,15 @@
+export * from './append-values';
+export * from './clear-values';
+export * from './copy-paste';
+export * from './create-spreadsheet';
+export * from './find-replace';
+export * from './format-cells';
+export * from './get-spreadsheet';
+export * from './manage-rows-columns';
+export * from './manage-sheets';
+export * from './merge-cells';
+export * from './named-ranges';
+export * from './protect-range';
+export * from './read-values';
+export * from './sort-range';
+export * from './write-values';