@airtable/blocks 0.0.0-experimental-d5ee5e823-20250501 → 0.0.0-experimental-15dc8a3ea-20250616

package/dist/cjs/base/models/table.js

@@ -17,7 +17,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = exports.WatchableTableKeys = void 0;
 require("core-js/modules/es.array.find.js");
 require("core-js/modules/es.array.includes.js");
-require("core-js/modules/es.array.map.js");
 require("core-js/modules/es.object.to-string.js");
 require("core-js/modules/es.string.includes.js");
 require("core-js/modules/web.dom-collections.for-each.js");
@@ -599,1075 +598,7 @@ var Table = /*#__PURE__*/function (_TableCore) {
         return _createFieldAsync.apply(this, arguments);
       }
       return createFieldAsync;
-    }()
-    /**
-     * Updates cell values for a record.
-     *
-     * Throws an error if the user does not have permission to update the given cell values in
-     * the record, or if invalid input is provided (eg. invalid cell values).
-     *
-     * Refer to {@link FieldType} for cell value write formats.
-     *
-     * This action is asynchronous: `await` the returned promise if you wish to wait for the updated
-     * cell values to be persisted to Airtable servers.
-     * Updates are applied optimistically locally, so your changes will be reflected in your extension
-     * before the promise resolves.
-     *
-     * @param recordOrRecordId the record to update
-     * @param fields cell values to update in that record, specified as object mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * function updateRecord(record, recordFields) {
-     *     if (table.hasPermissionToUpdateRecord(record, recordFields)) {
-     *         table.updateRecordAsync(record, recordFields);
-     *     }
-     *     // The updated values will now show in your extension (eg in
-     *     // `table.selectRecords()` result) but are still being saved to Airtable
-     *     // servers (e.g. other users may not be able to see them yet).
-     * }
-     *
-     * async function updateRecordAsync(record, recordFields) {
-     *     if (table.hasPermissionToUpdateRecord(record, recordFields)) {
-     *         await table.updateRecordAsync(record, recordFields);
-     *     }
-     *     // New record has been saved to Airtable servers.
-     *     alert(`record with ID ${record.id} has been updated`);
-     * }
-     *
-     * // Fields can be specified by name or ID
-     * updateRecord(record1, {
-     *     'Post Title': 'How to make: orange-mango pound cake',
-     *     'Publication Date': '2020-01-01',
-     * });
-     * updateRecord(record2, {
-     *     [postTitleField.id]: 'Cake decorating tips & tricks',
-     *     [publicationDateField.id]: '2020-02-02',
-     * });
-     *
-     * // Cell values should generally have format matching the output of
-     * // record.getCellValue() for the field being updated
-     * updateRecord(record1, {
-     *     'Category (single select)': {name: 'Recipe'},
-     *     'Tags (multiple select)': [{name: 'Desserts'}, {id: 'someChoiceId'}],
-     *     'Images (attachment)': [{url: 'http://mywebsite.com/cake.png'}],
-     *     'Related posts (linked records)': [{id: 'someRecordId'}],
-     * });
-     * ```
-     */
-    )
-  }, {
-    key: "updateRecordAsync",
-    value: (function () {
-      var _updateRecordAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(recordOrRecordId, fields) {
-        var recordId;
-        return _regenerator.default.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              recordId = typeof recordOrRecordId === 'string' ? recordOrRecordId : recordOrRecordId.id;
-              _context4.next = 3;
-              return this.updateRecordsAsync([{
-                id: recordId,
-                fields
-              }]);
-            case 3:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function updateRecordAsync(_x7, _x8) {
-        return _updateRecordAsync.apply(this, arguments);
-      }
-      return updateRecordAsync;
-    }()
-    /**
-     * Checks whether the current user has permission to perform the given record update.
-     *
-     * Accepts partial input, in the same format as {@link updateRecordAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * Returns `{hasPermission: true}` if the current user can update the specified record,
-     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
-     * used to display an error message to the user.
-     *
-     * @param recordOrRecordId the record to update
-     * @param fields cell values to update in that record, specified as object mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * // Check if user can update specific fields for a specific record.
-     * const updateRecordCheckResult =
-     *     table.checkPermissionsForUpdateRecord(record, {
-     *         'Post Title': 'How to make: orange-mango pound cake',
-     *         'Publication Date': '2020-01-01',
-     *     });
-     * if (!updateRecordCheckResult.hasPermission) {
-     *     alert(updateRecordCheckResult.reasonDisplayString);
-     * }
-     *
-     * // Like updateRecordAsync, you can use either field names or field IDs.
-     * const updateRecordCheckResultWithFieldIds =
-     *     table.checkPermissionsForUpdateRecord(record, {
-     *         [postTitleField.id]: 'Cake decorating tips & tricks',
-     *         [publicationDateField.id]: '2020-02-02',
-     *     });
-     *
-     * // Check if user could update a given record, when you don't know the
-     * // specific fields that will be updated yet (e.g. to check whether you should
-     * // allow a user to select a certain record to update).
-     * const updateUnknownFieldsCheckResult =
-     *     table.checkPermissionsForUpdateRecord(record);
-     *
-     * // Check if user could update specific fields, when you don't know the
-     * // specific record that will be updated yet. (for example, if the field is
-     * // selected by the user and you want to check if your extension can write to it).
-     * const updateUnknownRecordCheckResult =
-     *     table.checkPermissionsForUpdateRecord(undefined, {
-     *         'My field name': 'updated value',
-     *         // You can use undefined if you know you're going to update a field,
-     *         // but don't know the new cell value yet.
-     *         'Another field name': undefined,
-     *     });
-     *
-     * // Check if user could perform updates within the table, without knowing the
-     * // specific record or fields that will be updated yet (e.g., to render your
-     * // extension in "read only" mode).
-     * const updateUnknownRecordAndFieldsCheckResult =
-     *     table.checkPermissionsForUpdateRecord();
-     * ```
-     */
-    )
-  }, {
-    key: "checkPermissionsForUpdateRecord",
-    value: function checkPermissionsForUpdateRecord(recordOrRecordId, fields) {
-      var recordId = typeof recordOrRecordId === 'object' && recordOrRecordId !== null ? recordOrRecordId.id : recordOrRecordId;
-      return this.checkPermissionsForUpdateRecords([{
-        id: recordId,
-        fields
-      }]);
-    }
-    /**
-     * An alias for `checkPermissionsForUpdateRecord(recordOrRecordId, fields).hasPermission`.
-     *
-     * Checks whether the current user has permission to perform the given record update.
-     *
-     * Accepts partial input, in the same format as {@link updateRecordAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * @param recordOrRecordId the record to update
-     * @param fields cell values to update in that record, specified as object mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * // Check if user can update specific fields for a specific record.
-     * const canUpdateRecord = table.hasPermissionToUpdateRecord(record, {
-     *     'Post Title': 'How to make: orange-mango pound cake',
-     *     'Publication Date': '2020-01-01',
-     * });
-     * if (!canUpdateRecord) {
-     *     alert('not allowed!');
-     * }
-     *
-     * // Like updateRecordAsync, you can use either field names or field IDs.
-     * const canUpdateRecordWithFieldIds =
-     *     table.hasPermissionToUpdateRecord(record, {
-     *         [postTitleField.id]: 'Cake decorating tips & tricks',
-     *         [publicationDateField.id]: '2020-02-02',
-     *     });
-     *
-     * // Check if user could update a given record, when you don't know the
-     * // specific fields that will be updated yet (e.g. to check whether you should
-     * // allow a user to select a certain record to update).
-     * const canUpdateUnknownFields = table.hasPermissionToUpdateRecord(record);
-     *
-     * // Check if user could update specific fields, when you don't know the
-     * // specific record that will be updated yet (e.g. if the field is selected
-     * // by the user and you want to check if your extension can write to it).
-     * const canUpdateUnknownRecord =
-     *     table.hasPermissionToUpdateRecord(undefined, {
-     *         'My field name': 'updated value',
-     *         // You can use undefined if you know you're going to update a field,
-     *         // but don't know the new cell value yet.
-     *         'Another field name': undefined,
-     *     });
-     *
-     * // Check if user could perform updates within the table, without knowing the
-     * // specific record or fields that will be updated yet. (for example, to
-     * // render your extension in "read only" mode)
-     * const canUpdateUnknownRecordAndFields = table.hasPermissionToUpdateRecord();
-     * ```
-     */
-  }, {
-    key: "hasPermissionToUpdateRecord",
-    value: function hasPermissionToUpdateRecord(recordOrRecordId, fields) {
-      return this.checkPermissionsForUpdateRecord(recordOrRecordId, fields).hasPermission;
-    }
-    /**
-     * Updates cell values for records.
-     *
-     * Throws an error if the user does not have permission to update the given cell values in
-     * the records, or if invalid input is provided (eg. invalid cell values).
-     *
-     * Refer to {@link FieldType} for cell value write formats.
-     *
-     * You may only update up to 50 records in one call to `updateRecordsAsync`.
-     * See [Write back to Airtable](/guides/write-back-to-airtable) for more information
-     * about write limits.
-     *
-     * This action is asynchronous: `await` the returned promise if you wish to wait for the
-     * updates to be persisted to Airtable servers.
-     * Updates are applied optimistically locally, so your changes will be reflected in your extension
-     * before the promise resolves.
-     *
-     * @param records Array of objects containing recordId and fields/cellValues to update for that record (specified as an object mapping `FieldId` or field name to cell value)
-     * @example
-     * ```js
-     * const recordsToUpdate = [
-     *     // Fields can be specified by name or ID
-     *     {
-     *         id: record1.id,
-     *         fields: {
-     *             'Post Title': 'How to make: orange-mango pound cake',
-     *             'Publication Date': '2020-01-01',
-     *         },
-     *     },
-     *     {
-     *         id: record2.id,
-     *         fields: {
-     *             // Sets the cell values to be empty.
-     *             'Post Title': '',
-     *             'Publication Date': '',
-     *         },
-     *     },
-     *     {
-     *         id: record3.id,
-     *         fields: {
-     *             [postTitleField.id]: 'Cake decorating tips & tricks',
-     *             [publicationDateField.id]: '2020-02-02',
-     *         },
-     *     },
-     *     // Cell values should generally have format matching the output of
-     *     // record.getCellValue() for the field being updated
-     *     {
-     *         id: record4.id,
-     *         fields: {
-     *             'Category (single select)': {name: 'Recipe'},
-     *             'Tags (multiple select)': [{name: 'Desserts'}, {id: 'choiceId'}],
-     *             'Images (attachment)': [{url: 'http://mywebsite.com/cake.png'}],
-     *             'Related posts (linked records)': [{id: 'someRecordId'}],
-     *         },
-     *     },
-     * ];
-     *
-     * function updateRecords() {
-     *     if (table.hasPermissionToUpdateRecords(recordsToUpdate)) {
-     *         table.updateRecordsAsync(recordsToUpdate);
-     *     }
-     *     // The records are now updated within your extension (eg will be reflected in
-     *     // `table.selectRecords()`) but are still being saved to Airtable servers
-     *     // (e.g. they may not be updated for other users yet).
-     * }
-     *
-     * async function updateRecordsAsync() {
-     *     if (table.hasPermissionToUpdateRecords(recordsToUpdate)) {
-     *         await table.updateRecordsAsync(recordsToUpdate);
-     *     }
-     *     // Record updates have been saved to Airtable servers.
-     *     alert('records have been updated');
-     * }
-     * ```
-     */
-  }, {
-    key: "updateRecordsAsync",
-    value: (function () {
-      var _updateRecordsAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(records) {
-        var recordsWithCellValuesByFieldId;
-        return _regenerator.default.wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              recordsWithCellValuesByFieldId = records.map(record => ({
-                id: record.id,
-                cellValuesByFieldId: this._cellValuesByFieldIdOrNameToCellValuesByFieldId(record.fields)
-              }));
-              _context5.next = 3;
-              return this._sdk.__mutations.applyMutationAsync({
-                type: _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES,
-                tableId: this.id,
-                records: recordsWithCellValuesByFieldId,
-                opts: {
-                  parseDateCellValueInColumnTimeZone: true
-                }
-              });
-            case 3:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee5, this);
-      }));
-      function updateRecordsAsync(_x9) {
-        return _updateRecordsAsync.apply(this, arguments);
-      }
-      return updateRecordsAsync;
-    }()
-    /**
-     * Checks whether the current user has permission to perform the given record updates.
-     *
-     * Accepts partial input, in the same format as {@link updateRecordsAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * Returns `{hasPermission: true}` if the current user can update the specified records,
-     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
-     * used to display an error message to the user.
-     *
-     * @param records Array of objects containing recordId and fields/cellValues to update for that record (specified as an object mapping `FieldId` or field name to cell value)
-     * @example
-     * ```js
-     * const recordsToUpdate = [
-     *     {
-     *         // Validating a complete record update
-     *         id: record1.id,
-     *         fields: {
-     *             'Post Title': 'How to make: orange-mango pound cake',
-     *             'Publication Date': '2020-01-01',
-     *         },
-     *     },
-     *     {
-     *         // Like updateRecordsAsync, fields can be specified by name or ID
-     *         id: record2.id,
-     *         fields: {
-     *             [postTitleField.id]: 'Cake decorating tips & tricks',
-     *             [publicationDateField.id]: '2020-02-02',
-     *         },
-     *     },
-     *     {
-     *         // Validating an update to a specific record, not knowing what
-     *         // fields will be updated
-     *         id: record3.id,
-     *     },
-     *     {
-     *         // Validating an update to specific cell values, not knowing what
-     *         // record will be updated
-     *         fields: {
-     *             'My field name': 'updated value for unknown record',
-     *             // You can use undefined if you know you're going to update a
-     *             // field, but don't know the new cell value yet.
-     *             'Another field name': undefined,
-     *         },
-     *     },
-     * ];
-     *
-     * const updateRecordsCheckResult =
-     *     table.checkPermissionsForUpdateRecords(recordsToUpdate);
-     * if (!updateRecordsCheckResult.hasPermission) {
-     *     alert(updateRecordsCheckResult.reasonDisplayString);
-     * }
-     *
-     * // Check if user could potentially update records.
-     * // Equivalent to table.checkPermissionsForUpdateRecord()
-     * const updateUnknownRecordAndFieldsCheckResult =
-     *     table.checkPermissionsForUpdateRecords();
-     * ```
-     */
-    )
-  }, {
-    key: "checkPermissionsForUpdateRecords",
-    value: function checkPermissionsForUpdateRecords(records) {
-      return this._sdk.__mutations.checkPermissionsForMutation({
-        type: _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES,
-        tableId: this.id,
-        records: records ? records.map(record => ({
-          id: record.id || undefined,
-          cellValuesByFieldId: record.fields ? this._cellValuesByFieldIdOrNameToCellValuesByFieldId(record.fields) : undefined
-        })) : undefined
-      });
-    }
-    /**
-     * An alias for `checkPermissionsForUpdateRecords(records).hasPermission`.
-     *
-     * Checks whether the current user has permission to perform the given record updates.
-     *
-     * Accepts partial input, in the same format as {@link updateRecordsAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * @param records Array of objects containing recordId and fields/cellValues to update for that record (specified as an object mapping `FieldId` or field name to cell value)
-     * @example
-     * ```js
-     * const recordsToUpdate = [
-     *     {
-     *         // Validating a complete record update
-     *         id: record1.id,
-     *         fields: {
-     *             'Post Title': 'How to make: orange-mango pound cake',
-     *             'Publication Date': '2020-01-01',
-     *         },
-     *     },
-     *     {
-     *         // Like updateRecordsAsync, fields can be specified by name or ID
-     *         id: record2.id,
-     *         fields: {
-     *             [postTitleField.id]: 'Cake decorating tips & tricks',
-     *             [publicationDateField.id]: '2020-02-02',
-     *         },
-     *     },
-     *     {
-     *         // Validating an update to a specific record, not knowing what
-     *         // fields will be updated
-     *         id: record3.id,
-     *     },
-     *     {
-     *         // Validating an update to specific cell values, not knowing what
-     *         // record will be updated
-     *         fields: {
-     *             'My field name': 'updated value for unknown record',
-     *             // You can use undefined if you know you're going to update a
-     *             // field, but don't know the new cell value yet.
-     *             'Another field name': undefined,
-     *         },
-     *     },
-     * ];
-     *
-     * const canUpdateRecords = table.hasPermissionToUpdateRecords(recordsToUpdate);
-     * if (!canUpdateRecords) {
-     *     alert('not allowed');
-     * }
-     *
-     * // Check if user could potentially update records.
-     * // Equivalent to table.hasPermissionToUpdateRecord()
-     * const canUpdateUnknownRecordsAndFields =
-     *     table.hasPermissionToUpdateRecords();
-     * ```
-     */
-  }, {
-    key: "hasPermissionToUpdateRecords",
-    value: function hasPermissionToUpdateRecords(records) {
-      return this.checkPermissionsForUpdateRecords(records).hasPermission;
-    }
-    /**
-     * Delete the given record.
-     *
-     * Throws an error if the user does not have permission to delete the given record.
-     *
-     * This action is asynchronous: `await` the returned promise if you wish to wait for the
-     * delete to be persisted to Airtable servers.
-     * Updates are applied optimistically locally, so your changes will be reflected in your extension
-     * before the promise resolves.
-     *
-     * @param recordOrRecordId the record to be deleted
-     * @example
-     * ```js
-     * function deleteRecord(record) {
-     *     if (table.hasPermissionToDeleteRecord(record)) {
-     *         table.deleteRecordAsync(record);
-     *     }
-     *     // The record is now deleted within your extension (eg will not be returned
-     *     // in `table.selectRecords`) but it is still being saved to Airtable
-     *     // servers (e.g. it may not look deleted to other users yet).
-     * }
-     *
-     * async function deleteRecordAsync(record) {
-     *     if (table.hasPermissionToDeleteRecord(record)) {
-     *         await table.deleteRecordAsync(record);
-     *     }
-     *     // Record deletion has been saved to Airtable servers.
-     *     alert('record has been deleted');
-     * }
-     * ```
-     */
-  }, {
-    key: "deleteRecordAsync",
-    value: (function () {
-      var _deleteRecordAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(recordOrRecordId) {
-        return _regenerator.default.wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
-            case 0:
-              _context6.next = 2;
-              return this.deleteRecordsAsync([recordOrRecordId]);
-            case 2:
-            case "end":
-              return _context6.stop();
-          }
-        }, _callee6, this);
-      }));
-      function deleteRecordAsync(_x10) {
-        return _deleteRecordAsync.apply(this, arguments);
-      }
-      return deleteRecordAsync;
-    }()
-    /**
-     * Checks whether the current user has permission to delete the specified record.
-     *
-     * Accepts optional input, in the same format as {@link deleteRecordAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * Returns `{hasPermission: true}` if the current user can delete the specified record,
-     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
-     * used to display an error message to the user.
-     *
-     * @param recordOrRecordId the record to be deleted
-     * @example
-     * ```js
-     * // Check if user can delete a specific record
-     * const deleteRecordCheckResult =
-     *     table.checkPermissionsForDeleteRecord(record);
-     * if (!deleteRecordCheckResult.hasPermission) {
-     *     alert(deleteRecordCheckResult.reasonDisplayString);
-     * }
-     *
-     * // Check if user could potentially delete a record.
-     * // Use when you don't know the specific record you want to delete yet (for
-     * // example, to show/hide UI controls that let you select a record to delete).
-     * const deleteUnknownRecordCheckResult =
-     *     table.checkPermissionsForDeleteRecord();
-     * ```
-     */
-    )
-  }, {
-    key: "checkPermissionsForDeleteRecord",
-    value: function checkPermissionsForDeleteRecord(recordOrRecordId) {
-      return this.checkPermissionsForDeleteRecords(recordOrRecordId ? [recordOrRecordId] : undefined);
-    }
-    /**
-     * An alias for `checkPermissionsForDeleteRecord(recordOrRecordId).hasPermission`.
-     *
-     * Checks whether the current user has permission to delete the specified record.
-     *
-     * Accepts optional input, in the same format as {@link deleteRecordAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * @param recordOrRecordId the record to be deleted
-     * @example
-     * ```js
-     * // Check if user can delete a specific record
-     * const canDeleteRecord = table.hasPermissionToDeleteRecord(record);
-     * if (!canDeleteRecord) {
-     *     alert('not allowed');
-     * }
-     *
-     * // Check if user could potentially delete a record.
-     * // Use when you don't know the specific record you want to delete yet (for
-     * // example, to show/hide UI controls that let you select a record to delete).
-     * const canDeleteUnknownRecord = table.hasPermissionToDeleteRecord();
-     * ```
-     */
-  }, {
-    key: "hasPermissionToDeleteRecord",
-    value: function hasPermissionToDeleteRecord(recordOrRecordId) {
-      return this.checkPermissionsForDeleteRecord(recordOrRecordId).hasPermission;
-    }
-    /**
-     * Delete the given records.
-     *
-     * Throws an error if the user does not have permission to delete the given records.
-     *
-     * You may only delete up to 50 records in one call to `deleteRecordsAsync`.
-     * See [Write back to Airtable](/guides/write-back-to-airtable#size-limits-rate-limits) for
-     * more information about write limits.
-     *
-     * This action is asynchronous: `await` the returned promise if you wish to wait for the
-     * delete to be persisted to Airtable servers.
-     * Updates are applied optimistically locally, so your changes will be reflected in your extension
-     * before the promise resolves.
-     *
-     * @param recordsOrRecordIds Array of Records and RecordIds
-     * @example
-     * ```js
-     *
-     * function deleteRecords(records) {
-     *     if (table.hasPermissionToDeleteRecords(records)) {
-     *         table.deleteRecordsAsync(records);
-     *     }
-     *     // The records are now deleted within your extension (eg will not be
-     *     // returned in `table.selectRecords()`) but are still being saved to
-     *     // Airtable servers (e.g. they may not look deleted to other users yet).
-     * }
-     *
-     * async function deleteRecordsAsync(records) {
-     *     if (table.hasPermissionToDeleteRecords(records)) {
-     *         await table.deleteRecordsAsync(records);
-     *     }
-     *     // Record deletions have been saved to Airtable servers.
-     *     alert('records have been deleted');
-     * }
-     * ```
-     */
-  }, {
-    key: "deleteRecordsAsync",
-    value: (function () {
-      var _deleteRecordsAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(recordsOrRecordIds) {
-        var recordIds;
-        return _regenerator.default.wrap(function _callee7$(_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
-            case 0:
-              recordIds = recordsOrRecordIds.map(recordOrRecordId => typeof recordOrRecordId === 'string' ? recordOrRecordId : recordOrRecordId.id);
-              _context7.next = 3;
-              return this._sdk.__mutations.applyMutationAsync({
-                type: _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS,
-                tableId: this.id,
-                recordIds
-              });
-            case 3:
-            case "end":
-              return _context7.stop();
-          }
-        }, _callee7, this);
-      }));
-      function deleteRecordsAsync(_x11) {
-        return _deleteRecordsAsync.apply(this, arguments);
-      }
-      return deleteRecordsAsync;
-    }()
-    /**
-     * Checks whether the current user has permission to delete the specified records.
-     *
-     * Accepts optional input, in the same format as {@link deleteRecordsAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * Returns `{hasPermission: true}` if the current user can delete the specified records,
-     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
-     * used to display an error message to the user.
-     *
-     * @param recordsOrRecordIds the records to be deleted
-     * @example
-     * ```js
-     * // Check if user can delete specific records
-     * const deleteRecordsCheckResult =
-     *     table.checkPermissionsForDeleteRecords([record1, record2]);
-     * if (!deleteRecordsCheckResult.hasPermission) {
-     *     alert(deleteRecordsCheckResult.reasonDisplayString);
-     * }
-     *
-     * // Check if user could potentially delete records.
-     * // Use when you don't know the specific records you want to delete yet (for
-     * // example, to show/hide UI controls that let you select records to delete).
-     * // Equivalent to table.hasPermissionToDeleteRecord()
-     * const deleteUnknownRecordsCheckResult =
-     *     table.checkPermissionsForDeleteRecords();
-     * ```
-     */
-    )
-  }, {
-    key: "checkPermissionsForDeleteRecords",
-    value: function checkPermissionsForDeleteRecords(recordsOrRecordIds) {
-      return this._sdk.__mutations.checkPermissionsForMutation({
-        type: _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS,
-        tableId: this.id,
-        recordIds: recordsOrRecordIds ? recordsOrRecordIds.map(recordOrRecordId => typeof recordOrRecordId === 'string' ? recordOrRecordId : recordOrRecordId.id) : undefined
-      });
-    }
-    /**
-     * An alias for `checkPermissionsForDeleteRecords(recordsOrRecordIds).hasPermission`.
-     *
-     * Checks whether the current user has permission to delete the specified records.
-     *
-     * Accepts optional input, in the same format as {@link deleteRecordsAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * @param recordsOrRecordIds the records to be deleted
-     * @example
-     * ```js
-     * // Check if user can delete specific records
-     * const canDeleteRecords =
-     *     table.hasPermissionToDeleteRecords([record1, record2]);
-     * if (!canDeleteRecords) {
-     *     alert('not allowed!');
-     * }
-     *
-     * // Check if user could potentially delete records.
-     * // Use when you don't know the specific records you want to delete yet (for
-     * // example, to show/hide UI controls that let you select records to delete).
-     * // Equivalent to table.hasPermissionToDeleteRecord()
-     * const canDeleteUnknownRecords = table.hasPermissionToDeleteRecords();
-     * ```
-     */
-  }, {
-    key: "hasPermissionToDeleteRecords",
-    value: function hasPermissionToDeleteRecords(recordsOrRecordIds) {
-      return this.checkPermissionsForDeleteRecords(recordsOrRecordIds).hasPermission;
-    }
-
-    /**
-     * Creates a new record with the specified cell values.
-     *
-     * Throws an error if the user does not have permission to create the given records, or
-     * if invalid input is provided (eg. invalid cell values).
-     *
-     * Refer to {@link FieldType} for cell value write formats.
-     *
-     * This action is asynchronous: `await` the returned promise if you wish to wait for the new
-     * record to be persisted to Airtable servers.
-     * Updates are applied optimistically locally, so your changes will be reflected in your extension
-     * before the promise resolves.
-     *
-     * The returned promise will resolve to the RecordId of the new record once it is persisted.
-     *
-     * @param fields object mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * function createNewRecord(recordFields) {
-     *     if (table.hasPermissionToCreateRecord(recordFields)) {
-     *         table.createRecordAsync(recordFields);
-     *     }
-     *     // You can now access the new record in your extension (eg
-     *     // `table.selectRecords()`) but it is still being saved to Airtable
-     *     // servers (e.g. other users may not be able to see it yet).
-     * }
-     *
-     * async function createNewRecordAsync(recordFields) {
-     *     if (table.hasPermissionToCreateRecord(recordFields)) {
-     *         const newRecordId = await table.createRecordAsync(recordFields);
-     *     }
-     *     // New record has been saved to Airtable servers.
-     *     alert(`new record with ID ${newRecordId} has been created`);
-     * }
-     *
-     * // Fields can be specified by name or ID
-     * createNewRecord({
-     *     'Project Name': 'Advertising campaign',
-     *     'Budget': 100,
-     * });
-     * createNewRecord({
-     *     [projectNameField.id]: 'Cat video',
-     *     [budgetField.id]: 200,
-     * });
-     *
-     * // Cell values should generally have format matching the output of
-     * // record.getCellValue() for the field being updated
-     * createNewRecord({
-     *     'Project Name': 'Cat video 2'
-     *     'Category (single select)': {name: 'Video'},
-     *     'Tags (multiple select)': [{name: 'Cats'}, {id: 'someChoiceId'}],
-     *     'Assets (attachment)': [{url: 'http://mywebsite.com/cats.mp4'}],
-     *     'Related projects (linked records)': [{id: 'someRecordId'}],
-     * });
-     * ```
-     */
-  }, {
-    key: "createRecordAsync",
-    value: (function () {
-      var _createRecordAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
-        var fields,
-          recordIds,
-          _args8 = arguments;
-        return _regenerator.default.wrap(function _callee8$(_context8) {
-          while (1) switch (_context8.prev = _context8.next) {
-            case 0:
-              fields = _args8.length > 0 && _args8[0] !== undefined ? _args8[0] : {};
-              _context8.next = 3;
-              return this.createRecordsAsync([{
-                fields
-              }]);
-            case 3:
-              recordIds = _context8.sent;
-              return _context8.abrupt("return", recordIds[0]);
-            case 5:
-            case "end":
-              return _context8.stop();
-          }
-        }, _callee8, this);
-      }));
-      function createRecordAsync() {
-        return _createRecordAsync.apply(this, arguments);
-      }
-      return createRecordAsync;
-    }()
-    /**
-     * Checks whether the current user has permission to create the specified record.
-     *
-     * Accepts partial input, in the same format as {@link createRecordAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * Returns `{hasPermission: true}` if the current user can create the specified record,
-     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
-     * used to display an error message to the user.
-     *
-     * @param fields object mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * // Check if user can create a specific record, when you already know what
-     * // fields/cell values will be set for the record.
-     * const createRecordCheckResult = table.checkPermissionsForCreateRecord({
-     *     'Project Name': 'Advertising campaign',
-     *     'Budget': 100,
-     * });
-     * if (!createRecordCheckResult.hasPermission) {
-     *     alert(createRecordCheckResult.reasonDisplayString);
-     * }
-     *
-     * // Like createRecordAsync, you can use either field names or field IDs.
-     * const checkResultWithFieldIds = table.checkPermissionsForCreateRecord({
-     *     [projectNameField.id]: 'Cat video',
-     *     [budgetField.id]: 200,
-     * });
-     *
-     * // Check if user could potentially create a record.
-     * // Use when you don't know the specific fields/cell values yet (for example,
-     * // to show or hide UI controls that let you start creating a record.)
-     * const createUnknownRecordCheckResult =
-     *     table.checkPermissionsForCreateRecord();
-     * ```
-     */
-    )
-  }, {
-    key: "checkPermissionsForCreateRecord",
-    value: function checkPermissionsForCreateRecord(fields) {
-      return this.checkPermissionsForCreateRecords([{
-        fields: fields || undefined
-      }]);
-    }
-    /**
-     * An alias for `checkPermissionsForCreateRecord(fields).hasPermission`.
-     *
-     * Checks whether the current user has permission to create the specified record.
-     *
-     * Accepts partial input, in the same format as {@link createRecordAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * @param fields object mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * // Check if user can create a specific record, when you already know what
-     * // fields/cell values will be set for the record.
-     * const canCreateRecord = table.hasPermissionToCreateRecord({
-     *     'Project Name': 'Advertising campaign',
-     *     'Budget': 100,
-     * });
-     * if (!canCreateRecord) {
-     *     alert('not allowed!');
-     * }
-     *
-     * // Like createRecordAsync, you can use either field names or field IDs.
-     * const canCreateRecordWithFieldIds = table.hasPermissionToCreateRecord({
-     *     [projectNameField.id]: 'Cat video',
-     *     [budgetField.id]: 200,
-     * });
-     *
-     * // Check if user could potentially create a record.
-     * // Use when you don't know the specific fields/cell values yet (for example,
-     * // to show or hide UI controls that let you start creating a record.)
-     * const canCreateUnknownRecord = table.hasPermissionToCreateRecord();
-     * ```
-     */
-  }, {
-    key: "hasPermissionToCreateRecord",
-    value: function hasPermissionToCreateRecord(fields) {
-      return this.checkPermissionsForCreateRecord(fields).hasPermission;
-    }
-    /**
-     * Creates new records with the specified cell values.
-     *
-     * Throws an error if the user does not have permission to create the given records, or
-     * if invalid input is provided (eg. invalid cell values).
-     *
-     * Refer to {@link FieldType} for cell value write formats.
-     *
-     * You may only create up to 50 records in one call to `createRecordsAsync`.
-     * See [Write back to Airtable](/guides/write-back-to-airtable#size-limits-rate-limits) for
-     * more information about write limits.
-     *
-     * This action is asynchronous: `await` the returned promise if you wish to wait for the new
-     * record to be persisted to Airtable servers.
-     * Updates are applied optimistically locally, so your changes will be reflected in your extension
-     * before the promise resolves.
-     *
-     * The returned promise will resolve to an array of RecordIds of the new records once the new
-     * records are persisted.
-     *
-     * @param records Array of objects with a `fields` key mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * const recordDefs = [
-     *     // Fields can be specified by name or ID
-     *     {
-     *          fields: {
-     *              'Project Name': 'Advertising campaign',
-     *              'Budget': 100,
-     *          },
-     *     },
-     *     {
-     *          fields: {
-     *              [projectNameField.id]: 'Cat video',
-     *              [budgetField.id]: 200,
-     *          },
-     *     },
-     *     // Specifying no fields will create a new record with no cell values set
-     *     {
-     *          fields: {},
-     *     },
-     *     // Cell values should generally have format matching the output of
-     *     // record.getCellValue() for the field being updated
-     *     {
-     *          fields: {
-     *              'Project Name': 'Cat video 2'
-     *              'Category (single select)': {name: 'Video'},
-     *              'Tags (multiple select)': [{name: 'Cats'}, {id: 'choiceId'}],
-     *              'Assets (attachment)': [{url: 'http://mywebsite.com/cats.mp4'}],
-     *              'Related projects (linked records)': [{id: 'someRecordId'}],
-     *          },
-     *     },
-     * ];
-     *
-     * function createNewRecords() {
-     *     if (table.hasPermissionToCreateRecords(recordDefs)) {
-     *         table.createRecordsAsync(recordDefs);
-     *     }
-     *     // You can now access the new records in your extension (e.g.
-     *     // `table.selectRecords()`) but they are still being saved to Airtable
-     *     // servers (e.g. other users may not be able to see them yet.)
-     * }
-     *
-     * async function createNewRecordsAsync() {
-     *     if (table.hasPermissionToCreateRecords(recordDefs)) {
-     *         const newRecordIds = await table.createRecordsAsync(recordDefs);
-     *     }
-     *     // New records have been saved to Airtable servers.
-     *     alert(`new records with IDs ${newRecordIds} have been created`);
-     * }
-     * ```
-     */
-  }, {
-    key: "createRecordsAsync",
-    value: (function () {
-      var _createRecordsAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(records) {
-        var recordsToCreate;
-        return _regenerator.default.wrap(function _callee9$(_context9) {
-          while (1) switch (_context9.prev = _context9.next) {
-            case 0:
-              recordsToCreate = records.map(recordDef => {
-                var recordDefKeys = (0, _private_utils.keys)(recordDef);
-                var fields;
-                if (recordDefKeys.length === 1 && recordDefKeys[0] === 'fields') {
-                  fields = recordDef.fields;
-                } else {
-                  throw (0, _error_utils.spawnError)('Invalid record format. Please define field mappings using a `fields` key for each record definition object');
-                }
-                return {
-                  id: this._sdk.__airtableInterface.idGenerator.generateRecordId(),
-                  cellValuesByFieldId: this._cellValuesByFieldIdOrNameToCellValuesByFieldId(fields)
-                };
-              });
-              _context9.next = 3;
-              return this._sdk.__mutations.applyMutationAsync({
-                type: _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS,
-                tableId: this.id,
-                records: recordsToCreate,
-                opts: {
-                  parseDateCellValueInColumnTimeZone: true
-                }
-              });
-            case 3:
-              return _context9.abrupt("return", recordsToCreate.map(record => record.id));
-            case 4:
-            case "end":
-              return _context9.stop();
-          }
-        }, _callee9, this);
-      }));
-      function createRecordsAsync(_x12) {
-        return _createRecordsAsync.apply(this, arguments);
-      }
-      return createRecordsAsync;
-    }()
-    /**
-     * Checks whether the current user has permission to create the specified records.
-     *
-     * Accepts partial input, in the same format as {@link createRecordsAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * Returns `{hasPermission: true}` if the current user can create the specified records,
-     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
-     * used to display an error message to the user.
-     *
-     * @param records Array of objects mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * // Check if user can create specific records, when you already know what
-     * // fields/cell values will be set for the records.
-     * const createRecordsCheckResult = table.checkPermissionsForCreateRecords([
-     *     // Like createRecordsAsync, fields can be specified by name or ID
-     *     {
-     *          fields: {
-     *              'Project Name': 'Advertising campaign',
-     *              'Budget': 100,
-     *          },
-     *     },
-     *     {
-     *          fields: {
-     *              [projectNameField.id]: 'Cat video',
-     *              [budgetField.id]: 200,
-     *          },
-     *     },
-     *     {},
-     * ]);
-     * if (!createRecordsCheckResult.hasPermission) {
-     *     alert(createRecordsCheckResult.reasonDisplayString);
-     * }
-     *
-     * // Check if user could potentially create records.
-     * // Use when you don't know the specific fields/cell values yet (for example,
-     * // to show or hide UI controls that let you start creating records.)
-     * // Equivalent to table.checkPermissionsForCreateRecord()
-     * const createUnknownRecordCheckResult =
-     *     table.checkPermissionsForCreateRecords();
-     * ```
-     */
-    )
-  }, {
-    key: "checkPermissionsForCreateRecords",
-    value: function checkPermissionsForCreateRecords(records) {
-      return this._sdk.__mutations.checkPermissionsForMutation({
-        type: _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS,
-        tableId: this.id,
-        records: records ? records.map(record => ({
-          id: undefined,
-          cellValuesByFieldId: record.fields ? this._cellValuesByFieldIdOrNameToCellValuesByFieldId(record.fields) : undefined
-        })) : undefined
-      });
-    }
-    /**
-     * An alias for `checkPermissionsForCreateRecords(records).hasPermission`.
-     *
-     * Checks whether the current user has permission to create the specified records.
-     *
-     * Accepts partial input, in the same format as {@link createRecordsAsync}.
-     * The more information provided, the more accurate the permissions check will be.
-     *
-     * @param records Array of objects mapping `FieldId` or field name to value for that field.
-     * @example
-     * ```js
-     * // Check if user can create specific records, when you already know what fields/cell values
-     * // will be set for the records.
-     * const canCreateRecords = table.hasPermissionToCreateRecords([
-     *     // Like createRecordsAsync, fields can be specified by name or ID
-     *     {
-     *          fields: {
-     *              'Project Name': 'Advertising campaign',
-     *              'Budget': 100,
-     *          }
-     *     },
-     *     {
-     *          fields: {
-     *              [projectNameField.id]: 'Cat video',
-     *              [budgetField.id]: 200,
-     *          }
-     *     },
-     *     {},
-     * ]);
-     * if (!canCreateRecords) {
-     *     alert('not allowed');
-     * }
-     *
-     * // Check if user could potentially create records.
-     * // Use when you don't know the specific fields/cell values yet (for example,
-     * // to show or hide UI controls that let you start creating records).
-     * // Equivalent to table.hasPermissionToCreateRecord()
-     * const canCreateUnknownRecords = table.hasPermissionToCreateRecords();
-     * ```
-     */
-  }, {
-    key: "hasPermissionToCreateRecords",
-    value: function hasPermissionToCreateRecords(records) {
-      return this.checkPermissionsForCreateRecords(records).hasPermission;
-    }
-
-    /** @internal */
+    }() /** @internal */)
   }, {
     key: "__triggerOnChangeForDirtyPaths",
     value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {