google-spreadsheet 5.0.3 → 5.2.0

package/dist/index.js

@@ -43,6 +43,12 @@ var GoogleSpreadsheetRow = class {
 		this._worksheet = _worksheet;
 		this._rowNumber = _rowNumber;
 		this._rawData = _rawData;
+		this._padRawData();
+	}
+	/** pad _rawData with empty strings so it always matches header length */
+	_padRawData() {
+		const headerLength = this._worksheet.headerValues.length;
+		while (this._rawData.length < headerLength) this._rawData.push("");
 	}
 	_deleted = false;
 	get deleted() {
@@ -60,6 +66,14 @@ var GoogleSpreadsheetRow = class {
 	_updateRowNumber(newRowNumber) {
 		this._rowNumber = newRowNumber;
 	}
+	/**
+	* @internal
+	* Used internally to mark row as deleted.
+	* Should not be called directly.
+	*/
+	_markDeleted() {
+		this._deleted = true;
+	}
 	get a1Range() {
 		return [
 			this._worksheet.a1SheetName,
@@ -106,7 +120,8 @@ var GoogleSpreadsheetRow = class {
 				majorDimension: "ROWS",
 				values: [this._rawData]
 			}
-		})).json()).updatedData.values[0];
+		})).json()).updatedData.values?.[0] || [];
+		this._padRawData();
 	}
 	/** delete this row */
 	async delete() {
@@ -163,6 +178,7 @@ var GoogleSpreadsheetCell = class {
 	_rawData;
 	_draftData = {};
 	_error;
+	_deleted = false;
 	constructor(_sheet, _rowIndex, _columnIndex, rawCellData) {
 		this._sheet = _sheet;
 		this._rowIndex = _rowIndex;
@@ -170,6 +186,9 @@ var GoogleSpreadsheetCell = class {
 		this._updateRawData(rawCellData);
 		this._rawData = rawCellData;
 	}
+	get deleted() {
+		return this._deleted;
+	}
 	/**
 	* update cell using raw CellData coming back from sheets API
 	* @internal
@@ -195,6 +214,23 @@ var GoogleSpreadsheetCell = class {
 	get a1Address() {
 		return `${this.a1Column}${this.a1Row}`;
 	}
+	/**
+	* @internal
+	* Used internally to update cell indices after deleting rows/columns.
+	* Should not be called directly.
+	*/
+	_updateIndices(rowIndex, columnIndex) {
+		this._rowIndex = rowIndex;
+		this._columnIndex = columnIndex;
+	}
+	/**
+	* @internal
+	* Used internally to mark cell as deleted.
+	* Should not be called directly.
+	*/
+	_markDeleted() {
+		this._deleted = true;
+	}
 	get value() {
 		if (this._draftData.value !== void 0) throw new Error("Value has been changed");
 		if (this._error) return this._error;
@@ -202,6 +238,7 @@ var GoogleSpreadsheetCell = class {
 		return values(this._rawData.effectiveValue)[0];
 	}
 	set value(newValue) {
+		if (this._deleted) throw new Error("This cell has been deleted - reload cells before making updates.");
 		if (newValue instanceof GoogleSpreadsheetCellErrorValue) throw new Error("You can't manually set a value to an error");
 		if (isBoolean(newValue)) this._draftData.valueType = "boolValue";
 		else if (isString(newValue)) if (newValue.substring(0, 1) === "=") this._draftData.valueType = "formulaValue";
@@ -261,8 +298,8 @@ var GoogleSpreadsheetCell = class {
 		return this.value;
 	}
 	set stringValue(val) {
-		if (val?.startsWith("=")) throw new Error("Use cell.formula to set formula values");
-		this.value = val;
+		this._draftData.valueType = "stringValue";
+		this._draftData.value = val || "";
 	}
 	/**
 	* Hyperlink contained within the cell.
@@ -470,7 +507,9 @@ var GoogleSpreadsheetWorksheet = class {
 	_ensureInfoLoaded() {
 		if (!this._rawProperties) throw new Error("You must call `doc.loadInfo()` again before accessing this property");
 	}
-	/** clear local cache of sheet data/properties */
+	/**
+	* clear local cache of sheet data/properties
+	*/
 	resetLocalCache(dataOnly) {
 		if (!dataOnly) this._rawProperties = null;
 		this._headerValues = void 0;
@@ -613,6 +652,7 @@ var GoogleSpreadsheetWorksheet = class {
 				return `${this.a1SheetName}!${filter}`;
 			}
 			if (isObject(filter)) {
+				if ("developerMetadataLookup" in filter) return filter;
 				const filterAny = filter;
 				if (filterAny.sheetId && filterAny.sheetId !== this.sheetId) throw new Error("Leave sheet ID blank or set to matching ID of this sheet");
 				return {
@@ -702,7 +742,9 @@ var GoogleSpreadsheetWorksheet = class {
 			return new GoogleSpreadsheetRow(this, rowNumber++, rowValues);
 		});
 	}
-	/** add a single row - see addRows for more info */
+	/**
+	* add a single row - see addRows for more info
+	*/
 	async addRow(rowValues, options) {
 		return (await this.addRows([rowValues], options))[0];
 	}
@@ -742,6 +784,79 @@ var GoogleSpreadsheetWorksheet = class {
 			if (row.rowNumber > deletedRowNumber) row._updateRowNumber(row.rowNumber - 1);
 		});
 	}
+	/**
+	* @internal
+	* Used internally to update row numbers after deleting multiple rows.
+	* Should not be called directly.
+	* */
+	_shiftRowCacheBulk(startIndex, endIndex) {
+		const numDeleted = endIndex - startIndex;
+		const startRow = startIndex + 1;
+		const endRow = endIndex;
+		for (let rowNum = startRow; rowNum <= endRow; rowNum++) {
+			const row = this._rowCache[rowNum];
+			if (row) row._markDeleted();
+			delete this._rowCache[rowNum];
+		}
+		this._rowCache.forEach((row) => {
+			if (row.rowNumber > endRow) row._updateRowNumber(row.rowNumber - numDeleted);
+		});
+	}
+	/**
+	* @internal
+	* Used internally to shift cell cache after deleting rows.
+	* Should not be called directly.
+	* */
+	_shiftCellCacheRows(startIndex, endIndex) {
+		const numDeleted = endIndex - startIndex;
+		for (let rowIndex = startIndex; rowIndex < endIndex; rowIndex++) {
+			const row = this._cells[rowIndex];
+			if (row) row.forEach((cell) => {
+				if (cell) cell._markDeleted();
+			});
+			delete this._cells[rowIndex];
+		}
+		const rowsToShift = [];
+		for (let rowIndex = endIndex; rowIndex < this._cells.length; rowIndex++) if (this._cells[rowIndex]) rowsToShift.push({
+			oldRowIndex: rowIndex,
+			cells: this._cells[rowIndex]
+		});
+		rowsToShift.forEach(({ oldRowIndex, cells }) => {
+			delete this._cells[oldRowIndex];
+			const newRowIndex = oldRowIndex - numDeleted;
+			this._cells[newRowIndex] = cells;
+			cells.forEach((cell, colIndex) => {
+				if (cell) cell._updateIndices(newRowIndex, colIndex);
+			});
+		});
+	}
+	/**
+	* @internal
+	* Used internally to shift cell cache after deleting columns.
+	* Should not be called directly.
+	* */
+	_shiftCellCacheColumns(startIndex, endIndex) {
+		const numDeleted = endIndex - startIndex;
+		this._cells.forEach((row, rowIndex) => {
+			if (!row) return;
+			for (let colIndex = startIndex; colIndex < endIndex; colIndex++) {
+				const cell = row[colIndex];
+				if (cell) cell._markDeleted();
+				delete row[colIndex];
+			}
+			const cellsToShift = [];
+			for (let colIndex = endIndex; colIndex < row.length; colIndex++) if (row[colIndex]) cellsToShift.push({
+				oldColIndex: colIndex,
+				cell: row[colIndex]
+			});
+			cellsToShift.forEach(({ oldColIndex, cell }) => {
+				delete row[oldColIndex];
+				const newColIndex = oldColIndex - numDeleted;
+				row[newColIndex] = cell;
+				cell._updateIndices(rowIndex, newColIndex);
+			});
+		});
+	}
 	async clearRows(options) {
 		const startRowIndex = options?.start || this._headerRowIndex + 1;
 		const endRowIndex = options?.end || this.rowCount;
@@ -766,12 +881,13 @@ var GoogleSpreadsheetWorksheet = class {
 	async updateGridProperties(gridProperties) {
 		return this.updateProperties({ gridProperties });
 	}
-	/** resize, internally just calls updateGridProperties */
+	/**
+	* resize, internally just calls updateGridProperties
+	*/
 	async resize(gridProperties) {
 		return this.updateGridProperties(gridProperties);
 	}
 	/**
-	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#updatedimensionpropertiesrequest
 	*/
 	async updateDimensionProperties(columnsOrRows, properties, bounds) {
@@ -792,15 +908,96 @@ var GoogleSpreadsheetWorksheet = class {
 		const ranges = a1Ranges.map((r) => `ranges=${this.encodedA1SheetName}!${r}`).join("&");
 		return (await (await this._spreadsheet.sheetsApi.get(`values:batchGet?${ranges}`, { searchParams: options })).json()).valueRanges.map((r) => r.values);
 	}
-	async updateNamedRange() {}
-	async addNamedRange() {}
-	async deleteNamedRange() {}
-	async repeatCell() {}
-	async autoFill() {}
-	async cutPaste() {}
-	async copyPaste() {}
+	/**
+	* Updates an existing named range
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UpdateNamedRangeRequest
+	*/
+	async updateNamedRange(namedRangeId, namedRange, fields) {
+		return this._makeSingleUpdateRequest("updateNamedRange", {
+			namedRange: {
+				namedRangeId,
+				...namedRange.name && { name: namedRange.name },
+				...namedRange.range && { range: this._addSheetIdToRange(namedRange.range) }
+			},
+			fields
+		});
+	}
+	/**
+	* Creates a new named range in this worksheet (convenience method that auto-fills sheetId)
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AddNamedRangeRequest
+	*/
+	async addNamedRange(name, range, namedRangeId) {
+		return this._spreadsheet.addNamedRange(name, this._addSheetIdToRange(range), namedRangeId);
+	}
+	/**
+	* Deletes a named range (convenience wrapper)
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteNamedRangeRequest
+	*/
+	async deleteNamedRange(namedRangeId) {
+		return this._spreadsheet.deleteNamedRange(namedRangeId);
+	}
+	/**
+	* Updates all cells in a range with the same cell data
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#RepeatCellRequest
+	*/
+	async repeatCell(range, cell, fields) {
+		await this._makeSingleUpdateRequest("repeatCell", {
+			range: this._addSheetIdToRange(range),
+			cell,
+			fields
+		});
+	}
+	/**
+	* Auto-fills cells with data following a pattern (like dragging the fill handle)
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AutoFillRequest
+	*/
+	async autoFill(rangeOrSource, useAlternateSeries) {
+		const isSourceAndDestination = "dimension" in rangeOrSource;
+		await this._makeSingleUpdateRequest("autoFill", {
+			...isSourceAndDestination ? { sourceAndDestination: {
+				...rangeOrSource,
+				source: this._addSheetIdToRange(rangeOrSource.source)
+			} } : { range: this._addSheetIdToRange(rangeOrSource) },
+			...useAlternateSeries !== void 0 && { useAlternateSeries }
+		});
+	}
+	/**
+	* Cuts data from a source range and pastes it to a destination coordinate
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#CutPasteRequest
+	*/
+	async cutPaste(source, destination, pasteType = "PASTE_NORMAL") {
+		await this._makeSingleUpdateRequest("cutPaste", {
+			source: this._addSheetIdToRange(source),
+			destination: {
+				sheetId: this.sheetId,
+				rowIndex: destination.rowIndex,
+				columnIndex: destination.columnIndex
+			},
+			pasteType
+		});
+	}
+	/**
+	* Copies data from a source range and pastes it to a destination range
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#CopyPasteRequest
+	*/
+	async copyPaste(source, destination, pasteType = "PASTE_NORMAL", pasteOrientation = "NORMAL") {
+		await this._makeSingleUpdateRequest("copyPaste", {
+			source: this._addSheetIdToRange(source),
+			destination: this._addSheetIdToRange(destination),
+			pasteType,
+			pasteOrientation
+		});
+	}
 	/**
 	* Merges all cells in the range
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#MergeCellsRequest
 	*/
 	async mergeCells(range, mergeType = "MERGE_ALL") {
@@ -811,21 +1008,114 @@ var GoogleSpreadsheetWorksheet = class {
 	}
 	/**
 	* Unmerges cells in the given range
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UnmergeCellsRequest
 	*/
 	async unmergeCells(range) {
 		await this._makeSingleUpdateRequest("unmergeCells", { range: this._addSheetIdToRange(range) });
 	}
-	async updateBorders() {}
-	async addFilterView() {}
-	async appendCells() {}
-	async clearBasicFilter() {}
-	async deleteDimension() {}
-	async deleteEmbeddedObject() {}
-	async deleteFilterView() {}
-	async duplicateFilterView() {}
+	/**
+	* Updates borders for a range
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UpdateBordersRequest
+	*/
+	async updateBorders(range, borders) {
+		await this._makeSingleUpdateRequest("updateBorders", {
+			range: this._addSheetIdToRange(range),
+			...borders
+		});
+	}
+	/**
+	* Adds a filter view to the sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AddFilterViewRequest
+	*/
+	async addFilterView(filter) {
+		return this._makeSingleUpdateRequest("addFilterView", { filter });
+	}
+	/**
+	* Appends cells after the last row with data in a sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AppendCellsRequest
+	*/
+	async appendCells(rows, fields) {
+		await this._makeSingleUpdateRequest("appendCells", {
+			sheetId: this.sheetId,
+			rows,
+			fields
+		});
+	}
+	/**
+	* Clears the basic filter on this sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#ClearBasicFilterRequest
+	*/
+	async clearBasicFilter() {
+		await this._makeSingleUpdateRequest("clearBasicFilter", { sheetId: this.sheetId });
+	}
+	/**
+	* Delete rows or columns in a given range
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteDimensionRequest
+	*/
+	async deleteDimension(columnsOrRows, rangeIndexes) {
+		if (!columnsOrRows) throw new Error("You need to specify a dimension. i.e. COLUMNS|ROWS");
+		if (!isObject(rangeIndexes)) throw new Error("`range` must be an object containing `startIndex` and `endIndex`");
+		if (!isInteger(rangeIndexes.startIndex) || rangeIndexes.startIndex < 0) throw new Error("range.startIndex must be an integer >=0");
+		if (!isInteger(rangeIndexes.endIndex) || rangeIndexes.endIndex < 0) throw new Error("range.endIndex must be an integer >=0");
+		if (rangeIndexes.endIndex <= rangeIndexes.startIndex) throw new Error("range.endIndex must be greater than range.startIndex");
+		const result = await this._makeSingleUpdateRequest("deleteDimension", { range: {
+			sheetId: this.sheetId,
+			dimension: columnsOrRows,
+			startIndex: rangeIndexes.startIndex,
+			endIndex: rangeIndexes.endIndex
+		} });
+		if (columnsOrRows === "ROWS") {
+			this._shiftRowCacheBulk(rangeIndexes.startIndex, rangeIndexes.endIndex);
+			this._shiftCellCacheRows(rangeIndexes.startIndex, rangeIndexes.endIndex);
+		} else this._shiftCellCacheColumns(rangeIndexes.startIndex, rangeIndexes.endIndex);
+		return result;
+	}
+	/**
+	* Delete rows by index
+	*/
+	async deleteRows(startIndex, endIndex) {
+		return this.deleteDimension("ROWS", {
+			startIndex,
+			endIndex
+		});
+	}
+	/**
+	* Delete columns by index
+	*/
+	async deleteColumns(startIndex, endIndex) {
+		return this.deleteDimension("COLUMNS", {
+			startIndex,
+			endIndex
+		});
+	}
+	async deleteEmbeddedObject() {
+		throw new Error("Not implemented yet");
+	}
+	/**
+	* Deletes a filter view from the sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteFilterViewRequest
+	*/
+	async deleteFilterView(filterId) {
+		await this._makeSingleUpdateRequest("deleteFilterView", { filterId });
+	}
+	/**
+	* Duplicates a filter view
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DuplicateFilterViewRequest
+	*/
+	async duplicateFilterView(filterId) {
+		await this._makeSingleUpdateRequest("duplicateFilterView", { filterId });
+	}
 	/**
 	* Duplicate worksheet within the document
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DuplicateSheetRequest
 	*/
 	async duplicate(options) {
@@ -837,9 +1127,22 @@ var GoogleSpreadsheetWorksheet = class {
 		})).properties.sheetId;
 		return this._spreadsheet.sheetsById[newSheetId];
 	}
-	async findReplace() {}
+	/**
+	* Finds and replaces text in cells
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#FindReplaceRequest
+	*/
+	async findReplace(find, replacement, options, range) {
+		await this._makeSingleUpdateRequest("findReplace", {
+			find,
+			replacement,
+			...options,
+			...range ? { range: this._addSheetIdToRange(range) } : { sheetId: this.sheetId }
+		});
+	}
 	/**
 	* Inserts rows or columns at a particular index
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#InsertDimensionRequest
 	*/
 	async insertDimension(columnsOrRows, rangeIndexes, inheritFromBefore) {
@@ -862,27 +1165,143 @@ var GoogleSpreadsheetWorksheet = class {
 	}
 	/**
 	* insert empty cells in a range, shifting existing cells in the specified direction
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#InsertRangeRequest
 	*/
 	async insertRange(range, shiftDimension) {
-		return this._makeSingleUpdateRequest("insertRange", {
+		await this._makeSingleUpdateRequest("insertRange", {
+			range: this._addSheetIdToRange(range),
+			shiftDimension
+		});
+	}
+	/**
+	* Moves rows or columns to a different position within the sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#MoveDimensionRequest
+	*/
+	async moveDimension(dimension, source, destinationIndex) {
+		await this._makeSingleUpdateRequest("moveDimension", {
+			source: {
+				sheetId: this.sheetId,
+				dimension,
+				startIndex: source.startIndex,
+				endIndex: source.endIndex
+			},
+			destinationIndex
+		});
+	}
+	async updateEmbeddedObjectPosition() {
+		throw new Error("Not implemented yet");
+	}
+	/**
+	* Inserts data into the spreadsheet starting at the specified coordinate
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#PasteDataRequest
+	*/
+	async pasteData(coordinate, data, delimiter, type = "PASTE_NORMAL") {
+		await this._makeSingleUpdateRequest("pasteData", {
+			coordinate: {
+				sheetId: this.sheetId,
+				rowIndex: coordinate.rowIndex,
+				columnIndex: coordinate.columnIndex
+			},
+			data,
+			delimiter,
+			type
+		});
+	}
+	/**
+	* Splits a column of text into multiple columns based on a delimiter
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#TextToColumnsRequest
+	*/
+	async textToColumns(source, delimiterType, delimiter) {
+		await this._makeSingleUpdateRequest("textToColumns", {
+			source: this._addSheetIdToRange(source),
+			delimiterType,
+			...delimiter && { delimiter }
+		});
+	}
+	/**
+	* Updates properties of a filter view
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UpdateFilterViewRequest
+	*/
+	async updateFilterView(filter, fields) {
+		await this._makeSingleUpdateRequest("updateFilterView", {
+			filter,
+			fields
+		});
+	}
+	/**
+	* Deletes a range of cells and shifts remaining cells
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteRangeRequest
+	*/
+	async deleteRange(range, shiftDimension) {
+		await this._makeSingleUpdateRequest("deleteRange", {
 			range: this._addSheetIdToRange(range),
 			shiftDimension
 		});
 	}
-	async moveDimension() {}
-	async updateEmbeddedObjectPosition() {}
-	async pasteData() {}
-	async textToColumns() {}
-	async updateFilterView() {}
-	async deleteRange() {}
-	async appendDimension() {}
-	async addConditionalFormatRule() {}
-	async updateConditionalFormatRule() {}
-	async deleteConditionalFormatRule() {}
-	async sortRange() {}
+	/**
+	* Appends rows or columns to the end of a sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AppendDimensionRequest
+	*/
+	async appendDimension(dimension, length) {
+		await this._makeSingleUpdateRequest("appendDimension", {
+			sheetId: this.sheetId,
+			dimension,
+			length
+		});
+	}
+	/**
+	* Adds a new conditional formatting rule at the given index
+	* All subsequent rules' indexes are incremented
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AddConditionalFormatRuleRequest
+	*/
+	async addConditionalFormatRule(rule, index) {
+		await this._makeSingleUpdateRequest("addConditionalFormatRule", {
+			rule,
+			index
+		});
+	}
+	/**
+	* Updates a conditional format rule at the given index, or moves a conditional format rule to another index
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UpdateConditionalFormatRuleRequest
+	*/
+	async updateConditionalFormatRule(options) {
+		await this._makeSingleUpdateRequest("updateConditionalFormatRule", options);
+	}
+	/**
+	* Deletes a conditional format rule at the given index
+	* All subsequent rules' indexes are decremented
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteConditionalFormatRuleRequest
+	*/
+	async deleteConditionalFormatRule(index, sheetId) {
+		await this._makeSingleUpdateRequest("deleteConditionalFormatRule", {
+			index,
+			sheetId: sheetId ?? this.sheetId
+		});
+	}
+	/**
+	* Sorts data in rows based on sort order per column
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#SortRangeRequest
+	*/
+	async sortRange(range, sortSpecs) {
+		await this._makeSingleUpdateRequest("sortRange", {
+			range: this._addSheetIdToRange(range),
+			sortSpecs
+		});
+	}
 	/**
 	* Sets (or unsets) a data validation rule to every cell in the range
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#SetDataValidationRequest
 	*/
 	async setDataValidation(range, rule) {
@@ -894,9 +1313,20 @@ var GoogleSpreadsheetWorksheet = class {
 			...rule && { rule }
 		});
 	}
-	async setBasicFilter() {}
+	/**
+	* Sets the basic filter on this sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#SetBasicFilterRequest
+	*/
+	async setBasicFilter(filter) {
+		await this._makeSingleUpdateRequest("setBasicFilter", { filter: {
+			...filter,
+			...filter.range && { range: this._addSheetIdToRange(filter.range) }
+		} });
+	}
 	/**
 	* add a new protected range to the sheet
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AddProtectedRangeRequest
 	*/
 	async addProtectedRange(protectedRange) {
@@ -905,6 +1335,7 @@ var GoogleSpreadsheetWorksheet = class {
 	}
 	/**
 	* update an existing protected range
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UpdateProtectedRangeRequest
 	*/
 	async updateProtectedRange(protectedRangeId, protectedRange) {
@@ -918,6 +1349,7 @@ var GoogleSpreadsheetWorksheet = class {
 	}
 	/**
 	* delete a protected range by ID
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteProtectedRangeRequest
 	*/
 	async deleteProtectedRange(protectedRangeId) {
@@ -925,6 +1357,7 @@ var GoogleSpreadsheetWorksheet = class {
 	}
 	/**
 	* auto-resize rows or columns to fit their contents
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AutoResizeDimensionsRequest
 	*/
 	async autoResizeDimensions(columnsOrRows, rangeIndexes) {
@@ -934,34 +1367,126 @@ var GoogleSpreadsheetWorksheet = class {
 			...rangeIndexes
 		} });
 	}
-	async addChart() {}
-	async updateChartSpec() {}
-	async updateBanding() {}
-	async addBanding() {}
-	async deleteBanding() {}
-	async createDeveloperMetadata() {}
-	async updateDeveloperMetadata() {}
-	async deleteDeveloperMetadata() {}
-	async randomizeRange() {}
-	async addDimensionGroup() {}
-	async deleteDimensionGroup() {}
-	async updateDimensionGroup() {}
-	async trimWhitespace() {}
-	async deleteDuplicates() {}
-	async addSlicer() {}
-	async updateSlicerSpec() {}
-	/** delete this worksheet */
+	async addChart() {
+		throw new Error("Not implemented yet");
+	}
+	async updateChartSpec() {
+		throw new Error("Not implemented yet");
+	}
+	/**
+	* Updates properties of a banded range
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UpdateBandingRequest
+	*/
+	async updateBanding(bandedRange, fields) {
+		await this._makeSingleUpdateRequest("updateBanding", {
+			bandedRange,
+			fields
+		});
+	}
+	/**
+	* Adds a new banded range to the sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AddBandingRequest
+	*/
+	async addBanding(bandedRange) {
+		return this._makeSingleUpdateRequest("addBanding", { bandedRange });
+	}
+	/**
+	* Deletes a banded range from the sheet
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteBandingRequest
+	*/
+	async deleteBanding(bandedRangeId) {
+		await this._makeSingleUpdateRequest("deleteBanding", { bandedRangeId });
+	}
+	/**
+	* Creates developer metadata
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#CreateDeveloperMetadataRequest
+	*/
+	async createDeveloperMetadata(developerMetadata) {
+		return this._makeSingleUpdateRequest("createDeveloperMetadata", { developerMetadata });
+	}
+	/**
+	* Updates developer metadata that matches the specified filters
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UpdateDeveloperMetadataRequest
+	*/
+	async updateDeveloperMetadata(dataFilters, developerMetadata, fields) {
+		await this._makeSingleUpdateRequest("updateDeveloperMetadata", {
+			dataFilters,
+			developerMetadata,
+			fields
+		});
+	}
+	/**
+	* Deletes developer metadata that matches the specified filter
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteDeveloperMetadataRequest
+	*/
+	async deleteDeveloperMetadata(dataFilter) {
+		await this._makeSingleUpdateRequest("deleteDeveloperMetadata", { dataFilter });
+	}
+	/**
+	* Randomizes the order of rows in a range
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#RandomizeRangeRequest
+	*/
+	async randomizeRange(range) {
+		await this._makeSingleUpdateRequest("randomizeRange", { range: this._addSheetIdToRange(range) });
+	}
+	async addDimensionGroup() {
+		throw new Error("Not implemented yet");
+	}
+	async deleteDimensionGroup() {
+		throw new Error("Not implemented yet");
+	}
+	async updateDimensionGroup() {
+		throw new Error("Not implemented yet");
+	}
+	/**
+	* Trims whitespace from the start and end of each cell's text
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#TrimWhitespaceRequest
+	*/
+	async trimWhitespace(range) {
+		await this._makeSingleUpdateRequest("trimWhitespace", { range: this._addSheetIdToRange(range) });
+	}
+	/**
+	* Removes duplicate rows from a range based on specified columns
+	*
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteDuplicatesRequest
+	*/
+	async deleteDuplicates(range, comparisonColumns) {
+		await this._makeSingleUpdateRequest("deleteDuplicates", {
+			range: this._addSheetIdToRange(range),
+			...comparisonColumns && { comparisonColumns }
+		});
+	}
+	async addSlicer() {
+		throw new Error("Not implemented yet");
+	}
+	async updateSlicerSpec() {
+		throw new Error("Not implemented yet");
+	}
+	/**
+	* delete this worksheet
+	*/
 	async delete() {
 		return this._spreadsheet.deleteSheet(this.sheetId);
 	}
 	/**
 	* copies this worksheet into another document/spreadsheet
+	*
 	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.sheets/copyTo
-	* */
+	*/
 	async copyToSpreadsheet(destinationSpreadsheetId) {
 		return await this._spreadsheet.sheetsApi.post(`sheets/${this.sheetId}:copyTo`, { json: { destinationSpreadsheetId } }).json();
 	}
-	/** clear data in the sheet - either the entire sheet or a specific range */
+	/**
+	* clear data in the sheet - either the entire sheet or a specific range
+	*/
 	async clear(a1Range) {
 		const range = a1Range ? `!${a1Range}` : "";
 		await this._spreadsheet.sheetsApi.post(`values/${this.encodedA1SheetName}${range}:clear`);
@@ -1054,7 +1579,8 @@ var GoogleSpreadsheet = class GoogleSpreadsheet {
 	* initialize new GoogleSpreadsheet
 	* @category Initialization
 	* */
-	constructor(spreadsheetId, auth) {
+	constructor(spreadsheetId, auth, options) {
+		const { retryConfig } = options || {};
 		this.spreadsheetId = spreadsheetId;
 		this.auth = auth;
 		this._rawSheets = {};
@@ -1065,14 +1591,16 @@ var GoogleSpreadsheet = class GoogleSpreadsheet {
 			hooks: {
 				beforeRequest: [(r) => this._setAuthRequestHook(r)],
 				beforeError: [(e) => this._errorHook(e)]
-			}
+			},
+			retry: retryConfig
 		});
 		this.driveApi = ky.create({
 			prefixUrl: `${DRIVE_API_BASE_URL}/${spreadsheetId}`,
 			hooks: {
 				beforeRequest: [(r) => this._setAuthRequestHook(r)],
 				beforeError: [(e) => this._errorHook(e)]
-			}
+			},
+			retry: retryConfig
 		});
 	}
 	/** @internal */
@@ -1252,6 +1780,7 @@ var GoogleSpreadsheet = class GoogleSpreadsheet {
 			if (isString(filter)) return readOnlyMode ? filter : { a1Range: filter };
 			if (isObject(filter)) {
 				if (readOnlyMode) throw new Error("Only A1 ranges are supported when fetching cells with read-only access (using only an API key)");
+				if ("developerMetadataLookup" in filter) return { developerMetadataLookup: filter.developerMetadataLookup };
 				return { gridRange: filter };
 			}
 			throw new Error("Each filter must be an A1 range string or a gridrange object");
@@ -1366,6 +1895,15 @@ var GoogleSpreadsheet = class GoogleSpreadsheet {
 	async deletePermission(permissionId) {
 		await this.driveApi.delete(`permissions/${permissionId}`);
 	}
+	/**
+	* search for developer metadata entries matching the given filters
+	* @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.developerMetadata/search
+	*/
+	async searchDeveloperMetadata(filters) {
+		const data = await (await this.sheetsApi.post("developerMetadata:search", { json: { dataFilters: filters } })).json();
+		if (!data.matchedDeveloperMetadata) return [];
+		return data.matchedDeveloperMetadata.map((m) => m.developerMetadata);
+	}
 	static async createNewSpreadsheetDocument(auth, properties) {
 		if (getAuthMode(auth) === AUTH_MODES.API_KEY) throw new Error("Cannot use api key only to create a new spreadsheet - it is only usable for read-only access of public docs");
 		const authConfig = await getRequestAuthConfig(auth);