universal-mcp-applications 0.1.17__py3-none-any.whl → 0.1.33__py3-none-any.whl

universal_mcp/applications/google_sheet/app.py

@@ -3,7 +3,7 @@ from typing import Any
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
-from .helper import (
+from universal_mcp.applications.google_sheet.helper import (
     analyze_sheet_for_tables,
     analyze_table_schema,
 )
@@ -21,45 +21,49 @@ class GoogleSheetApp(APIApplication):
 
     def create_spreadsheet(self, title: str) -> dict[str, Any]:
         """
-        Creates a new, blank Google Spreadsheet file with a specified title. This function generates a completely new document, unlike `add_sheet` which adds a tab to an existing spreadsheet. It returns the API response containing the new spreadsheet's metadata.
-        
+        Creates a new, blank Google Spreadsheet file with a specified title. This function generates a completely new document, unlike `add_sheet` which adds a worksheet (tab) to an existing spreadsheet. It returns the API response containing the new spreadsheet's metadata. Note that you need to call other google_sheet functions (e.g. `google_sheet__write_values_to_sheet`) to actually add content after creating the spreadsheet.
+
         Args:
             title: String representing the desired title for the new spreadsheet
-        
+
         Returns:
             Dictionary containing the full response from the Google Sheets API, including the spreadsheet's metadata and properties
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid authentication, network issues, or API limitations
             ValueError: When the title parameter is empty or contains invalid characters
-        
+
         Tags:
             create, spreadsheet, google-sheets, api, important
         """
         url = self.base_url
         spreadsheet_data = {"properties": {"title": title}}
         response = self._post(url, data=spreadsheet_data)
-        return self._handle_response(response)
+        payload = self._handle_response(response)
+        payload["Note"] = (
+            "You must load and call other google_sheet content functions (like `google_sheet__write_values_to_sheet`)"
+        )
+        return payload
 
-    def get_spreadsheet_metadata(self, spreadsheet_id: str) -> dict[str, Any]:
+    def get_spreadsheet_metadata(self, spreadsheetId: str) -> dict[str, Any]:
         """
-        Retrieves a spreadsheet's metadata and structural properties, such as sheet names, IDs, and named ranges, using its unique ID. This function intentionally excludes cell data, distinguishing it from `get_values` which fetches the actual content within the cells.
-        
+        Retrieves a spreadsheet's metadata and structural properties, such as sheet names, IDs, and named ranges, using its unique ID. This function intentionally excludes cell data, distinguishing it from `get_values` which fetches the actual content within cells.
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Spreadsheet to retrieve (found in the spreadsheet's URL)
-        
+            spreadsheetId: The unique identifier of the Google Spreadsheet to retrieve (found in the spreadsheet's URL)
+
         Returns:
             A dictionary containing the full spreadsheet metadata and contents, including properties, sheets, named ranges, and other spreadsheet-specific information from the Google Sheets API
-        
+
         Raises:
-            HTTPError: When the API request fails due to invalid spreadsheet_id or insufficient permissions
+            HTTPError: When the API request fails due to invalid spreadsheetId or insufficient permissions
             ConnectionError: When there's a network connectivity issue
             ValueError: When the response cannot be parsed as JSON
-        
+
         Tags:
             get, retrieve, spreadsheet, api, metadata, read, important
         """
-        url = f"{self.base_url}/{spreadsheet_id}"
+        url = f"{self.base_url}/{spreadsheetId}"
         response = self._get(url)
         return self._handle_response(response)
 
@@ -72,22 +76,22 @@ class GoogleSheetApp(APIApplication):
         dateTimeRenderOption: str | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves cell values from a single, specified A1 notation range in a Google Spreadsheet. Unlike `batch_get_values` which fetches multiple ranges, this function is for a singular query and provides options to control the data's output format (e.g., rows vs. columns, formatted vs. raw values).
-        
+        Retrieves cell values from a single, specified A1 notation range. Unlike `batch_get_values_by_range` which fetches multiple ranges, this function is for a singular query and provides options to control the data's output format (e.g., rows vs. columns, formatted vs. raw values).
+
         Args:
             spreadsheetId: The unique identifier of the Google Spreadsheet to retrieve values from
             range: A1 notation range string (e.g., 'Sheet1!A1:B2')
             majorDimension: The major dimension that results should use. "ROWS" or "COLUMNS". Example: "ROWS"
             valueRenderOption: How values should be represented in the output. "FORMATTED_VALUE", "UNFORMATTED_VALUE", or "FORMULA". Example: "FORMATTED_VALUE"
             dateTimeRenderOption: How dates, times, and durations should be represented. "SERIAL_NUMBER" or "FORMATTED_STRING". Example: "FORMATTED_STRING"
-        
+
         Returns:
             A dictionary containing the API response with the requested spreadsheet values and metadata
-        
+
         Raises:
-            HTTPError: If the API request fails due to invalid spreadsheet_id, insufficient permissions, or invalid range format
-            ValueError: If the spreadsheet_id is empty or invalid
-        
+            HTTPError: If the API request fails due to invalid spreadsheetId, insufficient permissions, or invalid range format
+            ValueError: If the spreadsheetId is empty or invalid
+
         Tags:
             get, read, spreadsheet, values, important
         """
@@ -105,26 +109,26 @@ class GoogleSheetApp(APIApplication):
         return self._handle_response(response)
 
     def batch_get_values_by_range(
-        self, spreadsheet_id: str, ranges: list[str] | None = None
+        self, spreadsheetId: str, ranges: list[str] | None = None
     ) -> dict[str, Any]:
         """
-        Efficiently retrieves values from multiple specified ranges in a Google Spreadsheet using a single batch API request. This method is distinct from `get_values`, which fetches a single range, and `batch_get_values_by_data_filter`, which uses filtering criteria instead of predefined A1 notation ranges.
-        
+        Efficiently retrieves values from multiple predefined A1 notation ranges in a single API request. Unlike `get_values`, which fetches a single range, or `batch_get_values_by_data_filter`, which uses dynamic filtering criteria, this function operates on a simple list of range strings for bulk data retrieval.
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Spreadsheet to retrieve values from
+            spreadsheetId: The unique identifier of the Google Spreadsheet to retrieve values from
             ranges: Optional list of A1 notation or R1C1 notation range strings (e.g., ['Sheet1!A1:B2', 'Sheet2!C3:D4']). If None, returns values from the entire spreadsheet
-        
+
         Returns:
             A dictionary containing the API response with the requested spreadsheet values and metadata
-        
+
         Raises:
-            HTTPError: If the API request fails due to invalid spreadsheet_id, insufficient permissions, or invalid range format
-            ValueError: If the spreadsheet_id is empty or invalid
-        
+            HTTPError: If the API request fails due to invalid spreadsheetId, insufficient permissions, or invalid range format
+            ValueError: If the spreadsheetId is empty or invalid
+
         Tags:
             get, batch, read, spreadsheet, values
         """
-        url = f"{self.base_url}/{spreadsheet_id}/values:batchGet"
+        url = f"{self.base_url}/{spreadsheetId}/values:batchGet"
         params = {}
         if ranges:
             params["ranges"] = ranges
@@ -133,7 +137,7 @@ class GoogleSheetApp(APIApplication):
 
     def insert_dimensions(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         sheet_id: int,
         dimension: str,
         start_index: int,
@@ -144,13 +148,13 @@ class GoogleSheetApp(APIApplication):
         response_ranges: list[str] | None = None,
     ) -> dict[str, Any]:
         """
-        Inserts empty rows or columns at a specified index, shifting existing content. Unlike `append_dimensions`, which adds to the end, this function is used to insert space within the data grid. Returns the API response containing update details.
-        
+        Inserts a specified number of empty rows or columns at a given index, shifting existing content. Distinct from `append_dimensions`, which only adds to the end, this function creates space within the sheet's data grid, preserving surrounding data and formatting.
+
         This function inserts empty rows or columns at a specified location, shifting existing content.
         Use this when you need to add rows/columns in the middle of your data.
-        
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet to update. Example: "abc123spreadsheetId"
+            spreadsheetId: The ID of the spreadsheet to update. Example: "abc123spreadsheetId"
             sheet_id: The ID of the sheet where the dimensions will be inserted. Example: 0
             dimension: The dimension to insert. Valid values are "ROWS" or "COLUMNS". Example: "ROWS"
             start_index: The start index (0-based) of the dimension range to insert. The inserted dimensions will be placed before this index. Example: 1
@@ -159,19 +163,19 @@ class GoogleSheetApp(APIApplication):
             include_spreadsheet_in_response: True if the updated spreadsheet should be included in the response. Example: True
             response_include_grid_data: True if grid data should be included in the response (if includeSpreadsheetInResponse is true). Example: True
             response_ranges: Limits the ranges of the spreadsheet to include in the response. Example: ["Sheet1!A1:B10"]
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with update details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or dimension is not "ROWS" or "COLUMNS"
-        
+            ValueError: When spreadsheetId is empty or dimension is not "ROWS" or "COLUMNS"
+
         Tags:
             insert, modify, spreadsheet, rows, columns, dimensions, important
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if dimension not in ["ROWS", "COLUMNS"]:
             raise ValueError('dimension must be either "ROWS" or "COLUMNS"')
@@ -182,7 +186,7 @@ class GoogleSheetApp(APIApplication):
         if start_index >= end_index:
             raise ValueError("end_index must be greater than start_index")
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         request_body: dict[str, Any] = {
             "requests": [
@@ -217,35 +221,35 @@ class GoogleSheetApp(APIApplication):
 
     def append_dimensions(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         sheet_id: int,
         dimension: str,
         length: int,
     ) -> dict[str, Any]:
         """
-        Adds a specified number of empty rows or columns to the end of a designated sheet. Unlike `insert_dimensions`, which adds dimensions at a specific index, this function exclusively extends the sheet's boundaries at the bottom or to the right without affecting existing content.
-        
+        Adds a specified number of empty rows or columns to the end of a designated sheet. Unlike `insert_dimensions`, which adds space at a specific index, this function exclusively extends the sheet's boundaries at the bottom or to the right without affecting existing content.
+
         This function adds empty rows or columns to the end of the sheet without affecting existing content.
         Use this when you need to extend the sheet with additional space at the bottom or right.
-        
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
+            spreadsheetId: The unique identifier of the Google Spreadsheet to modify
             sheet_id: The ID of the sheet within the spreadsheet (0 for first sheet)
             dimension: The type of dimension to append - "ROWS" or "COLUMNS"
             length: The number of rows or columns to append to the end
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with update details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty, dimension is not "ROWS" or "COLUMNS", or length is not positive
-        
+            ValueError: When spreadsheetId is empty, dimension is not "ROWS" or "COLUMNS", or length is not positive
+
         Tags:
             append, modify, spreadsheet, rows, columns, dimensions, important
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if dimension not in ["ROWS", "COLUMNS"]:
             raise ValueError('dimension must be either "ROWS" or "COLUMNS"')
@@ -253,7 +257,7 @@ class GoogleSheetApp(APIApplication):
         if length <= 0:
             raise ValueError("length must be a positive integer")
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         request_body = {
             "requests": [
@@ -272,7 +276,7 @@ class GoogleSheetApp(APIApplication):
 
     def delete_dimensions(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         sheet_id: int,
         dimension: str,
         start_index: int,
@@ -282,10 +286,10 @@ class GoogleSheetApp(APIApplication):
         response_ranges: list[str] | None = None,
     ) -> dict[str, Any]:
         """
-        Deletes a specified range of rows or columns from a sheet, permanently removing them and shifting subsequent cells. This alters the sheet's structure, unlike `clear_values` which only removes cell content. It complements `insert_dimensions` and `append_dimensions` for structural modifications.
-        
+        Deletes a specified range of rows or columns, permanently removing them and shifting subsequent cells. This alters the sheet's structure, unlike `clear_values` which only removes cell content. It is the direct counterpart to `insert_dimensions`, which adds space within the data grid.
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet. Example: "abc123xyz789"
+            spreadsheetId: The ID of the spreadsheet. Example: "abc123xyz789"
             sheet_id: The ID of the sheet from which to delete the dimension. Example: 0 for first sheet
             dimension: The dimension to delete. Example: "ROWS"
             start_index: The zero-based start index of the range to delete, inclusive. The start index must be less than the end index. Example: 0
@@ -293,19 +297,19 @@ class GoogleSheetApp(APIApplication):
             include_spreadsheet_in_response: Determines if the update response should include the spreadsheet resource. Example: True
             response_include_grid_data: True if grid data should be returned. This parameter is ignored if a field mask was set in the request. Example: True
             response_ranges: Limits the ranges of cells included in the response spreadsheet. Example: ["Sheet1!A1:B2", "Sheet2!C:C"]
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with update details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty, dimension is not "ROWS" or "COLUMNS", or indices are invalid
-        
+            ValueError: When spreadsheetId is empty, dimension is not "ROWS" or "COLUMNS", or indices are invalid
+
         Tags:
             delete, modify, spreadsheet, rows, columns, dimensions, important
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if dimension not in ["ROWS", "COLUMNS"]:
             raise ValueError('dimension must be either "ROWS" or "COLUMNS"')
@@ -316,7 +320,7 @@ class GoogleSheetApp(APIApplication):
         if start_index >= end_index:
             raise ValueError("end_index must be greater than start_index")
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         request_body: dict[str, Any] = {
             "requests": [
@@ -371,8 +375,8 @@ class GoogleSheetApp(APIApplication):
         responseIncludeGridData: bool = False,
     ) -> dict[str, Any]:
         """
-        Adds a new worksheet (tab) to an existing Google Spreadsheet. Allows customization of the new sheet's properties, including its title, index position, size (rows/columns), and visibility. This differs from `create_spreadsheet`, which creates a new spreadsheet file entirely.
-        
+        Adds a new worksheet (tab) to an existing Google Spreadsheet. It allows extensive customization of the new sheet's properties, such as its title, position, and dimensions. This is distinct from `create_spreadsheet`, which generates a completely new spreadsheet file instead of modifying an existing one.
+
         Args:
             spreadsheetId: The ID of the spreadsheet to add the sheet to. This is the long string of characters in the URL of your Google Sheet. Example: "abc123xyz789"
             title: The name of the sheet. Example: "Q3 Report"
@@ -391,14 +395,14 @@ class GoogleSheetApp(APIApplication):
             columnGroupControlAfter: True if the column group control toggle is shown after the group, false if before.
             includeSpreadsheetInResponse: Whether the response should include the entire spreadsheet resource. Defaults to false.
             responseIncludeGridData: True if grid data should be returned. This parameter is ignored if includeSpreadsheetInResponse is false. Defaults to false.
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with the new sheet details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or invalid parameters are provided
-        
+            ValueError: When spreadsheetId is empty or invalid parameters are provided
+
         Tags:
             add, sheet, spreadsheet, create
         """
@@ -479,7 +483,7 @@ class GoogleSheetApp(APIApplication):
 
     def add_basic_chart(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         source_sheet_id: int,
         chart_title: str,
         chart_type: str,
@@ -492,12 +496,12 @@ class GoogleSheetApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Adds various axis-based charts (e.g., column, bar, line, area) to a spreadsheet from specified data ranges. The chart can be placed on a new sheet or positioned on an existing one. This is distinct from `add_pie_chart`, which creates proportional visualizations instead of axis-based charts.
-        
+
         This function creates various types of charts from the specified data ranges and places it in a new sheet or existing sheet.
         Use this when you need to visualize data in different chart formats.
-        
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
+            spreadsheetId: The unique identifier of the Google Spreadsheet to modify
             source_sheet_id: The ID of the sheet containing the source data
             chart_title: The title for the chart
             chart_type: The type of chart to create. Supported types: "COLUMN", "BAR", "LINE", "AREA", "STEPPED_AREA", "SCATTER", "COMBO"
@@ -507,24 +511,24 @@ class GoogleSheetApp(APIApplication):
             chart_position: Optional positioning for chart when new_sheet=False. Example: {"overlayPosition": {"anchorCell": {"sheetId": 0, "rowIndex": 10, "columnIndex": 5}, "offsetXPixels": 0, "offsetYPixels": 0, "widthPixels": 600, "heightPixels": 400}}
             x_axis_title: Optional title for the X-axis (bottom axis). If not provided, defaults to "Categories"
             y_axis_title: Optional title for the Y-axis (left axis). If not provided, defaults to "Values"
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with the chart details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or invalid parameters are provided
-        
+            ValueError: When spreadsheetId is empty or invalid parameters are provided
+
         Tags:
             add, chart, basic-chart, visualization
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not chart_title:
             raise ValueError("chart_title cannot be empty")
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         # Build the chart specification
         chart_spec = {
@@ -628,7 +632,7 @@ class GoogleSheetApp(APIApplication):
 
     def add_pie_chart(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         source_sheet_id: int,
         chart_title: str,
         data_range: dict,
@@ -638,13 +642,13 @@ class GoogleSheetApp(APIApplication):
         pie_hole: float | None = None,
     ) -> dict[str, Any]:
         """
-        Adds a pie or donut chart to a Google Spreadsheet from a specified data range. Unlike the more general `add_basic_chart`, this function is specialized for visualizing data as proportions of a whole and supports pie-specific options like creating a donut chart via the `pie_hole` parameter.
-        
+        Adds a pie or donut chart to a Google Spreadsheet from a specified data range. Unlike the more general `add_basic_chart`, this is specialized for visualizing data as proportions of a whole and supports pie-specific options like creating a donut chart via the `pie_hole` parameter.
+
         This function creates a pie chart from the specified data range and places it in a new sheet or existing sheet.
         Use this when you need to visualize data as proportions of a whole.
-        
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
+            spreadsheetId: The unique identifier of the Google Spreadsheet to modify
             source_sheet_id: The ID of the sheet containing the source data
             chart_title: The title for the chart
             data_range: Dictionary containing data range info (e.g., {"startRowIndex": 0, "endRowIndex": 7, "startColumnIndex": 0, "endColumnIndex": 2})
@@ -652,19 +656,19 @@ class GoogleSheetApp(APIApplication):
             chart_position: Optional positioning for chart when new_sheet=False. Example: {"overlayPosition": {"anchorCell": {"sheetId": 0, "rowIndex": 10, "columnIndex": 5}, "offsetXPixels": 0, "offsetYPixels": 0, "widthPixels": 600, "heightPixels": 400}}
             legend_position: Position of the legend. Options: "BOTTOM_LEGEND", "LEFT_LEGEND", "RIGHT_LEGEND", "TOP_LEGEND", "NO_LEGEND"
             pie_hole: Optional hole size for creating a donut chart (0.0 to 1.0). 0.0 = solid pie, 0.5 = 50% hole
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with the chart details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or invalid parameters are provided
-        
+            ValueError: When spreadsheetId is empty or invalid parameters are provided
+
         Tags:
             add, chart, pie, visualization
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not chart_title:
             raise ValueError("chart_title cannot be empty")
@@ -672,7 +676,7 @@ class GoogleSheetApp(APIApplication):
         if pie_hole is not None and not 0 <= pie_hole <= 1:
             raise ValueError("pie_hole must be between 0.0 and 1.0")
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         # Build the pie chart specification
         pie_chart_spec = {
@@ -747,7 +751,7 @@ class GoogleSheetApp(APIApplication):
 
     def add_table(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         sheet_id: int,
         table_name: str,
         table_id: str,
@@ -759,12 +763,12 @@ class GoogleSheetApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Creates a structured table within a specified range on a Google Sheet. Defines the table's name, ID, and dimensions, and can optionally configure column properties like data types and validation rules. This action creates a formal table object, distinct from functions that only write cell values.
-        
+
         This function creates a table with specified properties and column types.
         Use this when you need to create structured data with headers, footers, and column types.
-        
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
+            spreadsheetId: The unique identifier of the Google Spreadsheet to modify
             sheet_id: The ID of the sheet where the table will be created
             table_name: The name of the table
             table_id: The unique identifier for the table
@@ -775,16 +779,16 @@ class GoogleSheetApp(APIApplication):
             column_properties: Optional list of column properties with types and validation rules. Valid column types: "TEXT", "PERCENT", "DROPDOWN", "DOUBLE", "CURRENCY", "DATE", "TIME", "DATE_TIME". Example: [{"columnIndex": 0, "columnName": "Model Number", "columnType": "TEXT"}, {"columnIndex": 1, "columnName": "Sales - Jan", "columnType": "DOUBLE"}, {"columnIndex": 2, "columnName": "Price", "columnType": "CURRENCY"}, {"columnIndex": 3, "columnName": "Progress", "columnType": "PERCENT"}, {"columnIndex": 4, "columnName": "Created Date", "columnType": "DATE"}, {"columnIndex": 5, "columnName": "Status", "columnType": "DROPDOWN", "dataValidationRule": {"condition": {"type": "ONE_OF_LIST", "values": [{"userEnteredValue": "Active"}, {"userEnteredValue": "Inactive"}]}}}]
         Returns:
             A dictionary containing the Google Sheets API response with the table details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or invalid parameters are provided
-        
+            ValueError: When spreadsheetId is empty or invalid parameters are provided
+
         Tags:
             add, table, structured-data
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not table_name:
             raise ValueError("table_name cannot be empty")
@@ -827,7 +831,7 @@ class GoogleSheetApp(APIApplication):
                         f"Invalid column type '{prop['columnType']}' at index {i}. Valid types are: {', '.join(valid_column_types)}"
                     )
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         # Build the table specification
         table_spec = {
@@ -854,7 +858,7 @@ class GoogleSheetApp(APIApplication):
 
     def update_table(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         table_id: str,
         table_name: str | None = None,
         start_row_index: int | None = None,
@@ -865,12 +869,12 @@ class GoogleSheetApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Modifies properties of an existing table within a Google Sheet, such as its name, data range, or column specifications. This function updates the table's structural metadata, distinguishing it from `update_values` which alters the cell data within the table's range.
-        
+
         This function modifies table properties such as name, range, and column properties.
         Use this when you need to modify an existing table's structure or properties.
-        
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
+            spreadsheetId: The unique identifier of the Google Spreadsheet to modify
             table_id: The unique identifier of the table to update
             table_name: Optional new name for the table
             start_row_index: Optional new starting row index (0-based)
@@ -878,19 +882,19 @@ class GoogleSheetApp(APIApplication):
             start_column_index: Optional new starting column index (0-based)
             end_column_index: Optional new ending column index (exclusive)
             column_properties: Optional list of column properties with types and validation rules. Valid column types: "TEXT", "PERCENT", "DROPDOWN", "DOUBLE", "CURRENCY", "DATE", "TIME", "DATE_TIME". Example: [{"columnIndex": 0, "columnName": "Model Number", "columnType": "TEXT"}, {"columnIndex": 1, "columnName": "Sales - Jan", "columnType": "DOUBLE"}, {"columnIndex": 2, "columnName": "Price", "columnType": "CURRENCY"}, {"columnIndex": 3, "columnName": "Progress", "columnType": "PERCENT"}, {"columnIndex": 4, "columnName": "Created Date", "columnType": "DATE"}, {"columnIndex": 5, "columnName": "Status", "columnType": "DROPDOWN", "dataValidationRule": {"condition": {"type": "ONE_OF_LIST", "values": [{"userEnteredValue": "Active"}, {"userEnteredValue": "Inactive"}]}}}]
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with the updated table details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id or table_id is empty or invalid parameters are provided
-        
+            ValueError: When spreadsheetId or table_id is empty or invalid parameters are provided
+
         Tags:
             update, table, modify, structured-data
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not table_id:
             raise ValueError("table_id cannot be empty")
@@ -943,7 +947,7 @@ class GoogleSheetApp(APIApplication):
                         f"Invalid column type '{prop['columnType']}' at index {i}. Valid types are: {', '.join(valid_column_types)}"
                     )
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         # Build the table specification and track fields to update
         table_spec: dict[str, Any] = {"tableId": table_id}
@@ -995,55 +999,55 @@ class GoogleSheetApp(APIApplication):
         response = self._post(url, data=request_body)
         return self._handle_response(response)
 
-    def clear_values(self, spreadsheet_id: str, range: str) -> dict[str, Any]:
+    def clear_values(self, spreadsheetId: str, range: str) -> dict[str, Any]:
         """
-        Clears data from a single, specified cell range in a Google Sheet while preserving all formatting. Unlike `delete_dimensions`, it only removes content, not the cells themselves. For clearing multiple ranges simultaneously, use the `batch_clear_values` function.
-        
+        Clears data from a single, specified cell range while preserving all formatting. Unlike `delete_dimensions`, it only removes content, not the cells themselves. For clearing multiple ranges simultaneously, use the `batch_clear_values` function.
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
+            spreadsheetId: The unique identifier of the Google Spreadsheet to modify
             range: The A1 or R1C1 notation range of cells to clear (e.g., 'Sheet1!A1:B2')
-        
+
         Returns:
             A dictionary containing the Google Sheets API response
-        
+
         Raises:
-            HttpError: When the API request fails due to invalid spreadsheet_id, invalid range format, or insufficient permissions
-            ValueError: When spreadsheet_id is empty or range is in invalid format
-        
+            HttpError: When the API request fails due to invalid spreadsheetId, invalid range format, or insufficient permissions
+            ValueError: When spreadsheetId is empty or range is in invalid format
+
         Tags:
             clear, modify, spreadsheet, api, sheets, data-management, important
         """
-        url = f"{self.base_url}/{spreadsheet_id}/values/{range}:clear"
+        url = f"{self.base_url}/{spreadsheetId}/values/{range}:clear"
         response = self._post(url, data={})
         return self._handle_response(response)
 
     def update_values(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         range: str,
         values: list[list[Any]],
         value_input_option: str = "RAW",
     ) -> dict[str, Any]:
         """
-        Overwrites cell values within a specific A1 notation range in a Google Spreadsheet. This function replaces existing data with the provided values, differing from `append_values` which adds new rows. It provides a direct method for targeted data replacement in a predefined area of the sheet.
-        
+        Overwrites cell values within a specific A1 notation range using a provided 2D list. This function replaces existing data in a predefined area, distinguishing it from `append_values`, which adds new rows after a table instead of overwriting a specific block of cells.
+
         Args:
-            spreadsheet_id: The unique identifier of the target Google Spreadsheet
+            spreadsheetId: The unique identifier of the target Google Spreadsheet
             range: The A1 notation range where values will be updated (e.g., 'Sheet1!A1:B2')
             values: A list of lists containing the data to write, where each inner list represents a row of values
             value_input_option: Determines how input data should be interpreted: 'RAW' (as-is) or 'USER_ENTERED' (parsed as UI input). Defaults to 'RAW'
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with update details
-        
+
         Raises:
             RequestError: When the API request fails due to invalid parameters or network issues
             AuthenticationError: When authentication with the Google Sheets API fails
-        
+
         Tags:
             update, write, sheets, api, important, data-modification, google-sheets
         """
-        url = f"{self.base_url}/{spreadsheet_id}/values/{range}"
+        url = f"{self.base_url}/{spreadsheetId}/values/{range}"
         params = {"valueInputOption": value_input_option}
         data = {"range": range, "values": values}
         response = self._put(url, data=data, params=params)
@@ -1051,33 +1055,33 @@ class GoogleSheetApp(APIApplication):
 
     def batch_clear_values(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         ranges: list[str],
     ) -> dict[str, Any]:
         """
         Clears cell values from multiple specified ranges in a single batch operation, preserving existing formatting. Unlike `clear_values`, which handles a single range, this method efficiently processes a list of ranges at once, removing only the content and not the cells themselves.
-        
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet to update. Example: "1q2w3e4r5t6y7u8i9o0p"
+            spreadsheetId: The ID of the spreadsheet to update. Example: "1q2w3e4r5t6y7u8i9o0p"
             ranges: The ranges to clear, in A1 notation or R1C1 notation. Example: ["Sheet1!A1:B2", "Sheet1!C3:D4"]
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with clear details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or ranges is empty
-        
+            ValueError: When spreadsheetId is empty or ranges is empty
+
         Tags:
             clear, batch, values, spreadsheet
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not ranges or not isinstance(ranges, list) or len(ranges) == 0:
             raise ValueError("ranges must be a non-empty list")
 
-        url = f"{self.base_url}/{spreadsheet_id}/values:batchClear"
+        url = f"{self.base_url}/{spreadsheetId}/values:batchClear"
 
         request_body = {"ranges": ranges}
 
@@ -1086,36 +1090,36 @@ class GoogleSheetApp(APIApplication):
 
     def batch_get_values_by_data_filter(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         data_filters: list[dict],
         major_dimension: str | None = None,
         value_render_option: str | None = None,
         date_time_render_option: str | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves values from spreadsheet ranges matching a list of data filters. This method provides dynamic, criteria-based selection using A1 notation or grid coordinates, unlike `batch_get_values` which uses a simple list of range strings. It is ideal for fetching multiple, specific datasets in one request.
-        
+        Retrieves values from spreadsheet ranges matching a list of data filters. This method provides dynamic, criteria-based selection using A1 notation or grid coordinates, unlike `batch_get_values_by_range` which uses a simple list of range strings. It is ideal for fetching multiple, specific datasets in one request.
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet to retrieve data from. Example: "1q2w3e4r5t6y7u8i9o0p"
+            spreadsheetId: The ID of the spreadsheet to retrieve data from. Example: "1q2w3e4r5t6y7u8i9o0p"
             data_filters: The data filters used to match the ranges of values to retrieve. Ranges that match any of the specified data filters are included in the response. Each filter can contain:
                 - a1Range: Selects data that matches the specified A1 range. Example: "Sheet1!A1:B5"
                 - gridRange: Selects data that matches the specified grid range. Example: {"sheetId": 0, "startRowIndex": 0, "endRowIndex": 5, "startColumnIndex": 0, "endColumnIndex": 2}
             major_dimension: The major dimension that results should use. For example, if the spreadsheet data is: A1=1,B1=2,A2=3,B2=4, then a request that selects that range and sets majorDimension=ROWS returns [[1,2],[3,4]], whereas a request that sets majorDimension=COLUMNS returns [[1,3],[2,4]]. Options: "ROWS" or "COLUMNS". Example: "ROWS"
             value_render_option: How values should be represented in the output. The default render option is FORMATTED_VALUE. Options: "FORMATTED_VALUE", "UNFORMATTED_VALUE", or "FORMULA". Example: "FORMATTED_VALUE"
             date_time_render_option: How dates, times, and durations should be represented in the output. This is ignored if valueRenderOption is FORMATTED_VALUE. The default dateTime render option is SERIAL_NUMBER. Options: "SERIAL_NUMBER" or "FORMATTED_STRING". Example: "SERIAL_NUMBER"
-        
+
         Returns:
             A dictionary containing the filtered values that match the specified data filters
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or data_filters is empty
-        
+            ValueError: When spreadsheetId is empty or data_filters is empty
+
         Tags:
             get, batch, data-filter, values, spreadsheet
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if (
             not data_filters
@@ -1144,7 +1148,7 @@ class GoogleSheetApp(APIApplication):
                 'date_time_render_option must be either "SERIAL_NUMBER" or "FORMATTED_STRING"'
             )
 
-        url = f"{self.base_url}/{spreadsheet_id}/values:batchGetByDataFilter"
+        url = f"{self.base_url}/{spreadsheetId}/values:batchGetByDataFilter"
 
         request_body: dict[str, Any] = {"dataFilters": data_filters}
 
@@ -1163,48 +1167,48 @@ class GoogleSheetApp(APIApplication):
 
     def copy_sheet_to_spreadsheet(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         sheet_id: int,
-        destination_spreadsheet_id: str,
+        destination_spreadsheetId: str,
     ) -> dict[str, Any]:
         """
-        Copies a specific sheet, including all its data and formatting, from a source spreadsheet to a different destination spreadsheet. This action duplicates an entire worksheet into another workbook, returning the properties of the newly created sheet in the API response.
-        
-        
+        Copies a specific sheet, including all its data and formatting, from a source spreadsheet to a different destination spreadsheet. This action duplicates an entire worksheet into another workbook, returning properties of the newly created sheet.
+
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet containing the sheet to copy. Example: "1qZ_..."
+            spreadsheetId: The ID of the spreadsheet containing the sheet to copy. Example: "1qZ_..."
             sheet_id: The ID of the sheet to copy. Example: 0
-            destination_spreadsheet_id: The ID of the spreadsheet to copy the sheet to. Example: "2rY_..."
-        
+            destination_spreadsheetId: The ID of the spreadsheet to copy the sheet to. Example: "2rY_..."
+
         Returns:
             A dictionary containing the Google Sheets API response with copy details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When any required parameter is empty or invalid
-        
+
         Tags:
             copy, sheet, spreadsheet, duplicate
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if sheet_id is None:
             raise ValueError("sheet_id cannot be empty")
 
-        if not destination_spreadsheet_id:
-            raise ValueError("destination_spreadsheet_id cannot be empty")
+        if not destination_spreadsheetId:
+            raise ValueError("destination_spreadsheetId cannot be empty")
 
-        url = f"{self.base_url}/{spreadsheet_id}/sheets/{sheet_id}:copyTo"
+        url = f"{self.base_url}/{spreadsheetId}/sheets/{sheet_id}:copyTo"
 
-        request_body = {"destinationSpreadsheetId": destination_spreadsheet_id}
+        request_body = {"destinationSpreadsheetId": destination_spreadsheetId}
 
         response = self._post(url, data=request_body)
         return self._handle_response(response)
 
     def write_values_to_sheet(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         sheet_name: str,
         values: list[list[Any]],
         first_cell_location: str | None = None,
@@ -1212,28 +1216,28 @@ class GoogleSheetApp(APIApplication):
         include_values_in_response: bool = False,
     ) -> dict[str, Any]:
         """
-        Writes a 2D list of values to a sheet, overwriting existing data. Data is written starting from a specified cell, or defaults to cell A1 if no location is provided. This differs from `append_values`, which adds new rows after existing data.
-        
+        Writes a 2D list of values to a sheet, overwriting existing data. Data is written starting from a specified cell, or defaults to cell A1 if no location is provided. This differs from `append_values`, which adds new rows after existing data without replacing content.
+
         Args:
-            spreadsheet_id: The unique identifier of the Google Sheets spreadsheet to be updated. Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
+            spreadsheetId: The unique identifier of the Google Sheets spreadsheet to be updated. Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
             sheet_name: The name of the specific sheet within the spreadsheet to update. Example: "Sheet1"
             values: A 2D list of cell values. Each inner list represents a row. Values can be strings, numbers, or booleans. Ensure columns are properly aligned across rows. Example: [['Item', 'Cost', 'Stocked', 'Ship Date'], ['Wheel', 20.5, True, '2020-06-01'], ['Screw', 0.5, True, '2020-06-03'], ['Nut', 0.25, False, '2020-06-02']]
             first_cell_location: The starting cell for the update range, specified in A1 notation (e.g., 'A1', 'B2'). The update will extend from this cell to the right and down, based on the provided values. If omitted, values are appended to the end of the sheet. Example: "A1"
             value_input_option: How input data is interpreted. 'USER_ENTERED': Values parsed as if typed by a user (e.g., strings may become numbers/dates, formulas are calculated); recommended for formulas. 'RAW': Values stored as-is without parsing (e.g., '123' stays string, '=SUM(A1:B1)' stays string). Defaults to 'USER_ENTERED'. Example: "USER_ENTERED"
             include_values_in_response: If set to True, the response will include the updated values from the spreadsheet. Defaults to False. Example: True
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with update details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty, sheet_name is empty, or values is empty
-        
+            ValueError: When spreadsheetId is empty, sheet_name is empty, or values is empty
+
         Tags:
             batch, update, write, sheets, api, important, data-modification, google-sheets
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not sheet_name:
             raise ValueError("sheet_name cannot be empty")
@@ -1254,7 +1258,7 @@ class GoogleSheetApp(APIApplication):
             # Append to the sheet (no specific range)
             range_str = f"{sheet_name}"
 
-        url = f"{self.base_url}/{spreadsheet_id}/values/{range_str}"
+        url = f"{self.base_url}/{spreadsheetId}/values/{range_str}"
 
         params = {
             "valueInputOption": value_input_option,
@@ -1268,7 +1272,7 @@ class GoogleSheetApp(APIApplication):
 
     def append_values(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         range: str,
         value_input_option: str,
         values: list[list[Any]],
@@ -1278,10 +1282,10 @@ class GoogleSheetApp(APIApplication):
         response_date_time_render_option: str | None = None,
     ) -> dict[str, Any]:
         """
-        Appends rows of data after a table within a specified range. Unlike `batch_update`, this function can optionally insert new rows, shifting existing data down. This provides more granular control for adding data to a sheet without overwriting existing cells below the target table.
-        
+        Appends rows of data after a specified table in a Google Sheet. Distinct from `update_values` which overwrites data, this function adds new rows at the end of the table. It can also insert rows, shifting existing cells down, offering finer control over data addition.
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet to update. Example: "1q0gLhLdGXYZblahblahblah"
+            spreadsheetId: The ID of the spreadsheet to update. Example: "1q0gLhLdGXYZblahblahblah"
             range: The A1 notation of a range to search for a logical table of data. Values are appended after the last row of the table. Example: "Sheet1!A1:B2"
             value_input_option: How the input data should be interpreted. Required. Options: "RAW" or "USER_ENTERED". Example: "USER_ENTERED"
             values: The data to be written. This is an array of arrays, the outer array representing all the data and each inner array representing a major dimension. Each item in the inner array corresponds with one cell. Example: [["A1_val1", "A1_val2"], ["A2_val1", "A2_val2"]]
@@ -1289,19 +1293,19 @@ class GoogleSheetApp(APIApplication):
             include_values_in_response: Determines if the update response should include the values of the cells that were appended. By default, responses do not include the updated values. Example: True
             response_value_render_option: Determines how values in the response should be rendered. The default render option is FORMATTED_VALUE. Options: "FORMATTED_VALUE", "UNFORMATTED_VALUE", or "FORMULA". Example: "FORMATTED_VALUE"
             response_date_time_render_option: Determines how dates, times, and durations in the response should be rendered. This is ignored if responseValueRenderOption is FORMATTED_VALUE. The default dateTime render option is SERIAL_NUMBER. Options: "SERIAL_NUMBER" or "FORMATTED_STRING". Example: "SERIAL_NUMBER"
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with append details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When required parameters are empty or invalid
-        
+
         Tags:
             append, values, spreadsheet, data, important
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not range:
             raise ValueError("range cannot be empty")
@@ -1343,7 +1347,7 @@ class GoogleSheetApp(APIApplication):
                 'response_date_time_render_option must be either "SERIAL_NUMBER" or "FORMATTED_STRING"'
             )
 
-        url = f"{self.base_url}/{spreadsheet_id}/values/{range}:append"
+        url = f"{self.base_url}/{spreadsheetId}/values/{range}:append"
 
         params: dict[str, Any] = {"valueInputOption": value_input_option}
 
@@ -1367,33 +1371,33 @@ class GoogleSheetApp(APIApplication):
 
     def clear_basic_filter(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         sheet_id: int,
     ) -> dict[str, Any]:
         """
-        Removes the basic filter from a specified sheet within a Google Spreadsheet. This action clears any active sorting or filtering criteria, restoring the default data view. It is the direct counterpart to the `set_basic_filter` function.
-        
+        Removes the basic filter from a specified sheet, clearing active sorting and filtering criteria to restore the default data view. As the direct counterpart to `set_basic_filter`, this function removes the entire filter object, not just the cell content.
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet. Example: "abc123xyz789"
+            spreadsheetId: The ID of the spreadsheet. Example: "abc123xyz789"
             sheet_id: The ID of the sheet on which the basic filter should be cleared. Example: 0
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with update details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or sheet_id is negative
-        
+            ValueError: When spreadsheetId is empty or sheet_id is negative
+
         Tags:
             clear, filter, basic-filter, spreadsheet
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if sheet_id < 0:
             raise ValueError("sheet_id must be non-negative")
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         request_body = {"requests": [{"clearBasicFilter": {"sheetId": sheet_id}}]}
 
@@ -1402,33 +1406,33 @@ class GoogleSheetApp(APIApplication):
 
     def delete_sheet(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         sheet_id: int,
     ) -> dict[str, Any]:
         """
         Permanently deletes a specific sheet (worksheet) from a Google Spreadsheet using its sheet ID. This operation removes the target sheet and all its contents, acting as the direct counterpart to the `add_sheet` function which creates new sheets within a spreadsheet.
-        
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet from which to delete the sheet. Example: "abc123xyz789"
+            spreadsheetId: The ID of the spreadsheet from which to delete the sheet. Example: "abc123xyz789"
             sheet_id: The ID of the sheet to delete. If the sheet is of DATA_SOURCE type, the associated DataSource is also deleted. Example: 123456789
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with update details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or sheet_id is negative
-        
+            ValueError: When spreadsheetId is empty or sheet_id is negative
+
         Tags:
             delete, sheet, spreadsheet, worksheet
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if sheet_id < 0:
             raise ValueError("sheet_id must be non-negative")
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         request_body = {"requests": [{"deleteSheet": {"sheetId": sheet_id}}]}
 
@@ -1437,32 +1441,32 @@ class GoogleSheetApp(APIApplication):
 
     def discover_tables(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         min_rows: int = 2,
         min_columns: int = 1,
         min_confidence: float = 0.5,
     ) -> dict[str, Any]:
         """
-        Discovers and lists all table-like data structures within a Google Spreadsheet. It heuristically analyzes each sheet to identify headers and data boundaries, returning tables that meet specified size and confidence criteria. This is distinct from listing formally defined tables.
-        
+        Heuristically analyzes a spreadsheet to discover and list all table-like data structures, identifying headers and data boundaries. It returns informal data blocks meeting specified size criteria, distinguishing it from functions like `add_table` that manage formally defined tables.
+
         Args:
-            spreadsheet_id: Google Sheets ID from the URL (e.g., '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms'). Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
+            spreadsheetId: Google Sheets ID from the URL (e.g., '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms'). Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
             min_rows: Minimum number of data rows to consider a valid table. Example: 2
             min_columns: Minimum number of columns to consider a valid table. Example: 1
             min_confidence: Minimum confidence score (0.0-1.0) to consider a valid table. Example: 0.5
-        
+
         Returns:
             A dictionary containing the list of discovered tables with their properties
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or parameters are invalid
-        
+            ValueError: When spreadsheetId is empty or parameters are invalid
+
         Tags:
             list, tables, discover, analyze, spreadsheet, important
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if min_rows < 1:
             raise ValueError("min_rows must be at least 1")
@@ -1474,7 +1478,7 @@ class GoogleSheetApp(APIApplication):
             raise ValueError("min_confidence must be between 0.0 and 1.0")
 
         # Get spreadsheet structure
-        spreadsheet = self.get_spreadsheet_metadata(spreadsheet_id)
+        spreadsheet = self.get_spreadsheet_metadata(spreadsheetId)
 
         tables = []
 
@@ -1486,7 +1490,7 @@ class GoogleSheetApp(APIApplication):
             # Analyze sheet for tables using helper function
             sheet_tables = analyze_sheet_for_tables(
                 self.get_values,  # Pass the get_values method as a function
-                spreadsheet_id,
+                spreadsheetId,
                 sheet_id,
                 sheet_title,
                 min_rows,
@@ -1497,7 +1501,7 @@ class GoogleSheetApp(APIApplication):
             tables.extend(sheet_tables)
 
         return {
-            "spreadsheet_id": spreadsheet_id,
+            "spreadsheetId": spreadsheetId,
             "total_tables": len(tables),
             "tables": tables,
             "analysis_parameters": {
@@ -1508,32 +1512,32 @@ class GoogleSheetApp(APIApplication):
 
     def analyze_table_schema(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         table_name: str,
         sheet_name: str | None = None,
         sample_size: int = 50,
     ) -> dict[str, Any]:
         """
-        Infers the schema for a specific table within a Google Sheet by analyzing a sample of its data. After locating the table by name (as discovered by `list_tables`), it determines the most likely data type and properties for each column.
-        
+        Infers a specified table's schema by analyzing a data sample. After locating the table by name (a value discovered via `discover_tables`), this function determines the most likely data type and properties for each column, providing a detailed structural breakdown of its content.
+
         Args:
-            spreadsheet_id: Google Sheets ID from the URL (e.g., '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms')
+            spreadsheetId: Google Sheets ID from the URL (e.g., '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms')
             table_name: Specific table name from LIST_TABLES response (e.g., 'Sales_Data', 'Employee_List'). Use 'auto' to analyze the largest/most prominent table
             sheet_name: Sheet/tab name if table_name is ambiguous across multiple sheets
             sample_size: Number of rows to sample for type inference (1-1000, default 50)
-        
+
         Returns:
             A dictionary containing the table schema with column names, types, and constraints
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty, table_name is empty, or sample_size is invalid
-        
+            ValueError: When spreadsheetId is empty, table_name is empty, or sample_size is invalid
+
         Tags:
             schema, analyze, table, structure, types, columns
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not table_name:
             raise ValueError("table_name cannot be empty")
@@ -1542,7 +1546,7 @@ class GoogleSheetApp(APIApplication):
             raise ValueError("sample_size must be between 1 and 1000")
 
         # Get spreadsheet structure
-        spreadsheet = self.get_spreadsheet_metadata(spreadsheet_id)
+        spreadsheet = self.get_spreadsheet_metadata(spreadsheetId)
 
         # Find the target table
         target_table = None
@@ -1558,7 +1562,7 @@ class GoogleSheetApp(APIApplication):
             # Get tables in this sheet
             sheet_tables = analyze_sheet_for_tables(
                 self.get_values,
-                spreadsheet_id,
+                spreadsheetId,
                 sheet_properties.get("sheetId", 0),
                 sheet_title,
                 min_rows=2,
@@ -1586,19 +1590,19 @@ class GoogleSheetApp(APIApplication):
 
         # Use the helper function to analyze the table schema
         return analyze_table_schema(
-            self.get_values, spreadsheet_id, target_table, sample_size
+            self.get_values, spreadsheetId, target_table, sample_size
         )
 
     def set_basic_filter(
         self,
-        spreadsheet_id: str,
+        spreadsheetId: str,
         filter: dict,
     ) -> dict[str, Any]:
         """
         Sets or updates a basic filter on a specified range within a sheet, enabling data sorting and filtering. The filter's target range and optional sort specifications are defined in a dictionary argument. It is the counterpart to `clear_basic_filter`, which removes an existing filter.
-        
+
         Args:
-            spreadsheet_id: The ID of the spreadsheet. Example: "abc123xyz789"
+            spreadsheetId: The ID of the spreadsheet. Example: "abc123xyz789"
             filter: The filter to set. This parameter is required. Contains:
                 - range: The range the filter covers (required)
                     - sheetId: The sheet this range is on (required)
@@ -1609,19 +1613,19 @@ class GoogleSheetApp(APIApplication):
                 - sortSpecs: The sort specifications for the filter (optional)
                     - dimensionIndex: The dimension the sort should be applied to
                     - sortOrder: The order data should be sorted ("ASCENDING", "DESCENDING", "SORT_ORDER_UNSPECIFIED")
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with filter details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty or filter is missing required fields
-        
+            ValueError: When spreadsheetId is empty or filter is missing required fields
+
         Tags:
             filter, basic-filter, spreadsheet, sort, important
         """
-        if not spreadsheet_id:
-            raise ValueError("spreadsheet_id cannot be empty")
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
 
         if not filter:
             raise ValueError("filter cannot be empty")
@@ -1635,7 +1639,7 @@ class GoogleSheetApp(APIApplication):
         if "sheetId" not in range_data:
             raise ValueError("filter range must contain 'sheetId' field")
 
-        url = f"{self.base_url}/{spreadsheet_id}:batchUpdate"
+        url = f"{self.base_url}/{spreadsheetId}:batchUpdate"
 
         request_body = {"requests": [{"setBasicFilter": {"filter": filter}}]}
 
@@ -1681,8 +1685,8 @@ class GoogleSheetApp(APIApplication):
         mergeCells: bool = False,
     ) -> dict[str, Any]:
         """
-        Applies comprehensive formatting to a specified cell range in a worksheet. It modifies visual properties like text style, color, alignment, borders, and can merge cells, without altering the underlying cell values.
-        
+        Applies comprehensive formatting to a specified cell range in a worksheet. It modifies visual properties like text style, color, alignment, borders, and can merge cells, without altering the underlying cell values, distinguishing it from data-modification functions like `update_values`.
+
         Args:
             spreadsheetId: Identifier of the Google Sheets spreadsheet. Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
             worksheetId: ID (sheetId) of the worksheet. Use `get_spreadsheet_metadata` to find this ID. Example: 123456789
@@ -1690,44 +1694,44 @@ class GoogleSheetApp(APIApplication):
             startColumnIndex: 0-based index of the first column in the range. Example: 0
             endRowIndex: 0-based index of the row *after* the last row in the range (exclusive). Example: 1
             endColumnIndex: 0-based index of the column *after* the last column in the range (exclusive). Example: 2
-        
-        
+
+
             bold: Apply bold formatting. Example: True
             italic: Apply italic formatting. Example: False
             underline: Apply underline formatting. Example: False
             strikethrough: Apply strikethrough formatting. Example: False
             fontSize: Font size in points. Example: 12
             fontFamily: Font family name. Example: "Arial", "Times New Roman"
-        
+
             backgroundRed: Red component of background color. Example: 0.9
             backgroundGreen: Green component of background color. Example: 0.9
             backgroundBlue: Blue component of background color. Example: 0.9
-        
+
             textRed: Red component of text color. Example: 0.0
             textGreen: Green component of text color. Example: 0.0
             textBlue: Blue component of text color. Example: 0.0
-        
+
             horizontalAlignment: "LEFT", "CENTER", or "RIGHT". Example: "CENTER"
             verticalAlignment: "TOP", "MIDDLE", or "BOTTOM". Example: "MIDDLE"
-        
+
             wrapStrategy: "OVERFLOW_CELL", "LEGACY_WRAP", "CLIP", or "WRAP". Example: "WRAP"
-        
+
             numberFormat: Number format string. Example: "#,##0.00", "0.00%", "$#,##0.00"
-        
+
             borderTop: Top border settings. Example: {"style": "SOLID", "color": {"red": 0, "green": 0, "blue": 0}}
             borderBottom: Bottom border settings. Example: {"style": "SOLID", "color": {"red": 0, "green": 0, "blue": 0}}
             borderLeft: Left border settings. Example: {"style": "SOLID", "color": {"red": 0, "green": 0, "blue": 0}}
             borderRight: Right border settings. Example: {"style": "SOLID", "color": {"red": 0, "green": 0, "blue": 0}}
-        
+
             mergeCells: Whether to merge the specified range into a single cell. Example: True
-        
+
         Returns:
             A dictionary containing the Google Sheets API response with formatting details
-        
+
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
-            ValueError: When spreadsheet_id is empty, indices are invalid, or color values are out of range
-        
+            ValueError: When spreadsheetId is empty, indices are invalid, or color values are out of range
+
         Tags:
             format, cells, styling, text-formatting, background-color, borders, alignment, merge
         """