@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-3649c7162-20250904

package/dist/esm/base/models/record_store.js

@@ -0,0 +1,475 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.WatchableRecordStoreKeys = void 0;
+var _private_utils = require("../../shared/private_utils");
+var _error_utils = require("../../shared/error_utils");
+var _record_store_core = _interopRequireWildcard(require("../../shared/models/record_store_core"));
+var _abstract_model_with_async_data = _interopRequireDefault(require("./abstract_model_with_async_data"));
+var _record = _interopRequireDefault(require("./record"));
+var _view_data_store = _interopRequireDefault(require("./view_data_store"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const WatchableRecordStoreKeys = exports.WatchableRecordStoreKeys = Object.freeze({
+  ..._record_store_core.WatchableRecordStoreKeysCore
+});
+
+/**
+ * The string case is to accommodate prefix keys
+ *
+ * @internal
+ */
+
+/**
+ * One RecordStore exists per table, and contains all the record data associated with that table.
+ * Table itself is for schema information only, so isn't the appropriate place for this data.
+ *
+ * @internal
+ */
+class RecordStore extends _record_store_core.default {
+  static _className = 'RecordStore';
+  static _isWatchableKey(key) {
+    return (0, _private_utils.isEnumValue)(WatchableRecordStoreKeys, key) || key.startsWith(_record_store_core.WatchableCellValuesInFieldKeyPrefix);
+  }
+  _viewDataStoresByViewId = {};
+  constructor(sdk, tableId) {
+    super(sdk, tableId);
+    const onChange = this._onChange.bind(this);
+    const clearRecordModels = () => {
+      this._recordModelsById = {};
+    };
+    this._loader = new RecordStoreAsyncLoader(sdk, tableId, onChange, clearRecordModels);
+  }
+  _constructRecord(recordId, parentTable) {
+    return new _record.default(this._sdk, this, parentTable, recordId);
+  }
+  get _dataOrNullIfDeleted() {
+    return this._loader._dataOrNullIfDeleted;
+  }
+  getViewDataStore(viewId) {
+    if (this._viewDataStoresByViewId[viewId]) {
+      return this._viewDataStoresByViewId[viewId];
+    }
+    (0, _error_utils.invariant)(this._data.viewsById[viewId], 'view must exist');
+    const viewDataStore = new _view_data_store.default(this._sdk, this, viewId);
+    this._viewDataStoresByViewId[viewId] = viewDataStore;
+    return viewDataStore;
+  }
+  watch(keys, callback, context) {
+    const validKeys = super.watch(keys, callback, context);
+    const fieldIdsToLoad = this._loader._getFieldIdsToLoadFromWatchableKeys(validKeys);
+    if (fieldIdsToLoad.length > 0) {
+      (0, _private_utils.fireAndForgetPromise)(async () => {
+        await this._loader.loadCellValuesInFieldIdsAsync(fieldIdsToLoad, this._onChange.bind(this));
+      });
+    }
+    return validKeys;
+  }
+  unwatch(keys, callback, context) {
+    const validKeys = super.unwatch(keys, callback, context);
+    const fieldIdsToUnload = this._loader._getFieldIdsToLoadFromWatchableKeys(validKeys);
+    if (fieldIdsToUnload.length > 0) {
+      this._loader.unloadCellValuesInFieldIds(fieldIdsToUnload);
+    }
+    return validKeys;
+  }
+
+  /**
+   * The record IDs in this table. The order is arbitrary since records are
+   * only ordered in the context of a specific view.
+   */
+  get recordIds() {
+    const recordsById = this._data.recordsById;
+    (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
+    return Object.keys(recordsById);
+  }
+  __onDataDeletion() {
+    // also need to call unloadCellValuesInFieldIds because otherwise
+    // on the hyperbase side, the old record store would still be subscribed
+    // to the cell values and it will refuse a request for new subscription
+    for (const fieldId of Object.keys(this._loader._cellValuesRetainCountByFieldId)) {
+      while (this._loader._cellValuesRetainCountByFieldId[fieldId] && this._loader._cellValuesRetainCountByFieldId[fieldId] > 0) {
+        this._loader.unloadCellValuesInFieldIds([fieldId]);
+      }
+    }
+    this._loader._forceUnload();
+
+    // similarly unsubscribe from the view data.
+    // this comes after _forceUnload to avoid over releasing the table data.
+    for (const viewDataStore of (0, _private_utils.values)(this._viewDataStoresByViewId)) {
+      viewDataStore.__onDataDeletion();
+    }
+  }
+
+  // #region async data loading
+  // wrapper methods over RecordStoreAsyncLoader
+  get isDeleted() {
+    return this._loader.isDeleted || super.isDeleted;
+  }
+  get isDataLoaded() {
+    return !this.isDeleted && this._loader.isDataLoaded;
+  }
+  async loadDataAsync() {
+    return await this._loader.loadDataAsync();
+  }
+  unloadData() {
+    return this._loader.unloadData();
+  }
+  get isRecordMetadataLoaded() {
+    return this._loader.isRecordMetadataLoaded;
+  }
+  async loadRecordMetadataAsync() {
+    return await this._loader.loadRecordMetadataAsync(this._onChange.bind(this));
+  }
+  unloadRecordMetadata() {
+    return this._loader.unloadRecordMetadata();
+  }
+  areCellValuesLoadedForFieldId(fieldId) {
+    return this._loader.areCellValuesLoadedForFieldId(fieldId);
+  }
+  async loadCellValuesInFieldIdsAsync(fieldIds) {
+    return await this._loader.loadCellValuesInFieldIdsAsync(fieldIds, this._onChange.bind(this));
+  }
+  unloadCellValuesInFieldIds(fieldIds) {
+    return this._loader.unloadCellValuesInFieldIds(fieldIds);
+  }
+  // #endregion
+
+  triggerOnChangeForDirtyPaths(dirtyPaths) {
+    if (this.isRecordMetadataLoaded && dirtyPaths.recordsById) {
+      super.triggerOnChangeForDirtyPaths(dirtyPaths);
+    }
+    if (dirtyPaths.viewOrder) {
+      // clean up deleted views
+      for (const [viewId, viewDataStore] of (0, _private_utils.entries)(this._viewDataStoresByViewId)) {
+        if (viewDataStore.isDeleted) {
+          viewDataStore.__onDataDeletion();
+          delete this._viewDataStoresByViewId[viewId];
+        }
+      }
+    }
+  }
+}
+
+/** @internal */
+class RecordStoreAsyncLoader extends _abstract_model_with_async_data.default {
+  static _shouldLoadDataForKey(key) {
+    // "Data" means *all* cell values in the table. If only watching records/recordIds,
+    // we'll just load record metadata (id, createdTime, commentCount).
+    // If only watching specific fields, we'll just load cell values in those
+    // fields. Both of those scenarios are handled manually by this class,
+    // instead of relying on AbstractModelWithAsyncData.
+    return key === WatchableRecordStoreKeys.cellValues;
+  }
+  // There is a lot of duplication here and in AbstractModelWithAsyncData.
+  // Alternatively, phase out AbstractModelWithAsyncData as a superclass
+  // and instead create a helper class for managing each part of the data
+  // tree that is loaded.
+  _areCellValuesLoadedByFieldId = {};
+  _pendingCellValuesLoadPromiseByFieldId = {};
+  _cellValuesRetainCountByFieldId = {};
+  _timeoutForRemovingFieldIds = null;
+  constructor(sdk, tableId, onChange, clearRecordModels) {
+    super(sdk, `${tableId}-RecordStore`);
+    this._airtableInterface = sdk.__airtableInterface;
+    this.tableId = tableId;
+    this._onChange = onChange;
+    this._clearRecordModels = clearRecordModels;
+    // A bit of a hack, but we use the primary field ID to load record
+    // metadata (see _getFieldIdForCausingRecordMetadataToLoad). We copy the
+    // ID here instead of calling this.primaryField.id since that would crash
+    // when the table is getting unloaded after being deleted.
+    this._primaryFieldId = this._data.primaryFieldId;
+  }
+  _onChangeIsDataLoaded() {
+    // noop
+  }
+
+  /**
+   * Record metadata means record IDs, createdTime, and commentCount are loaded.
+   * Record metadata must be loaded before creating, deleting, or updating records.
+   */
+  get isRecordMetadataLoaded() {
+    return !!this._data.recordsById;
+  }
+  async loadRecordMetadataAsync(onChange) {
+    return await this.loadCellValuesInFieldIdsAsync([this._getFieldIdForCausingRecordMetadataToLoad()], onChange);
+  }
+  unloadRecordMetadata() {
+    this.unloadCellValuesInFieldIds([this._getFieldIdForCausingRecordMetadataToLoad()]);
+  }
+  _getFieldIdsToLoadFromWatchableKeys(keys) {
+    const fieldIdsToLoad = [];
+    for (const key of keys) {
+      if (key.startsWith(_record_store_core.WatchableCellValuesInFieldKeyPrefix)) {
+        const fieldId = key.substring(_record_store_core.WatchableCellValuesInFieldKeyPrefix.length);
+        fieldIdsToLoad.push(fieldId);
+      } else if (key === WatchableRecordStoreKeys.records || key === WatchableRecordStoreKeys.recordIds) {
+        fieldIdsToLoad.push(this._getFieldIdForCausingRecordMetadataToLoad());
+      }
+    }
+    return fieldIdsToLoad;
+  }
+  _getFieldIdForCausingRecordMetadataToLoad() {
+    // As a shortcut, we'll load the primary field cell values to
+    // cause record metadata (id, createdTime, commentCount) to be loaded
+    // and subscribed to. In the future, we could add an explicit model
+    // bridge to fetch and subscribe to row metadata.
+    return this._primaryFieldId;
+  }
+  areCellValuesLoadedForFieldId(fieldId) {
+    return this.isDataLoaded || this._areCellValuesLoadedByFieldId[fieldId] || false;
+  }
+  async loadCellValuesInFieldIdsAsync(fieldIds, onChange) {
+    this._assertNotForceUnloaded();
+    const fieldIdsWhichAreNotAlreadyLoadedOrLoading = [];
+    const pendingLoadPromises = [];
+    for (const fieldId of fieldIds) {
+      if (this._cellValuesRetainCountByFieldId[fieldId] !== undefined) {
+        this._cellValuesRetainCountByFieldId[fieldId]++;
+      } else {
+        this._cellValuesRetainCountByFieldId[fieldId] = 1;
+      }
+
+      // NOTE: we don't use this.areCellValuesLoadedForFieldId() here because
+      // that will return true if the cell values are loaded as a result
+      // of the entire table being loaded. In that scenario, we still
+      // want to separately load the cell values for the field so there
+      // is a separate subscription. Otherwise, when the table data unloads,
+      // the field data would unload as well. This can be improved by just
+      // subscribing to the field data without fetching it, since the cell
+      // values are already in the block frame.
+      if (!this._areCellValuesLoadedByFieldId[fieldId]) {
+        const pendingLoadPromise = this._pendingCellValuesLoadPromiseByFieldId[fieldId];
+        if (pendingLoadPromise) {
+          pendingLoadPromises.push(pendingLoadPromise);
+        } else {
+          fieldIdsWhichAreNotAlreadyLoadedOrLoading.push(fieldId);
+        }
+      }
+    }
+    if (fieldIdsWhichAreNotAlreadyLoadedOrLoading.length > 0) {
+      // Could inline _loadCellValuesInFieldIdsAsync, but following the
+      // pattern from AbstractModelWithAsyncData where the public method
+      // is responsible for updating retain counts and the private method
+      // actually fetches data.
+      const loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise = this._loadCellValuesInFieldIdsAsync(fieldIdsWhichAreNotAlreadyLoadedOrLoading);
+      pendingLoadPromises.push(loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise);
+      for (const fieldId of fieldIdsWhichAreNotAlreadyLoadedOrLoading) {
+        this._pendingCellValuesLoadPromiseByFieldId[fieldId] = loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise;
+      }
+      // Doing `.then` instead of performing these actions directly in
+      // _loadCellValuesInFieldIdsAsync so this is similar to
+      // AbstractModelWithAsyncData. The idea is to refactor to avoid code
+      // duplication, so keeping them similar for now hopefully will make the
+      // refactor simpler.
+      loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise.then(changedKeys => {
+        for (const fieldId of fieldIdsWhichAreNotAlreadyLoadedOrLoading) {
+          this._areCellValuesLoadedByFieldId[fieldId] = true;
+          this._pendingCellValuesLoadPromiseByFieldId[fieldId] = undefined;
+        }
+        for (const key of changedKeys) {
+          onChange(key);
+        }
+      });
+    }
+    // Since we are incrementing fieldIds, it's necessary to restart any pending timeouts
+    // to unload data. This is because it's possible for a timeout to fire while a queryResult
+    // is actively unloading, and erroneously unload data. Data must be unloaded _after_ the queryResult.
+    this._restartTimeoutToUnloadFieldIdsIfTimeoutIsActive();
+    await Promise.all(pendingLoadPromises);
+  }
+  async _loadCellValuesInFieldIdsAsync(fieldIds) {
+    const {
+      recordsById: newRecordsById
+    } = await this._airtableInterface.fetchAndSubscribeToCellValuesInFieldsAsync(this.tableId, fieldIds);
+
+    // Merge with existing data.
+    if (!this._data.recordsById) {
+      this._data.recordsById = {};
+    }
+    const {
+      recordsById: existingRecordsById
+    } = this._data;
+    for (const [recordId, newRecordObj] of (0, _private_utils.entries)((0, _private_utils.cast)(newRecordsById))) {
+      if (!(0, _private_utils.has)(existingRecordsById, recordId)) {
+        existingRecordsById[recordId] = newRecordObj;
+      } else {
+        const existingRecordObj = existingRecordsById[recordId];
+
+        // Metadata (createdTime, commentCount) should generally be up to date,
+        // but can be out of date in the rare scenario where realtime
+        // data has not yet been delivered to the SDK, but is populated in hyperbase
+        // at the time this new fetch is executed.
+        // istanbul ignore next
+        if (existingRecordObj.commentCount !== newRecordObj.commentCount) {
+          const isCommentCountTypesSame = typeof existingRecordObj.commentCount !== typeof newRecordObj.commentCount;
+          (0, _error_utils.logErrorToSentry)('comment count out of sync - types are same: %s', {
+            isCommentCountTypesSame
+          });
+        }
+
+        // istanbul ignore next
+        if (existingRecordObj.createdTime !== newRecordObj.createdTime) {
+          const isCreatedTimeTypesSame = typeof existingRecordObj.createdTime !== typeof newRecordObj.createdTime;
+          (0, _error_utils.logErrorToSentry)('created time out of sync - types are same: %s', {
+            isCreatedTimeTypesSame
+          });
+        }
+        if (!existingRecordObj.cellValuesByFieldId) {
+          existingRecordObj.cellValuesByFieldId = {};
+        }
+        const existingCellValuesByFieldId = existingRecordObj.cellValuesByFieldId;
+        for (let i = 0; i < fieldIds.length; i++) {
+          const fieldId = fieldIds[i];
+          existingCellValuesByFieldId[fieldId] = newRecordObj.cellValuesByFieldId ? newRecordObj.cellValuesByFieldId[fieldId] : undefined;
+        }
+      }
+    }
+    const changedKeys = fieldIds.map(fieldId => _record_store_core.WatchableCellValuesInFieldKeyPrefix + fieldId);
+    // Need to trigger onChange for records and recordIds since watching either
+    // of those causes record metadata to be loaded (via _getFieldIdForCausingRecordMetadataToLoad)
+    // and by convention we trigger a change event when data loads.
+    changedKeys.push(WatchableRecordStoreKeys.records);
+    changedKeys.push(WatchableRecordStoreKeys.recordIds);
+    // Also trigger cellValues changes since the cell values in the fields
+    // are now loaded.
+    changedKeys.push(WatchableRecordStoreKeys.cellValues);
+    return changedKeys;
+  }
+  unloadCellValuesInFieldIds(fieldIds) {
+    if (this._isForceUnloaded) {
+      return;
+    }
+    for (const fieldId of fieldIds) {
+      let fieldRetainCount = this._cellValuesRetainCountByFieldId[fieldId] || 0;
+      fieldRetainCount--;
+      if (fieldRetainCount < 0) {
+        console.log('Field data over-released'); // eslint-disable-line no-console
+        fieldRetainCount = 0;
+      }
+      this._cellValuesRetainCountByFieldId[fieldId] = fieldRetainCount;
+    }
+    // Don't unload immediately. Wait a while in case something else
+    // requests the data, so we can avoid going back to liveapp or
+    // the network.
+    this._startTimeoutToUnloadForFieldIdsIfNeeded();
+  }
+
+  // This unloads all fields where the retain count is at zero, and if any other
+  // request to unload fields is pending - cancels it and restarts it.
+  // This is important because fields must always be unloaded at least __DATA_UNLOAD_DELAY_MS
+  // after the unload is requested so that any QueryResults relying on them properly
+  // unload either first, or at the same time
+  _startTimeoutToUnloadForFieldIdsIfNeeded() {
+    const fieldIdsWithZeroRetainCount = [];
+    for (const [fieldId, retainCount] of Object.entries(this._cellValuesRetainCountByFieldId)) {
+      if (retainCount === 0) {
+        fieldIdsWithZeroRetainCount.push(fieldId);
+      }
+    }
+
+    // Cancel any pending timeouts before proceeding
+    // This should be canceled even if there aren't any fields to unload as that means
+    // that there has been loading that's occured that makes the pending request invalid
+    if (this._timeoutForRemovingFieldIds) {
+      clearTimeout(this._timeoutForRemovingFieldIds);
+      this._timeoutForRemovingFieldIds = null;
+    }
+    if (fieldIdsWithZeroRetainCount.length > 0) {
+      this._timeoutForRemovingFieldIds = setTimeout(() => {
+        // Make sure the retain count is still zero, since it may
+        // have been incremented before the timeout fired.
+        const fieldIdsToUnload = fieldIdsWithZeroRetainCount.filter(fieldId => {
+          // It's necessary to also check that the field is loaded, as it's possible
+          // for an unload to trigger with fields that have already been removed.
+          return this._cellValuesRetainCountByFieldId[fieldId] === 0 && this._areCellValuesLoadedByFieldId[fieldId];
+        });
+        // istanbul ignore else
+        if (fieldIdsToUnload.length > 0) {
+          // Set _areCellValuesLoadedByFieldId to false before calling _unloadCellValuesInFieldIds
+          // since _unloadCellValuesInFieldIds will check if *any* fields are still loaded.
+          for (const fieldId of fieldIdsToUnload) {
+            this._areCellValuesLoadedByFieldId[fieldId] = false;
+          }
+          this._unloadCellValuesInFieldIds(fieldIdsToUnload);
+        } else {
+          // This shouldn't be possible because we always cancel the timer if fieldIds loadedness
+          // status ever changes
+          (0, _error_utils.logErrorToSentry)('fieldIdsToUnload is empty, this likely means the unload timer is not properly reset.');
+        }
+        this._timeoutForRemovingFieldIds = null;
+      }, _abstract_model_with_async_data.default.__DATA_UNLOAD_DELAY_MS);
+    }
+  }
+  _restartTimeoutToUnloadFieldIdsIfTimeoutIsActive() {
+    if (this._timeoutForRemovingFieldIds) {
+      this._startTimeoutToUnloadForFieldIdsIfNeeded();
+    }
+  }
+  _unloadCellValuesInFieldIds(fieldIds) {
+    this._airtableInterface.unsubscribeFromCellValuesInFields(this.tableId, fieldIds);
+    this._afterUnloadDataOrUnloadCellValuesInFieldIds(fieldIds);
+  }
+  async _loadDataAsync() {
+    const tableData = await this._airtableInterface.fetchAndSubscribeToTableDataAsync(this.tableId);
+    this._data.recordsById = tableData.recordsById;
+    const changedKeys = [WatchableRecordStoreKeys.records, WatchableRecordStoreKeys.recordIds, WatchableRecordStoreKeys.cellValues];
+    for (const fieldId of (0, _private_utils.keys)(this._data.fieldsById)) {
+      changedKeys.push(_record_store_core.WatchableCellValuesInFieldKeyPrefix + fieldId);
+    }
+    return changedKeys;
+  }
+  _unloadData() {
+    this._airtableInterface.unsubscribeFromTableData(this.tableId);
+    this._afterUnloadDataOrUnloadCellValuesInFieldIds();
+  }
+  _afterUnloadDataOrUnloadCellValuesInFieldIds(unloadedFieldIds) {
+    const areAnyFieldsLoaded = this.isDataLoaded || (0, _private_utils.values)(this._areCellValuesLoadedByFieldId).some(isLoaded => isLoaded);
+    if (!this.isDeleted) {
+      if (!areAnyFieldsLoaded) {
+        this._data.recordsById = undefined;
+      } else if (!this.isDataLoaded) {
+        let fieldIdsToClear;
+        // This should be impossible - for fields should always be loaded
+        // when attempting to unload specific fields. This codepath was previously possible
+        // due to a bug. It could be converted to an invariant, but that is higher risk.
+        // istanbul ignore if
+        if (unloadedFieldIds) {
+          // Specific fields were unloaded, so clear out the cell values for those fields.
+          fieldIdsToClear = unloadedFieldIds;
+          (0, _error_utils.logErrorToSentry)('Field Ids are being unloaded when record_store is unloaded');
+        } else {
+          // The entire table was unloaded, but some individual fields are still loaded.
+          // We need to clear out the cell values of every field that was unloaded.
+          // This is kind of slow, but hopefully uncommon.
+          const fieldIds = Object.keys(this._data.fieldsById);
+          fieldIdsToClear = fieldIds.filter(fieldId => !this._areCellValuesLoadedByFieldId[fieldId]);
+        }
+        const {
+          recordsById
+        } = this._data;
+        for (const recordObj of (0, _private_utils.values)(recordsById || {})) {
+          for (let i = 0; i < fieldIdsToClear.length; i++) {
+            const fieldId = fieldIdsToClear[i];
+            if (recordObj.cellValuesByFieldId) {
+              recordObj.cellValuesByFieldId[fieldId] = undefined;
+            }
+          }
+        }
+      }
+    }
+    if (!areAnyFieldsLoaded) {
+      this._clearRecordModels();
+    }
+  }
+  get _dataOrNullIfDeleted() {
+    return this._baseData.tablesById[this.tableId] ?? null;
+  }
+}
+
+/** @internal */
+var _default = exports.default = RecordStore;

package/dist/esm/base/models/session.js

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _session_core = require("../../shared/models/session_core");
+var _mutations = require("../types/mutations");
+/**
+ * Model class representing the current user's session.
+ *
+ * @example
+ * ```js
+ * import {useSession} from '@airtable/blocks/base/ui';
+ *
+ * function Username() {
+ *     const session = useSession();
+ *
+ *     if (session.currentUser !== null) {
+ *         return <span>The current user's name is {session.currentUser.name}</span>;
+ *     } else {
+ *         return <span>This extension is being viewed in a public share</span>;
+ *     }
+ * }
+ * ```
+ * @docsPath models/Session
+ */
+class Session extends _session_core.SessionCore {
+  /** @internal */
+  static _className = 'Session';
+  /**
+   * Checks whether the current user has permission to update any records in the current base. For
+   * more granular permission checks, see {@link Table.checkPermissionsForUpdateRecords}.
+   *
+   * Returns `{hasPermission: true}` if the current user can update records,
+   * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may
+   * be used to display an error message to the user.
+   *
+   * @example
+   * ```js
+   * import {useSession} from '@airtable/blocks/base/ui';
+   *
+   * function UpdateButton({onClick}) {
+   *     const session = useSession();
+   *     const updateRecordsCheckResult = session.checkPermissionsForUpdateRecords();
+   *     const deniedReason = updateRecordsCheckResult.hasPermission
+   *         ? <span>{updateRecordsCheckResult.reasonDisplayString}</span>
+   *         : null;
+   *
+   *     return <div>
+   *         {deniedReason}
+   *         <button onClick={onClick} disabled={!!deniedReason}>
+   *             Update
+   *         </button>
+   *     </div>;
+   * }
+   */
+  checkPermissionsForUpdateRecords() {
+    return this._sdk.__mutations.checkPermissionsForMutation({
+      type: _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES,
+      tableId: undefined,
+      records: undefined
+    });
+  }
+  /**
+   * An alias for `session.checkPermissionsForUpdateRecords().hasPermission`. For more granular
+   * permission checks, see {@link Table.hasPermissionToUpdateRecords}.
+   */
+  hasPermissionToUpdateRecords() {
+    return this.checkPermissionsForUpdateRecords().hasPermission;
+  }
+  /**
+   * Checks whether the current user has permission to create any records in the current base. For
+   * more granular permission checks, see {@link Table.checkPermissionsForCreateRecords}.
+   *
+   * Returns `{hasPermission: true}` if the current user can create records,
+   * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+   * used to display an error message to the user.
+   *
+   * @example
+   * ```js
+   * import {useSession} from '@airtable/blocks/base/ui';
+   *
+   * function CreateButton({onClick}) {
+   *     const session = useSession();
+   *     const updateRecordsCheckResult = session.checkPermissionsForCreateRecords();
+   *     const deniedReason = updateRecordsCheckResult.hasPermission
+   *         ? <span>{updateRecordsCheckResult.reasonDisplayString}</span>
+   *         : null;
+   *
+   *     return <div>
+   *         {deniedReason}
+   *         <button onClick={onClick} disabled={!!deniedReason}>
+   *             Create
+   *         </button>
+   *     </div>;
+   * }
+   */
+  checkPermissionsForCreateRecords() {
+    return this._sdk.__mutations.checkPermissionsForMutation({
+      type: _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS,
+      tableId: undefined,
+      records: undefined
+    });
+  }
+  /**
+   * An alias for `session.checkPermissionsForCreateRecords().hasPermission`. For more granular
+   * permission checks, see {@link Table.hasPermissionToCreateRecords}.
+   */
+  hasPermissionToCreateRecords() {
+    return this.checkPermissionsForCreateRecords().hasPermission;
+  }
+  /**
+   * Checks whether the current user has permission to delete any records in the current base. For
+   * more granular permission checks, see {@link Table.checkPermissionsForDeleteRecords}.
+   *
+   * Returns `{hasPermission: true}` if the current user can delete records,
+   * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+   * used to display an error message to the user.
+   *
+   * @example
+   * ```js
+   * import {useSession} from '@airtable/blocks/base/ui';
+   *
+   * function DeleteButton({onClick}) {
+   *     const session = useSession();
+   *     const updateRecordsCheckResult = session.checkPermissionsForDeleteRecords();
+   *     const deniedReason = updateRecordsCheckResult.hasPermission
+   *         ? <span>{updateRecordsCheckResult.reasonDisplayString}</span>
+   *         : null;
+   *
+   *     return <div>
+   *         {deniedReason}
+   *         <button onClick={onClick} disabled={!!deniedReason}>
+   *             Delete
+   *         </button>
+   *     </div>;
+   */
+  checkPermissionsForDeleteRecords() {
+    return this._sdk.__mutations.checkPermissionsForMutation({
+      type: _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS,
+      tableId: undefined,
+      recordIds: undefined
+    });
+  }
+  /**
+   * An alias for `session.checkPermissionsForDeleteRecords().hasPermission`. For more granular
+   * permission checks, see {@link Table.hasPermissionToDeleteRecords}.
+   */
+  hasPermissionToDeleteRecords() {
+    return this.checkPermissionsForDeleteRecords().hasPermission;
+  }
+}
+var _default = exports.default = Session;