feat: complete gmail and sheets api method coverage

app/api/v1/gmail.py

@@ -26,6 +26,7 @@ from app.models.schemas import (
     GmailRefreshResponse,
     GmailSendResponse,
     GmailSettingsUpdateRequest,
+    GmailSmimeInfoRequest,
     GmailWatchRequest,
 )
 from app.services.gmail_service import (
@@ -1356,6 +1357,98 @@ async def verify_send_as(
     return _ok(start, creds, {"verification_sent": send_as_email})
 
 
+@router.get("/settings/send-as/{send_as_email}/smime-info", response_model=GmailGenericResponse,
+            summary="List S/MIME certificates for a send-as alias (smimeInfo.list)")
+async def list_smime_info(
+    send_as_email: str,
+    creds: GmailCredentials = Depends(_credentials),
+    service: GmailService = Depends(get_gmail_service),
+    user_id: Optional[str] = None,
+):
+    start = time.perf_counter()
+    try:
+        data = await service.list_smime_info(creds, send_as_email, user_id=user_id or "me")
+    except GmailAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info("Gmail smimeInfo listed for %s (%.2fms)", send_as_email, _elapsed_ms(start))
+    return _ok(start, creds, data)
+
+
+@router.post("/settings/send-as/{send_as_email}/smime-info", response_model=GmailGenericResponse,
+             summary="Insert an S/MIME certificate for a send-as alias (smimeInfo.insert)")
+async def insert_smime_info(
+    send_as_email: str,
+    body: GmailSmimeInfoRequest,
+    creds: GmailCredentials = Depends(_credentials),
+    service: GmailService = Depends(get_gmail_service),
+    user_id: Optional[str] = None,
+):
+    start = time.perf_counter()
+    try:
+        data = await service.insert_smime_info(creds, send_as_email, body.payload, user_id=user_id or "me")
+    except GmailAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info("Gmail smimeInfo inserted for %s (%.2fms)", send_as_email, _elapsed_ms(start))
+    return _ok(start, creds, data)
+
+
+@router.get("/settings/send-as/{send_as_email}/smime-info/{smime_info_id}",
+            response_model=GmailGenericResponse,
+            summary="Get a single S/MIME certificate (smimeInfo.get)")
+async def get_smime_info(
+    send_as_email: str,
+    smime_info_id: str,
+    creds: GmailCredentials = Depends(_credentials),
+    service: GmailService = Depends(get_gmail_service),
+    user_id: Optional[str] = None,
+):
+    start = time.perf_counter()
+    try:
+        data = await service.get_smime_info(creds, send_as_email, smime_info_id, user_id=user_id or "me")
+    except GmailAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info("Gmail smimeInfo %s fetched (%.2fms)", smime_info_id, _elapsed_ms(start))
+    return _ok(start, creds, data)
+
+
+@router.delete("/settings/send-as/{send_as_email}/smime-info/{smime_info_id}",
+               response_model=GmailGenericResponse,
+               summary="Delete an S/MIME certificate (smimeInfo.delete)")
+async def delete_smime_info(
+    send_as_email: str,
+    smime_info_id: str,
+    creds: GmailCredentials = Depends(_credentials),
+    service: GmailService = Depends(get_gmail_service),
+    user_id: Optional[str] = None,
+):
+    start = time.perf_counter()
+    try:
+        await service.delete_smime_info(creds, send_as_email, smime_info_id, user_id=user_id or "me")
+    except GmailAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info("Gmail smimeInfo %s deleted (%.2fms)", smime_info_id, _elapsed_ms(start))
+    return _ok(start, creds, {"deleted": smime_info_id})
+
+
+@router.post("/settings/send-as/{send_as_email}/smime-info/{smime_info_id}/setDefault",
+             response_model=GmailGenericResponse,
+             summary="Set an S/MIME certificate as the default for a send-as alias (smimeInfo.setDefault)")
+async def set_default_smime_info(
+    send_as_email: str,
+    smime_info_id: str,
+    creds: GmailCredentials = Depends(_credentials),
+    service: GmailService = Depends(get_gmail_service),
+    user_id: Optional[str] = None,
+):
+    start = time.perf_counter()
+    try:
+        await service.set_default_smime_info(creds, send_as_email, smime_info_id, user_id=user_id or "me")
+    except GmailAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info("Gmail smimeInfo %s set default (%.2fms)", smime_info_id, _elapsed_ms(start))
+    return _ok(start, creds, {"default_set": smime_info_id})
+
+
 @router.get("/settings/delegates", response_model=GmailGenericResponse,
             summary="List delegates")
 async def list_delegates(

app/api/v1/sheets.py

@@ -9,10 +9,18 @@ from app.config import get_settings
 from app.core.logger import get_logger
 from app.models.schemas import (
     SheetsAppendRequest,
+    SheetsBatchClearByDataFilterRequest,
+    SheetsBatchClearRequest,
+    SheetsBatchGetByDataFilterRequest,
+    SheetsBatchUpdateByDataFilterRequest,
     SheetsBatchUpdateRequest,
+    SheetsBatchUpdateValuesRequest,
+    SheetsCopySheetRequest,
     SheetsCreateSpreadsheetRequest,
     SheetsGenericResponse,
+    SheetsGetByDataFilterRequest,
     SheetsRefreshResponse,
+    SheetsSearchDeveloperMetadataRequest,
     SheetsValueUpdateRequest,
 )
 from app.services.sheets_service import (
@@ -225,6 +233,57 @@ async def batch_update(
     return _ok(start, creds, data)
 
 
+@router.post("/spreadsheets/{spreadsheet_id}:getByDataFilter",
+             response_model=SheetsGenericResponse,
+             summary="Read a spreadsheet filtered by DataFilter objects (spreadsheets.getByDataFilter)")
+async def get_spreadsheet_by_data_filter(
+    spreadsheet_id: str,
+    body: SheetsGetByDataFilterRequest,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+):
+    start = time.perf_counter()
+    try:
+        data = await service.get_spreadsheet_by_data_filter(
+            creds,
+            spreadsheet_id,
+            data_filters=body.data_filters,
+            include_grid_data=body.include_grid_data,
+        )
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info(
+        "Sheets spreadsheet %s read by data filter (%.2fms)", spreadsheet_id, _elapsed_ms(start)
+    )
+    return _ok(start, creds, data)
+
+
+@router.post("/spreadsheets/{spreadsheet_id}/sheets/{sheet_id}:copyTo",
+             response_model=SheetsGenericResponse,
+             summary="Copy a sheet to another spreadsheet (sheets.copyTo)")
+async def copy_sheet(
+    spreadsheet_id: str,
+    sheet_id: int,
+    body: SheetsCopySheetRequest,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+):
+    start = time.perf_counter()
+    try:
+        data = await service.copy_sheet(
+            creds,
+            spreadsheet_id,
+            sheet_id,
+            destination_spreadsheet_id=body.destination_spreadsheet_id,
+        )
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info(
+        "Sheets sheet %d copied from %s (%.2fms)", sheet_id, spreadsheet_id, _elapsed_ms(start)
+    )
+    return _ok(start, creds, data)
+
+
 # ---------------------------------------------------------------------------
 # Values
 # ---------------------------------------------------------------------------
@@ -362,3 +421,179 @@ async def clear_values(
         raise _http_error(exc) from exc
     _logger.info("Sheets values %s!%s cleared (%.2fms)", spreadsheet_id, range, _elapsed_ms(start))
     return _ok(start, creds, data)
+
+
+@router.post("/spreadsheets/{spreadsheet_id}/values:batchUpdate",
+             response_model=SheetsGenericResponse,
+             summary="Write multiple ranges in one call (values.batchUpdate)")
+async def batch_update_values(
+    spreadsheet_id: str,
+    body: SheetsBatchUpdateValuesRequest,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+    value_input_option: str = "RAW",
+):
+    start = time.perf_counter()
+    try:
+        data = await service.batch_update_values(
+            creds,
+            spreadsheet_id,
+            data=body.data,
+            value_input_option=value_input_option,
+            include_values_in_response=body.include_values_in_response,
+            value_render_option=body.value_render_option,
+            response_value_render_option=body.response_value_render_option,
+            response_date_time_render_option=body.response_date_time_render_option,
+        )
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info("Sheets values batch-updated on %s (%.2fms)", spreadsheet_id, _elapsed_ms(start))
+    return _ok(start, creds, data)
+
+
+@router.post("/spreadsheets/{spreadsheet_id}/values:batchClear",
+             response_model=SheetsGenericResponse,
+             summary="Clear multiple ranges in one call (values.batchClear)")
+async def batch_clear_values(
+    spreadsheet_id: str,
+    body: SheetsBatchClearRequest,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+):
+    start = time.perf_counter()
+    try:
+        data = await service.batch_clear_values(
+            creds, spreadsheet_id, ranges=body.ranges
+        )
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info("Sheets values batch-cleared on %s (%.2fms)", spreadsheet_id, _elapsed_ms(start))
+    return _ok(start, creds, data)
+
+
+@router.post("/spreadsheets/{spreadsheet_id}/values:batchGetByDataFilter",
+             response_model=SheetsGenericResponse,
+             summary="Read multiple ranges by DataFilter (values.batchGetByDataFilter)")
+async def batch_get_values_by_data_filter(
+    spreadsheet_id: str,
+    body: SheetsBatchGetByDataFilterRequest,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+):
+    start = time.perf_counter()
+    try:
+        data = await service.batch_get_values_by_data_filter(
+            creds,
+            spreadsheet_id,
+            data_filters=body.data_filters,
+            major_dimension=body.major_dimension,
+            value_render_option=body.value_render_option,
+            date_time_render_option=body.date_time_render_option,
+        )
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info(
+        "Sheets batchGetByDataFilter on %s (%.2fms)", spreadsheet_id, _elapsed_ms(start)
+    )
+    return _ok(start, creds, data)
+
+
+@router.post("/spreadsheets/{spreadsheet_id}/values:batchUpdateByDataFilter",
+             response_model=SheetsGenericResponse,
+             summary="Write multiple DataFilter ranges (values.batchUpdateByDataFilter)")
+async def batch_update_values_by_data_filter(
+    spreadsheet_id: str,
+    body: SheetsBatchUpdateByDataFilterRequest,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+    value_input_option: str = "RAW",
+):
+    start = time.perf_counter()
+    try:
+        data = await service.batch_update_values_by_data_filter(
+            creds,
+            spreadsheet_id,
+            data=body.data,
+            value_input_option=value_input_option,
+            include_values_in_response=body.include_values_in_response,
+            value_render_option=body.value_render_option,
+            response_value_render_option=body.response_value_render_option,
+            response_date_time_render_option=body.response_date_time_render_option,
+        )
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info(
+        "Sheets batchUpdateByDataFilter on %s (%.2fms)", spreadsheet_id, _elapsed_ms(start)
+    )
+    return _ok(start, creds, data)
+
+
+@router.post("/spreadsheets/{spreadsheet_id}/values:batchClearByDataFilter",
+             response_model=SheetsGenericResponse,
+             summary="Clear multiple DataFilter ranges (values.batchClearByDataFilter)")
+async def batch_clear_values_by_data_filter(
+    spreadsheet_id: str,
+    body: SheetsBatchClearByDataFilterRequest,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+):
+    start = time.perf_counter()
+    try:
+        data = await service.batch_clear_values_by_data_filter(
+            creds, spreadsheet_id, data_filters=body.data_filters
+        )
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info(
+        "Sheets batchClearByDataFilter on %s (%.2fms)", spreadsheet_id, _elapsed_ms(start)
+    )
+    return _ok(start, creds, data)
+
+
+# ---------------------------------------------------------------------------
+# Developer metadata
+# ---------------------------------------------------------------------------
+
+@router.get("/spreadsheets/{spreadsheet_id}/developerMetadata/{metadata_id}",
+            response_model=SheetsGenericResponse,
+            summary="Get a single developer metadata entry (developerMetadata.get)")
+async def get_developer_metadata(
+    spreadsheet_id: str,
+    metadata_id: int,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+):
+    start = time.perf_counter()
+    try:
+        data = await service.get_developer_metadata(creds, spreadsheet_id, metadata_id)
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info(
+        "Sheets developer metadata %d fetched from %s (%.2fms)",
+        metadata_id,
+        spreadsheet_id,
+        _elapsed_ms(start),
+    )
+    return _ok(start, creds, data)
+
+
+@router.post("/spreadsheets/{spreadsheet_id}/developerMetadata:search",
+             response_model=SheetsGenericResponse,
+             summary="Search developer metadata (developerMetadata.search)")
+async def search_developer_metadata(
+    spreadsheet_id: str,
+    body: SheetsSearchDeveloperMetadataRequest,
+    creds: SheetsCredentials = Depends(_credentials),
+    service: SheetsService = Depends(get_sheets_service),
+):
+    start = time.perf_counter()
+    try:
+        data = await service.search_developer_metadata(
+            creds, spreadsheet_id, data_filters=body.data_filters or None
+        )
+    except SheetsAPIError as exc:
+        raise _http_error(exc) from exc
+    _logger.info(
+        "Sheets developer metadata searched on %s (%.2fms)", spreadsheet_id, _elapsed_ms(start)
+    )
+    return _ok(start, creds, data)

app/models/schemas.py

@@ -1964,6 +1964,22 @@ class GmailSendAsRequest(BaseModel):
     signature: Optional[str] = Field(None, description="Email signature (HTML)")
 
 
+class GmailSmimeInfoRequest(BaseModel):
+    """Body for inserting an S/MIME certificate (users.settings.sendAs.smimeInfo.insert)."""
+
+    payload: Dict[str, Any] = Field(
+        ...,
+        description="SmimeInfo resource: either 'pkcs12' (base64) + 'encryptedKeyPassword', or 'pem'. See Gmail API reference.",
+    )
+
+    @field_validator("payload")
+    @classmethod
+    def _non_empty(cls, v: Dict[str, Any]) -> Dict[str, Any]:
+        if not v:
+            raise ValueError("payload must not be empty.")
+        return v
+
+
 class GmailGenericResponse(BaseModel):
     """Standard Gmail operation envelope."""
 
@@ -2053,6 +2069,83 @@ class SheetsBatchUpdateRequest(BaseModel):
     requests: List[Dict[str, Any]] = Field(..., min_length=1, description="List of request objects (addSheet, updateCells, etc.)")
 
 
+class SheetsGetByDataFilterRequest(BaseModel):
+    """Body for reading a spreadsheet filtered by DataFilter (spreadsheets.getByDataFilter)."""
+
+    data_filters: List[Dict[str, Any]] = Field(
+        ...,
+        min_length=1,
+        description="List of DataFilter objects; each must set exactly one of a1Range, gridRange, namedRangeId, developerMetadataLookup",
+    )
+    include_grid_data: bool = Field(False, description="Whether to include cell grid data in the response")
+
+
+class SheetsCopySheetRequest(BaseModel):
+    """Body for copying a sheet to another spreadsheet (sheets.copyTo)."""
+
+    destination_spreadsheet_id: str = Field(
+        ..., min_length=1, description="ID of the spreadsheet to copy the sheet into"
+    )
+
+
+class SheetsBatchGetByDataFilterRequest(BaseModel):
+    """Body for reading multiple ranges by DataFilter (values.batchGetByDataFilter)."""
+
+    data_filters: List[Dict[str, Any]] = Field(..., min_length=1, description="List of DataFilter objects")
+    major_dimension: Optional[str] = Field(None, pattern="^(ROWS|COLUMNS)$", description="Major dimension of the returned values")
+    value_render_option: Optional[str] = Field(None, pattern="^(FORMATTED_VALUE|UNFORMATTED_VALUE|FORMULA)$", description="Render option for returned values")
+    date_time_render_option: Optional[str] = Field(None, pattern="^(SERIAL_NUMBER|FORMATTED_STRING)$", description="Date/time render option for returned values")
+
+
+class SheetsBatchUpdateValuesRequest(BaseModel):
+    """Body for writing multiple ranges in one call (values.batchUpdate)."""
+
+    data: List[Dict[str, Any]] = Field(
+        ..., min_length=1, description="List of ValueRange objects, each with 'range' and 'values'"
+    )
+    include_values_in_response: Optional[bool] = Field(None, description="Whether responses should include updated values")
+    value_render_option: Optional[str] = Field(None, pattern="^(FORMATTED_VALUE|UNFORMATTED_VALUE|FORMULA)$", description="Render option for values in the response")
+    response_value_render_option: Optional[str] = Field(None, pattern="^(FORMATTED_VALUE|UNFORMATTED_VALUE|FORMULA)$", description="Render option for response values")
+    response_date_time_render_option: Optional[str] = Field(None, pattern="^(SERIAL_NUMBER|FORMATTED_STRING)$", description="Date/time render option for response values")
+
+
+class SheetsBatchUpdateByDataFilterRequest(BaseModel):
+    """Body for writing multiple DataFilter ranges (values.batchUpdateByDataFilter)."""
+
+    data: List[Dict[str, Any]] = Field(
+        ...,
+        min_length=1,
+        description="List of DataFilterValueRange objects, each with 'dataFilter', optional 'majorDimension' and 'values'",
+    )
+    include_values_in_response: Optional[bool] = Field(None, description="Whether responses should include updated values")
+    value_render_option: Optional[str] = Field(None, pattern="^(FORMATTED_VALUE|UNFORMATTED_VALUE|FORMULA)$", description="Render option for values in the response")
+    response_value_render_option: Optional[str] = Field(None, pattern="^(FORMATTED_VALUE|UNFORMATTED_VALUE|FORMULA)$", description="Render option for response values")
+    response_date_time_render_option: Optional[str] = Field(None, pattern="^(SERIAL_NUMBER|FORMATTED_STRING)$", description="Date/time render option for response values")
+
+
+class SheetsBatchClearRequest(BaseModel):
+    """Body for clearing multiple ranges in one call (values.batchClear)."""
+
+    ranges: List[str] = Field(
+        ..., min_length=1, description="A1 notation ranges to clear, e.g. ['Sheet1!A1:B2']"
+    )
+
+
+class SheetsBatchClearByDataFilterRequest(BaseModel):
+    """Body for clearing multiple DataFilter ranges (values.batchClearByDataFilter)."""
+
+    data_filters: List[Dict[str, Any]] = Field(..., min_length=1, description="List of DataFilter objects")
+
+
+class SheetsSearchDeveloperMetadataRequest(BaseModel):
+    """Body for searching developer metadata (developerMetadata.search)."""
+
+    data_filters: List[Dict[str, Any]] = Field(
+        default_factory=list,
+        description="Optional list of DataFilter objects, each with developerMetadataLookup; empty searches all metadata",
+    )
+
+
 class SheetsGenericResponse(BaseModel):
     """Standard Google Sheets operation envelope."""
 

app/services/gmail_service.py

@@ -1024,3 +1024,63 @@ class GmailService:
         await self._request(
             creds, "DELETE", f"/users/{user_id}/settings/delegates/{delegate_email}"
         )
+
+    async def list_smime_info(
+        self, creds: GmailCredentials, send_as_email: str, user_id: str = "me"
+    ) -> Dict[str, Any]:
+        return await self._request(
+            creds, "GET", f"/users/{user_id}/settings/sendAs/{send_as_email}/smimeInfo"
+        )
+
+    async def get_smime_info(
+        self,
+        creds: GmailCredentials,
+        send_as_email: str,
+        smime_info_id: str,
+        user_id: str = "me",
+    ) -> Dict[str, Any]:
+        return await self._request(
+            creds,
+            "GET",
+            f"/users/{user_id}/settings/sendAs/{send_as_email}/smimeInfo/{smime_info_id}",
+        )
+
+    async def insert_smime_info(
+        self,
+        creds: GmailCredentials,
+        send_as_email: str,
+        payload: Dict[str, Any],
+        user_id: str = "me",
+    ) -> Dict[str, Any]:
+        return await self._request(
+            creds,
+            "POST",
+            f"/users/{user_id}/settings/sendAs/{send_as_email}/smimeInfo",
+            json_body=payload,
+        )
+
+    async def delete_smime_info(
+        self,
+        creds: GmailCredentials,
+        send_as_email: str,
+        smime_info_id: str,
+        user_id: str = "me",
+    ) -> None:
+        await self._request(
+            creds,
+            "DELETE",
+            f"/users/{user_id}/settings/sendAs/{send_as_email}/smimeInfo/{smime_info_id}",
+        )
+
+    async def set_default_smime_info(
+        self,
+        creds: GmailCredentials,
+        send_as_email: str,
+        smime_info_id: str,
+        user_id: str = "me",
+    ) -> None:
+        await self._request(
+            creds,
+            "POST",
+            f"/users/{user_id}/settings/sendAs/{send_as_email}/smimeInfo/{smime_info_id}/setDefault",
+        )

app/services/sheets_service.py

@@ -561,3 +561,175 @@ class SheetsService:
             f"/spreadsheets/{spreadsheet_id}/values/{range_}:clear",
             json_body={},
         )
+
+    async def batch_update_values(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        *,
+        data: List[Dict[str, Any]],
+        value_input_option: str = "RAW",
+        include_values_in_response: Optional[bool] = None,
+        value_render_option: Optional[str] = None,
+        response_value_render_option: Optional[str] = None,
+        response_date_time_render_option: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"data": data}
+        if include_values_in_response is not None:
+            body["includeValuesInResponse"] = include_values_in_response
+        if value_render_option:
+            body["valueRenderOption"] = value_render_option
+        if response_value_render_option:
+            body["responseValueRenderOption"] = response_value_render_option
+        if response_date_time_render_option:
+            body["responseDateTimeRenderOption"] = response_date_time_render_option
+        return await self._request(
+            creds,
+            "POST",
+            f"/spreadsheets/{spreadsheet_id}/values:batchUpdate",
+            params={"valueInputOption": value_input_option},
+            json_body=body,
+        )
+
+    async def batch_clear_values(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        *,
+        ranges: List[str],
+    ) -> Dict[str, Any]:
+        return await self._request(
+            creds,
+            "POST",
+            f"/spreadsheets/{spreadsheet_id}/values:batchClear",
+            json_body={"ranges": ranges},
+        )
+
+    async def get_spreadsheet_by_data_filter(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        *,
+        data_filters: List[Dict[str, Any]],
+        include_grid_data: bool = False,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"dataFilters": data_filters}
+        if include_grid_data:
+            body["includeGridData"] = True
+        return await self._request(
+            creds,
+            "POST",
+            f"/spreadsheets/{spreadsheet_id}:getByDataFilter",
+            json_body=body,
+        )
+
+    async def copy_sheet(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        sheet_id: int,
+        *,
+        destination_spreadsheet_id: str,
+    ) -> Dict[str, Any]:
+        return await self._request(
+            creds,
+            "POST",
+            f"/spreadsheets/{spreadsheet_id}/sheets/{sheet_id}:copyTo",
+            json_body={"destinationSpreadsheetId": destination_spreadsheet_id},
+        )
+
+    async def batch_get_values_by_data_filter(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        *,
+        data_filters: List[Dict[str, Any]],
+        major_dimension: Optional[str] = None,
+        value_render_option: Optional[str] = None,
+        date_time_render_option: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"dataFilters": data_filters}
+        if major_dimension:
+            body["majorDimension"] = major_dimension
+        if value_render_option:
+            body["valueRenderOption"] = value_render_option
+        if date_time_render_option:
+            body["dateTimeRenderOption"] = date_time_render_option
+        return await self._request(
+            creds,
+            "POST",
+            f"/spreadsheets/{spreadsheet_id}/values:batchGetByDataFilter",
+            json_body=body,
+        )
+
+    async def batch_update_values_by_data_filter(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        *,
+        data: List[Dict[str, Any]],
+        value_input_option: str = "RAW",
+        include_values_in_response: Optional[bool] = None,
+        value_render_option: Optional[str] = None,
+        response_value_render_option: Optional[str] = None,
+        response_date_time_render_option: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"data": data}
+        if include_values_in_response is not None:
+            body["includeValuesInResponse"] = include_values_in_response
+        if value_render_option:
+            body["valueRenderOption"] = value_render_option
+        if response_value_render_option:
+            body["responseValueRenderOption"] = response_value_render_option
+        if response_date_time_render_option:
+            body["responseDateTimeRenderOption"] = response_date_time_render_option
+        return await self._request(
+            creds,
+            "POST",
+            f"/spreadsheets/{spreadsheet_id}/values:batchUpdateByDataFilter",
+            params={"valueInputOption": value_input_option},
+            json_body=body,
+        )
+
+    async def batch_clear_values_by_data_filter(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        *,
+        data_filters: List[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        return await self._request(
+            creds,
+            "POST",
+            f"/spreadsheets/{spreadsheet_id}/values:batchClearByDataFilter",
+            json_body={"dataFilters": data_filters},
+        )
+
+    async def get_developer_metadata(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        metadata_id: int,
+    ) -> Dict[str, Any]:
+        return await self._request(
+            creds,
+            "GET",
+            f"/spreadsheets/{spreadsheet_id}/developerMetadata/{metadata_id}",
+        )
+
+    async def search_developer_metadata(
+        self,
+        creds: SheetsCredentials,
+        spreadsheet_id: str,
+        *,
+        data_filters: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {}
+        if data_filters:
+            body["dataFilters"] = data_filters
+        return await self._request(
+            creds,
+            "POST",
+            f"/spreadsheets/{spreadsheet_id}/developerMetadata:search",
+            json_body=body,
+        )