@baselift/blocks-testing 0.0.1

package/dist/cjs/test_mutations.js

@@ -0,0 +1,37 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestMutationTypes = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _unstable_testing_utils = require("@baselift/blocks/unstable_testing_utils");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Get the type of all the values of an object.
+ *
+ * Same as the legacy Flow `$Values<T>` type.
+ *
+ * @hidden
+ */
+
+/** @hidden */
+var TestMutationTypes = exports.TestMutationTypes = Object.freeze(_objectSpread(_objectSpread({}, _unstable_testing_utils.MutationTypes), {}, {
+  DELETE_SINGLE_FIELD: 'deleteSingleField',
+  DELETE_SINGLE_VIEW: 'deleteSingleView'
+}));
+
+/** @hidden */
+
+/** @hidden */
+
+/** @hidden */
+
+/** @hidden */

package/dist/cjs/vacant_airtable_interface.js

@@ -0,0 +1,367 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _unstable_testing_utils = require("@baselift/blocks/unstable_testing_utils");
+var _error_utils = require("./error_utils");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var cannotSimulateErrorMessage = 'Unable to simulate behavior' + '\n\n' + 'Extensions which retrieve model references using JavaScript `import` ' + 'declarations cannot be tested. To resolve this, replace `import` ' + "declaration in your Extension's source code with corresponding React " + 'Hooks. For instance, replace' + '\n\n' + '    import {base} from "@baselift/blocks";' + '\n\n' + 'with' + '\n\n' + '    const base = useBase();';
+
+/**
+ * An implementation of the MockAirtableInterface designed to satisfy the SDK's
+ * requirement for an instance at the moment of initial module evaluation. This
+ * instance (like the SDK features it enables) is fundamentally untestable both
+ * because the consumer cannot control its initial state and because it is
+ * shared by every Extension created in the testing environment.
+ *
+ * For some features of the SDK, Extension developers can avoid reliance on the
+ * VacantAirtableInterface by refactoring their code to use more testable
+ * patterns. This instance informs test authors of such cases by immediately
+ * throwing an error (intentionally discouraging its use).
+ *
+ * For other features of the SDK, the only way to use the feature is via an
+ * untestable pattern. In these cases, Extension developers have no alternative but
+ * to rely on the VacantAirtableInterface. This instance informs test authors
+ * of such cases by issuing a warning (allowing Extension code to be partially
+ * validated).
+ *
+ * @internal
+ */
+var VacantAirtableInterface = exports.default = /*#__PURE__*/function (_AbstractMockAirtable) {
+  function VacantAirtableInterface() {
+    (0, _classCallCheck2.default)(this, VacantAirtableInterface);
+    return _callSuper(this, VacantAirtableInterface, [{
+      isDevelopmentMode: false,
+      blockInstallationId: '',
+      isFirstRun: false,
+      isFullscreen: false,
+      initialKvValuesByKey: {},
+      runContext: {
+        type: _unstable_testing_utils.BlockRunContextType.DASHBOARD_APP
+      },
+      baseData: {
+        id: '',
+        name: '',
+        color: '',
+        activeTableId: '',
+        tableOrder: [],
+        tablesById: {},
+        permissionLevel: 'create',
+        currentUserId: '',
+        enabledFeatureNames: [],
+        collaboratorsById: {},
+        activeCollaboratorIds: [],
+        cursorData: null,
+        billingPlanGrouping: 'pro',
+        appInterface: {},
+        isBlockDevelopmentRestrictionEnabled: false,
+        workspaceId: ''
+      },
+      intentData: null
+    }]);
+  }
+  (0, _inherits2.default)(VacantAirtableInterface, _AbstractMockAirtable);
+  return (0, _createClass2.default)(VacantAirtableInterface, [{
+    key: "applyMutationAsync",
+    value: function () {
+      var _applyMutationAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(mutation, opts) {
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function applyMutationAsync(_x, _x2) {
+        return _applyMutationAsync.apply(this, arguments);
+      }
+      return applyMutationAsync;
+    }()
+  }, {
+    key: "checkPermissionsForMutation",
+    value: function checkPermissionsForMutation(mutation) {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+  }, {
+    key: "globalConfigHelpers",
+    get: function get() {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+  }, {
+    key: "expandRecord",
+    value: function expandRecord(tableId, recordId, recordIds) {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+  }, {
+    key: "fieldTypeProvider",
+    get: function get() {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+  }, {
+    key: "fetchAndSubscribeToCellValuesInFieldsAsync",
+    value: function () {
+      var _fetchAndSubscribeToCellValuesInFieldsAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(tableId, fieldIds) {
+        return _regenerator.default.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function fetchAndSubscribeToCellValuesInFieldsAsync(_x3, _x4) {
+        return _fetchAndSubscribeToCellValuesInFieldsAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToCellValuesInFieldsAsync;
+    }()
+  }, {
+    key: "fetchAndSubscribeToCursorDataAsync",
+    value: function () {
+      var _fetchAndSubscribeToCursorDataAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      function fetchAndSubscribeToCursorDataAsync() {
+        return _fetchAndSubscribeToCursorDataAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToCursorDataAsync;
+    }()
+  }, {
+    key: "fetchAndSubscribeToTableDataAsync",
+    value: function () {
+      var _fetchAndSubscribeToTableDataAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(tableId) {
+        return _regenerator.default.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      function fetchAndSubscribeToTableDataAsync(_x5) {
+        return _fetchAndSubscribeToTableDataAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToTableDataAsync;
+    }()
+  }, {
+    key: "fetchAndSubscribeToViewDataAsync",
+    value: function () {
+      var _fetchAndSubscribeToViewDataAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(tableId, viewId) {
+        return _regenerator.default.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      function fetchAndSubscribeToViewDataAsync(_x6, _x7) {
+        return _fetchAndSubscribeToViewDataAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToViewDataAsync;
+    }()
+  }, {
+    key: "hasRecord",
+    value: function hasRecord(tableId, recordId) {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+
+    // get idGenerator(): never {
+    //     throw spawnError(cannotSimulateErrorMessage);
+    // }
+  }, {
+    key: "setFullscreenMaxSize",
+    value: function setFullscreenMaxSize() {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+  }, {
+    key: "performBackendFetchAsync",
+    value: function () {
+      var _performBackendFetchAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6(requestJson) {
+        return _regenerator.default.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function performBackendFetchAsync(_x8) {
+        return _performBackendFetchAsync.apply(this, arguments);
+      }
+      return performBackendFetchAsync;
+    }()
+  }, {
+    key: "fetchDefaultCellValuesByFieldIdAsync",
+    value: function () {
+      var _fetchDefaultCellValuesByFieldIdAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
+        return _regenerator.default.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }));
+      function fetchDefaultCellValuesByFieldIdAsync() {
+        return _fetchDefaultCellValuesByFieldIdAsync.apply(this, arguments);
+      }
+      return fetchDefaultCellValuesByFieldIdAsync;
+    }()
+  }, {
+    key: "expandRecordList",
+    value: function expandRecordList() {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+  }, {
+    key: "expandRecordPickerAsync",
+    value: function () {
+      var _expandRecordPickerAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+        return _regenerator.default.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }));
+      function expandRecordPickerAsync() {
+        return _expandRecordPickerAsync.apply(this, arguments);
+      }
+      return expandRecordPickerAsync;
+    }()
+    /**
+     * `reload` is made available to Extensions through an undocumented binding
+     * exported by the SDK's main entry point. That reference is associated
+     * with the singleton instance of the `Sdk` class and therefore cannot be
+     * controlled in the testing environment.
+     */
+  }, {
+    key: "reloadFrame",
+    value: function reloadFrame() {
+      // eslint-disable-next-line no-console
+      console.warn('Frame reloading cannot be simulated in the Extension testing environment.');
+    }
+
+    /**
+     * An Extension can only retrieve a reference to the `SettingsButton` singleton
+     * via a JavaScript `import` declaration. The SDK does not offer a testable
+     * pattern for explicitly controlling the visibility of the settings button
+     */
+  }, {
+    key: "setSettingsButtonVisibility",
+    value: function setSettingsButtonVisibility() {
+      // eslint-disable-next-line no-console
+      console.warn('The Settings button cannot be simulated in the Extension testing environment.');
+    }
+
+    /**
+     * `undoRedo` is made available to Extensions through an undocumented binding
+     * exported by the SDK's main entry point. That reference is associated
+     * with the singleton instance of the `Sdk` class and therefore cannot be
+     * controlled in the testing environment.
+     */
+  }, {
+    key: "setUndoRedoMode",
+    value: function setUndoRedoMode() {
+      // eslint-disable-next-line no-console
+      console.warn('The `undoRedo` feature cannot be simulated in the Extension testing environment.');
+    }
+  }, {
+    key: "enterFullscreen",
+    value: function enterFullscreen() {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+  }, {
+    key: "exitFullscreen",
+    value: function exitFullscreen() {
+      throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+    }
+  }, {
+    key: "fetchAndSubscribeToPerformRecordActionAsync",
+    value: function () {
+      var _fetchAndSubscribeToPerformRecordActionAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
+        return _regenerator.default.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)(cannotSimulateErrorMessage);
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
+      }));
+      function fetchAndSubscribeToPerformRecordActionAsync() {
+        return _fetchAndSubscribeToPerformRecordActionAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToPerformRecordActionAsync;
+    }()
+    /**
+     * `trackEvent` is made available to internal Extensions through the
+     * `unstable_private_utils` module. That reference is not associated with
+     * any instance of the `Sdk` class.
+     */
+  }, {
+    key: "trackEvent",
+    value: function trackEvent() {
+      // eslint-disable-next-line no-console
+      console.warn('Event tracking signals cannot be observed in the Extension testing environment.');
+    }
+
+    /**
+     * `trackExposure` cannot be invoked by any Extensions (neither those authored by
+     * Airtable nor by other Extension developers). It should be implemented to
+     * satisfy the AirtableInterface contract, but the implementation should
+     * not throw (since it must be successful for Extensions to function), nor should
+     * it emit an event (since test authors have no need to track its usage).
+     */
+  }, {
+    key: "trackExposure",
+    value: function trackExposure() {}
+
+    /**
+     * `blockStats` is made available to internal Extensions through the
+     * `unstable_private_utils` module. That reference is not associated with
+     * any instance of the `Sdk` class.
+     */
+  }, {
+    key: "sendStat",
+    value: function sendStat() {
+      // eslint-disable-next-line no-console
+      console.warn('Statistic tracking signals cannot be observed in the Extension testing environment.');
+    }
+  }]);
+}(_unstable_testing_utils.AbstractMockAirtableInterface);

package/dist/types/src/error_utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @hidden
+ */
+export declare function spawnError(errorMessageFormat: string, ...errorMessageArgs: ReadonlyArray<unknown>): Error;
+/**
+ * An alternative to facebook's invariant that's safe to use with base data
+ *
+ * @hidden
+ */
+export declare function invariant(condition: unknown, errorMessageFormat: string, ...errorMessageArgs: Array<unknown>): asserts condition;
+//# sourceMappingURL=error_utils.d.ts.map

package/dist/types/src/error_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error_utils.d.ts","sourceRoot":"","sources":["../../../src/error_utils.ts"],"names":[],"mappings":"AAgCA;;GAEG;AACH,wBAAgB,UAAU,CACtB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,gBAAgB,EAAE,aAAa,CAAC,OAAO,CAAC,SAO9C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACrB,SAAS,EAAE,OAAO,EAClB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,gBAAgB,EAAE,KAAK,CAAC,OAAO,CAAC,GACpC,OAAO,CAAC,SAAS,CAQnB"}

package/dist/types/src/index.d.ts

@@ -0,0 +1,4 @@
+import './inject_mock_airtable_interface';
+export { default } from './test_driver';
+export { MutationTypes } from '@baselift/blocks/unstable_testing_utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,kCAAkC,CAAC;AAG1C,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AACtC,OAAO,EAAC,aAAa,EAAC,MAAM,yCAAyC,CAAC"}

package/dist/types/src/inject_mock_airtable_interface.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inject_mock_airtable_interface.d.ts.map

package/dist/types/src/inject_mock_airtable_interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject_mock_airtable_interface.d.ts","sourceRoot":"","sources":["../../../src/inject_mock_airtable_interface.ts"],"names":[],"mappings":""}

package/dist/types/src/mock_airtable_interface.d.ts

@@ -0,0 +1,237 @@
+import { BaseId, CollaboratorData, Color, FieldId, PermissionCheckResult, RecordActionData, RecordId, TableId, ViewId } from '@baselift/blocks/types';
+import { AbstractMockAirtableInterface, CursorData, GlobalConfigData, FieldType, Mutation, PartialViewData, RecordData, RequestJson, ResponseJson, ViewportSizeConstraint, ViewType } from '@baselift/blocks/unstable_testing_utils';
+import { TestMutation } from './test_mutations';
+import { ObjectMap } from './private_utils';
+/**
+ * A mapping relating the names of event subscriptions available on
+ * {@link TestDriver} instances to the arguments that are provided when one of
+ * those events is triggered.
+ */
+export interface WatchableKeysAndArgs {
+    /**
+     * Triggered whenever the SDK has been induced to persist a change to the
+     * Base.
+     */
+    mutation: Mutation;
+    /**
+     * Triggered when the SDK has been induced to expand a Record in the user
+     * interface
+     */
+    expandRecord: {
+        recordId: RecordId;
+        recordIds: Array<RecordId> | null;
+    };
+    /**
+     * Triggered when the SDK has been induced to enter full screen mode.
+     */
+    enterFullscreen: null;
+    /**
+     * Triggered when the SDK has been induced to exit full screen mode.
+     */
+    exitFullscreen: null;
+    /**
+     * Triggered when the maximum full screen size is modified.
+     */
+    setFullscreenMaxSize: ViewportSizeConstraint;
+    /**
+     * Triggered when the SDK has been induced to expand a list of Records in
+     * the user interface.
+     */
+    expandRecordList: {
+        tableId: string;
+        recordIds: Array<string>;
+        fieldIds: Array<string> | null;
+    };
+}
+/**
+ * A complete set of information necessary to initialize a simulated Airtable
+ * Base in automated test environments.
+ */
+export interface FixtureData {
+    /**
+     * An optional object describing the initial state of the globalConfig
+     * which is associated with the simulated Base. If omitted, the Base's
+     * globalConfig will be initially empty.
+     */
+    globalConfig?: GlobalConfigData;
+    /** A representation of the state of an Airtable Base */
+    base: {
+        id: BaseId;
+        name: string;
+        color?: string;
+        tables: Array<TableFixtureData>;
+        collaborators: Array<CollaboratorData & {
+            isActive: boolean;
+        }>;
+        workspaceId: string;
+    };
+}
+/** A representation of the state of a Table */
+interface TableFixtureData {
+    /** A unique identifier for the simulated Tbale */
+    id: TableId;
+    /** The name to assign to the simulated Table */
+    name: string;
+    /** The description to assign to the simulated Table */
+    description: string | null;
+    /**
+     * Fixture data for the simulated Fields that should be present in the
+     * simulated Table when it is initialized.
+     */
+    fields: Array<FieldFixtureData>;
+    /**
+     * Fixture data for the simulated Views that should be present in the
+     * simulated Table when it is initialized.
+     */
+    views: Array<ViewFixtureData>;
+    /**
+     * Fixture data for the simulated Records that should be present in the
+     * simulated Table when it is initialized.
+     */
+    records: Array<RecordFixtureData>;
+}
+/** A representation of the state of a Field */
+interface FieldFixtureData {
+    /** A unique identifier for the simulated Field */
+    id: FieldId;
+    /** The name to assign to the simulated Field */
+    name: string;
+    /** The description to assign to the simulated Field */
+    description: string | null;
+    /** The type of the simulated Field */
+    type: FieldType;
+    /** Options associated with the simulated Field */
+    options: null | {
+        [key: string]: unknown;
+    };
+}
+/** A representation of the state of a View */
+interface ViewFixtureData {
+    /** A unique identifier for the simulated View */
+    id: ViewId;
+    /** The name to assign to the simulated View */
+    name: string;
+    /** The type of the simulated view */
+    type: ViewType;
+    /**
+     * A description of how simulated Fields should be sequenced within the
+     * simulated View
+     */
+    fieldOrder: {
+        fieldIds: Array<FieldId>;
+        visibleFieldCount: number;
+    };
+    /**
+     * A set of references to Records contained within the simulated view. This
+     * is distinct from the complete fixture data for the simulated Records.
+     */
+    records: Array<ViewRecordFixtureData>;
+    /**
+     * A boolean determining if a view is locked
+     */
+    isLockedView: boolean;
+}
+/**
+ * A reference to Record contained within a simulated view. This is distinct
+ * from the complete fixture data for the simulated Record.
+ */
+interface ViewRecordFixtureData {
+    /** A value which uniquely identifies a Record within a base. */
+    id: RecordId;
+    /** The color associated with a Record's membership in a View. */
+    color: Color | null;
+}
+/** A representation of the state of a Record */
+interface RecordFixtureData {
+    /** A unique identifier for the simulated Record */
+    id: RecordId;
+    /** The number of comments to assign to the simulated record */
+    commentCount: number;
+    /** The time the simulated record should appear to have been created */
+    createdTime: string;
+    /** A mapping of field identifiers to cell values */
+    cellValuesByFieldId: ObjectMap<FieldId, unknown>;
+}
+/** @hidden */
+interface RecordDataStore {
+    tables: {
+        [key: string]: {
+            [key: string]: RecordFixtureData;
+        };
+    };
+    views: {
+        [key: string]: {
+            [key: string]: Pick<ViewFixtureData, 'fieldOrder' | 'records'>;
+        };
+    };
+}
+/**
+ * A callback function allowing tests to simulate user interaction with the
+ * expanded record picker UI. The testing library will invoke this function
+ * whenever the Extension under test uses the {@link expandRecordPickerAsync}
+ * function, and the return value of this function will be provided to the Extension
+ * under test as the {@link Record} that the simulated user selected.
+ */
+export type PickRecord = (tableId: string, recordIds: Array<string>, fieldIds: Array<string> | null, shouldAllowCreatingRecord: boolean) => RecordId | null;
+/**
+ * An implementation of the MockAirtableInterface designed for use in automated
+ * test suites for Airtable Blocks maintained externally. Provides a more
+ * high-level constructor for specifying test fixture data and implements some
+ * features which approximate interactions with Hyperbase in production.
+ *
+ * @hidden
+ */
+export default class MockAirtableInterface extends AbstractMockAirtableInterface {
+    _recordDataStore: RecordDataStore;
+    _userPermissionCheck?: (mutation: Mutation) => boolean;
+    _pickRecord?: PickRecord;
+    constructor(unsafeFixtureData: FixtureData);
+    applyMutationAsync(mutation: TestMutation, opts?: {
+        holdForMs?: number;
+    }): Promise<void>;
+    checkPermissionsForMutation(mutation: Mutation): PermissionCheckResult;
+    get globalConfigHelpers(): import("@baselift/blocks/dist/types/src/types/airtable_interface").GlobalConfigHelpers;
+    emit<Key extends keyof WatchableKeysAndArgs>(key: Key, data: WatchableKeysAndArgs[Key]): void;
+    expandRecord(tableId: string, recordId: string, recordIds: Array<string> | null): void;
+    expandRecordList(tableId: string, recordIds: Array<string>, fieldIds: Array<string> | null): void;
+    expandRecordPickerAsync(tableId: string, recordIds: Array<string>, fieldIds: Array<string> | null, shouldAllowCreatingRecord: boolean): Promise<string | null>;
+    get fieldTypeProvider(): import("@baselift/blocks/dist/types/src/types/airtable_interface").FieldTypeProvider;
+    fetchAndSubscribeToCellValuesInFieldsAsync(tableId: TableId, fieldIds: Array<FieldId>): Promise<any>;
+    fetchAndSubscribeToCursorDataAsync(): Promise<CursorData>;
+    fetchAndSubscribeToTableDataAsync(tableId: string): Promise<{
+        recordsById: {
+            [recordId: string]: RecordData;
+        };
+    }>;
+    fetchAndSubscribeToViewDataAsync(tableId: string, viewId: string): Promise<PartialViewData>;
+    hasRecord(tableId: TableId, recordId: RecordId): boolean;
+    get idGenerator(): import("@baselift/blocks/dist/types/src/types/airtable_interface").IdGenerator;
+    on<Key extends keyof WatchableKeysAndArgs>(key: Key, fn: (data: WatchableKeysAndArgs[Key]) => void): void;
+    off<Key extends keyof WatchableKeysAndArgs>(key: Key, fn: (data: WatchableKeysAndArgs[Key]) => void): void;
+    setFullscreenMaxSize(maxFullscreenSize: ViewportSizeConstraint): void;
+    setPickRecord(pickRecord: PickRecord): void;
+    setUserPermissionCheck(check: (mutation: Mutation) => boolean): void;
+    performBackendFetchAsync(requestJson: RequestJson): Promise<ResponseJson>;
+    fetchDefaultCellValuesByFieldIdAsync(): Promise<{
+        [key: string]: unknown;
+    }>;
+    reloadFrame(): void;
+    setSettingsButtonVisibility(): void;
+    setUndoRedoMode(): void;
+    enterFullscreen(): void;
+    exitFullscreen(): void;
+    fetchAndSubscribeToPerformRecordActionAsync(): Promise<RecordActionData | null>;
+    trackEvent(): void;
+    /**
+     * `trackExposure` cannot be invoked by any Extensions (neither those authored by
+     * Airtable nor by other Extension developers). It should be implemented to
+     * satisfy the AirtableInterface contract, but the implementation should
+     * not throw because it must be successful for Extensions to function. Likewise,
+     * it should not emit an event because test authors have no need to track
+     * its usage.
+     */
+    trackExposure(): void;
+    sendStat(): void;
+}
+export {};
+//# sourceMappingURL=mock_airtable_interface.d.ts.map