@airtable/blocks 0.0.0-experimental-20e3506bd-20250428

package/dist/cjs/stats/block_stats.js

@@ -0,0 +1,96 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.blockStats = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _airtable_interface = _interopRequireDefault(require("../injected/airtable_interface"));
+// NOTE(richsinn): this client is effectively an implementation of the StatsClient interface
+// for Datadog. For example, see https://github.com/Hyperbase/hyperbase/blob/development/client_server_shared/stats/stats_client.tsx
+/** @hidden */
+var BlockStats = /*#__PURE__*/function () {
+  function BlockStats() {
+    (0, _classCallCheck2.default)(this, BlockStats);
+  }
+  return (0, _createClass2.default)(BlockStats, [{
+    key: "increment",
+    value: function increment(stat, tags) {
+      this.incrementBy(stat, 1, tags);
+    }
+  }, {
+    key: "incrementBy",
+    value: function incrementBy(stat, value, tags) {
+      (0, _airtable_interface.default)().sendStat({
+        metricType: 'incrementBy',
+        stat,
+        value,
+        tags
+      });
+    }
+  }, {
+    key: "decrement",
+    value: function decrement(stat, tags) {
+      this.decrementBy(stat, 1, tags);
+    }
+  }, {
+    key: "decrementBy",
+    value: function decrementBy(stat, value, tags) {
+      (0, _airtable_interface.default)().sendStat({
+        metricType: 'decrementBy',
+        stat,
+        value,
+        tags
+      });
+    }
+  }, {
+    key: "gauge",
+    value: function gauge(stat, value, tags) {
+      (0, _airtable_interface.default)().sendStat({
+        metricType: 'gauge',
+        stat,
+        value,
+        tags
+      });
+    }
+  }, {
+    key: "histogram",
+    value: function histogram(stat, value, tags) {
+      (0, _airtable_interface.default)().sendStat({
+        metricType: 'histogram',
+        stat,
+        value,
+        tags
+      });
+    }
+  }, {
+    key: "distribution",
+    value: function distribution(stat, value, tags) {
+      (0, _airtable_interface.default)().sendStat({
+        metricType: 'distribution',
+        stat,
+        value,
+        tags
+      });
+    }
+  }, {
+    key: "timing",
+    value: function timing(stat, time, tags) {
+      (0, _airtable_interface.default)().sendStat({
+        metricType: 'timing',
+        stat,
+        value: time,
+        tags
+      });
+    }
+  }, {
+    key: "timingWithSum",
+    value: function timingWithSum(stat, time, tags) {
+      this.timing(stat, time, tags);
+      this.incrementBy(stat + '.sum', time, tags);
+    }
+  }]);
+}();
+var blockStats = exports.blockStats = new BlockStats();

package/dist/cjs/testing/abstract_mock_airtable_interface.js

@@ -0,0 +1,277 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractMockAirtableInterface = void 0;
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+var _private_utils = require("../shared/private_utils");
+var _error_utils = require("../shared/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; })(); } // istanbul ignore file
+var EventEmitter = require('events');
+
+/** @internal */
+var aggregators = {
+  aggregate(appInterface, summaryFunctionKey, cellValues, fieldData) {
+    return null;
+  },
+  aggregateToString(appInterface, summaryFunctionKey, cellValues, fieldData) {
+    return '';
+  },
+  getAggregatorConfig(summaryFunctionKey) {
+    return {
+      key: '',
+      displayName: '',
+      shortDisplayName: ''
+    };
+  },
+  getAllAvailableAggregatorKeys() {
+    return [];
+  },
+  getAvailableAggregatorKeysForField(fieldData) {
+    return [];
+  }
+};
+
+/** @internal */
+var fieldTypeProvider = {
+  isComputed(fieldData) {
+    return false;
+  },
+  validateConfigForUpdate: () => {
+    return {
+      isValid: true
+    };
+  },
+  getConfig: (appInterface, fieldData, fieldNamesById) => {
+    return {
+      type: fieldData.type,
+      options: fieldData.typeOptions
+    };
+  },
+  canBePrimary: () => {
+    return true;
+  },
+  convertStringToCellValue(appInterface, string, fieldData) {
+    return '';
+  },
+  convertCellValueToString(appInterface, cellValue, fieldData) {
+    return '';
+  },
+  getCellRendererData(appInterface, cellValue, fieldData, shouldWrap) {
+    return {
+      cellValueHtml: "<pre>".concat(JSON.stringify(cellValue), "</pre>"),
+      attributes: {}
+    };
+  },
+  validateCellValueForUpdate(appInterface, newCellValue, currentCellValue, fieldData) {
+    return {
+      isValid: true
+    };
+  },
+  getUiConfig(appInterface, fieldData) {
+    return {
+      iconName: '',
+      desiredCellWidthForRecordCard: 0,
+      minimumCellWidthForRecordCard: 0
+    };
+  }
+};
+
+/** @internal */
+var urlConstructor = {
+  getTableUrl(tableId) {
+    return "https://airtable.test/".concat(tableId);
+  },
+  getViewUrl(viewId, tableId) {
+    return "https://airtable.test/".concat(tableId, "/").concat(viewId);
+  },
+  getRecordUrl(recordId, tableId) {
+    return "https://airtable.test/".concat(tableId, "/").concat(recordId);
+  },
+  getAttachmentClientUrl(appInterface, attachmentId, attachmentUrl) {
+    return attachmentUrl;
+  }
+};
+
+/** @internal */
+var globalConfigHelpers = {
+  validatePath(path, store) {
+    return {
+      isValid: true
+    };
+  },
+  validateAndApplyUpdates(updates, store) {
+    throw (0, _error_utils.spawnError)('validateAndApplyUpdates unimplemented');
+  }
+};
+
+/** @internal */
+var idGenerator = {
+  generateRecordId: () => 'recGeneratedMockId',
+  generateFieldId: () => 'fldGeneratedMockId',
+  generateTableId: () => 'tblGeneratedMockId'
+};
+
+/**
+ * An abstract base class with a common interface exposed to both Blocks SDK's
+ * internal automated test suite and the blocks-testing public repo.
+ *
+ * @hidden
+ */
+var AbstractMockAirtableInterface = exports.AbstractMockAirtableInterface = /*#__PURE__*/function (_EventEmitter) {
+  function AbstractMockAirtableInterface(initData) {
+    var _this;
+    (0, _classCallCheck2.default)(this, AbstractMockAirtableInterface);
+    _this = _callSuper(this, AbstractMockAirtableInterface);
+    (0, _defineProperty2.default)(_this, "sdkInitData", void 0);
+    (0, _defineProperty2.default)(_this, "_initData", void 0);
+    _this._initData = (0, _private_utils.cloneDeep)(initData);
+    _this.reset();
+    return _this;
+  }
+
+  /**
+   * Revert the mock interface to its initial state. This includes:
+   *
+   * - removing all event listeners
+   * - restoring the database schema
+   */
+  (0, _inherits2.default)(AbstractMockAirtableInterface, _EventEmitter);
+  return (0, _createClass2.default)(AbstractMockAirtableInterface, [{
+    key: "reset",
+    value: function reset() {
+      this.removeAllListeners();
+      this.sdkInitData = (0, _private_utils.cloneDeep)(this._initData);
+    }
+
+    // The following properties are defined using accessors in order to
+    // facilitate overriding in subclasses.
+  }, {
+    key: "aggregators",
+    get: function get() {
+      return aggregators;
+    }
+  }, {
+    key: "fieldTypeProvider",
+    get: function get() {
+      return fieldTypeProvider;
+    }
+  }, {
+    key: "urlConstructor",
+    get: function get() {
+      return urlConstructor;
+    }
+  }, {
+    key: "globalConfigHelpers",
+    get: function get() {
+      return globalConfigHelpers;
+    }
+  }, {
+    key: "idGenerator",
+    get: function get() {
+      return idGenerator;
+    }
+  }, {
+    key: "assertAllowedSdkPackageVersion",
+    value: function assertAllowedSdkPackageVersion() {}
+  }, {
+    key: "applyMutationAsync",
+    value: function applyMutationAsync(mutation, opts) {
+      return Promise.resolve();
+    }
+  }, {
+    key: "checkPermissionsForMutation",
+    value: function checkPermissionsForMutation(mutation) {
+      return {
+        hasPermission: true
+      };
+    }
+  }, {
+    key: "createVisList",
+    value: function createVisList(appInterface, recordDatas, fieldDatas, sorts) {
+      return {
+        removeRecordIds(recordIds) {},
+        addRecordData(recordData) {},
+        getOrderedRecordIds() {
+          return recordDatas.map(_ref => {
+            var id = _ref.id;
+            return id;
+          });
+        }
+      };
+    }
+  }, {
+    key: "subscribeToModelUpdates",
+    value: function subscribeToModelUpdates(fn) {
+      this.on('modelupdates', fn);
+    }
+  }, {
+    key: "setActiveViewOrTable",
+    value: function setActiveViewOrTable(tableId, viewId) {}
+
+    // TODO(jugglinmike): Implement
+  }, {
+    key: "subscribeToGlobalConfigUpdates",
+    value: function subscribeToGlobalConfigUpdates() {}
+  }, {
+    key: "subscribeToSettingsButtonClick",
+    value: function subscribeToSettingsButtonClick() {}
+  }, {
+    key: "subscribeToEnterFullScreen",
+    value: function subscribeToEnterFullScreen() {}
+  }, {
+    key: "subscribeToExitFullScreen",
+    value: function subscribeToExitFullScreen() {}
+  }, {
+    key: "subscribeToFocus",
+    value: function subscribeToFocus() {}
+  }, {
+    key: "triggerModelUpdates",
+    value: function triggerModelUpdates(changes) {
+      this.emit('modelupdates', {
+        changes
+      });
+    }
+
+    // TODO(jugglinmike): Implement
+  }, {
+    key: "triggerGlobalConfigUpdates",
+    value: function triggerGlobalConfigUpdates() {}
+  }, {
+    key: "triggerSettingsButtonClick",
+    value: function triggerSettingsButtonClick() {}
+  }, {
+    key: "triggerEnterFullScreen",
+    value: function triggerEnterFullScreen() {}
+  }, {
+    key: "triggerExitFullScreen",
+    value: function triggerExitFullScreen() {}
+  }, {
+    key: "triggerFocus",
+    value: function triggerFocus() {}
+  }, {
+    key: "unsubscribeFromCursorData",
+    value: function unsubscribeFromCursorData() {}
+  }, {
+    key: "unsubscribeFromTableData",
+    value: function unsubscribeFromTableData() {}
+  }, {
+    key: "unsubscribeFromCellValuesInFields",
+    value: function unsubscribeFromCellValuesInFields() {}
+  }, {
+    key: "unsubscribeFromViewData",
+    value: function unsubscribeFromViewData() {}
+  }]);
+}(EventEmitter);

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

@@ -0,0 +1,13 @@
+import Sdk from './sdk';
+export declare let base: Sdk['base'];
+export declare let globalConfig: Sdk['globalConfig'];
+export declare let installationId: Sdk['installationId'];
+export declare let reload: Sdk['reload'];
+export declare let runInfo: Sdk['runInfo'];
+export declare let settingsButton: Sdk['settingsButton'];
+export declare let undoRedo: Sdk['undoRedo'];
+export declare let viewport: Sdk['viewport'];
+export declare let unstable_fetchAsync: Sdk['unstable_fetchAsync'];
+export declare let cursor: Sdk['cursor'];
+export declare let session: Sdk['session'];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/base/index.ts"],"names":[],"mappings":"AAIA,OAAO,GAAG,MAAM,OAAO,CAAC;AAMxB,eAAO,IAAI,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;AAC7B,eAAO,IAAI,YAAY,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;AAC7C,eAAO,IAAI,cAAc,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;AACjD,eAAO,IAAI,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;AACjC,eAAO,IAAI,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;AACnC,eAAO,IAAI,cAAc,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;AACjD,eAAO,IAAI,QAAQ,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;AACrC,eAAO,IAAI,QAAQ,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;AACrC,eAAO,IAAI,mBAAmB,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAK3D,eAAO,IAAI,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;AAejC,eAAO,IAAI,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC"}

package/dist/types/src/base/models/abstract_model_with_async_data.d.ts

@@ -0,0 +1,47 @@
+/** @module @airtable/blocks/models: Abstract models */ /** */
+import Sdk from '../sdk';
+import { FlowAnyFunction, FlowAnyObject } from '../../shared/private_utils';
+import AbstractModel from '../../shared/models/abstract_model';
+import { BaseSdkMode } from '../../sdk_mode';
+/**
+ * Abstract superclass for all Blocks SDK models that need to fetch async data.
+ *
+ * @docsPath models/advanced/AbstractModelWithAsyncData
+ */
+declare abstract class AbstractModelWithAsyncData<DataType, WatchableKey extends string> extends AbstractModel<BaseSdkMode, DataType, WatchableKey> {
+    /** @hidden */
+    constructor(sdk: Sdk, modelId: string);
+    /**
+     * Watching a key that needs to load data asynchronously will automatically
+     * cause the data to be fetched. Once the data is available, the callback
+     * will be called.
+     *
+     * @inheritdoc
+     */
+    watch(keys: WatchableKey | ReadonlyArray<WatchableKey>, callback: FlowAnyFunction, context?: FlowAnyObject | null): Array<WatchableKey>;
+    /**
+     * Unwatching a key that needs to load data asynchronously will automatically
+     * cause the data to be released. Once the data is available, the callback
+     * will be called.
+     *
+     * @inheritdoc
+     */
+    unwatch(keys: WatchableKey | ReadonlyArray<WatchableKey>, callback: FlowAnyFunction, context?: FlowAnyObject | null): Array<WatchableKey>;
+    /** @inheritdoc */
+    get isDeleted(): boolean;
+    /** */
+    get isDataLoaded(): boolean;
+    /**
+     * Will cause all the async data to be fetched and retained. Every call to
+     * `loadDataAsync` should have a matching call to `unloadData`.
+     *
+     * Returns a Promise that will resolve once the data is loaded.
+     */
+    loadDataAsync(): Promise<void>;
+    /** */
+    unloadData(): void;
+    _forceUnload(): void;
+    _assertNotForceUnloaded(): void;
+}
+export default AbstractModelWithAsyncData;
+//# sourceMappingURL=abstract_model_with_async_data.d.ts.map

package/dist/types/src/base/models/abstract_model_with_async_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract_model_with_async_data.d.ts","sourceRoot":"","sources":["../../../../../src/base/models/abstract_model_with_async_data.ts"],"names":[],"mappings":"AAAA,uDAAuD,CAAC,MAAM;AAC9D,OAAO,GAAG,MAAM,QAAQ,CAAC;AACzB,OAAO,EAEH,eAAe,EACf,aAAa,EAEhB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,aAAa,MAAM,oCAAoC,CAAC;AAC/D,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAE3C;;;;GAIG;AACH,uBAAe,0BAA0B,CACrC,QAAQ,EACR,YAAY,SAAS,MAAM,CAC7B,SAAQ,aAAa,CAAC,WAAW,EAAE,QAAQ,EAAE,YAAY,CAAC;IA6BxD,cAAc;gBACF,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;IAQrC;;;;;;OAMG;IACH,KAAK,CACD,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC,EAChD,QAAQ,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,GAC/B,KAAK,CAAC,YAAY,CAAC;IAetB;;;;;;OAMG;IACH,OAAO,CACH,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC,EAChD,QAAQ,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,GAC/B,KAAK,CAAC,YAAY,CAAC;IAatB,kBAAkB;IAClB,IAAI,SAAS,IAAI,OAAO,CAKvB;IACD,MAAM;IACN,IAAI,YAAY,IAAI,OAAO,CAK1B;IAWD;;;;;OAKG;IACG,aAAa;IAmCnB,MAAM;IACN,UAAU;IA6BV,YAAY;IAOZ,uBAAuB;CAG1B;AAED,eAAe,0BAA0B,CAAC"}

package/dist/types/src/base/models/base.d.ts

@@ -0,0 +1,142 @@
+/** @module @airtable/blocks/models: Base */ /** */
+import { BaseCore } from '../../shared/models/base_core';
+import { FieldType } from '../../shared/types/field';
+import { PermissionCheckResult } from '../../shared/types/mutations_core';
+import { BaseSdkMode } from '../../sdk_mode';
+import Table from './table';
+/**
+ * Model class representing a base.
+ *
+ * If you want the base model to automatically recalculate whenever the base schema changes, try the
+ * {@link useBase} hook. Alternatively, you can manually subscribe to changes with
+ * {@link useWatchable} (recommended) or [Base#watch](/api/models/Base#watch).
+ *
+ * @example
+ * ```js
+ * import {base} from '@airtable/blocks';
+ *
+ * console.log('The name of your base is', base.name);
+ * ```
+ * @docsPath models/Base
+ */
+declare class Base extends BaseCore<BaseSdkMode> {
+    /**
+     * Checks whether the current user has permission to create a table.
+     *
+     * Accepts partial input, in the same format as {@link createTableAsync}.
+     *
+     * 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 name name for the table. must be case-insensitive unique
+     * @param fields array of fields to create in the table
+     *
+     * @example
+     * ```js
+     * const createTableCheckResult = base.checkPermissionsForCreateTable();
+     *
+     * if (!createTableCheckResult.hasPermission) {
+     *     alert(createTableCheckResult.reasonDisplayString);
+     * }
+     * ```
+     */
+    checkPermissionsForCreateTable(name?: string, fields?: Array<{
+        name?: string;
+        type?: FieldType;
+        options?: {
+            [key: string]: unknown;
+        } | null;
+        description?: string | null;
+    }>): PermissionCheckResult;
+    /**
+     * An alias for `checkPermissionsForCreateTable(name, fields).hasPermission`.
+     *
+     * Checks whether the current user has permission to create a table.
+     *
+     * Accepts partial input, in the same format as {@link createTableAsync}.
+     *
+     * @param name name for the table. must be case-insensitive unique
+     * @param fields array of fields to create in the table
+     *
+     * @example
+     * ```js
+     * const canCreateTable = table.hasPermissionToCreateTable();
+     *
+     * if (!canCreateTable) {
+     *     alert('not allowed!');
+     * }
+     * ```
+     */
+    hasPermissionToCreateTable(name?: string, fields?: Array<{
+        name?: string;
+        type?: FieldType;
+        options?: {
+            [key: string]: unknown;
+        } | null;
+        description?: string | null;
+    }>): boolean;
+    /**
+     * Creates a new table.
+     *
+     * Throws an error if the user does not have permission to create a table, if an invalid
+     * table name is provided, or if invalid fields are provided (invalid name, type, options or
+     * description).
+     *
+     * Refer to {@link FieldType} for supported field types, the write format for field options, and
+     * other specifics for certain field types.
+     *
+     * At least one field must be specified. The first field in the `fields` array will be used as
+     * the table's [primary field](https://support.airtable.com/hc/en-us/articles/202624179-The-Name-Field)
+     * and must be a supported primary field type. Fields must have case-insensitive unique names
+     * within the table.
+     *
+     * A default grid view will be created with all fields visible.
+     *
+     * This action is asynchronous. Unlike new records, new tables are **not** created
+     * optimistically locally. You must `await` the returned promise before using the new
+     * table in your extension.
+     *
+     * @param name name for the table. must be case-insensitive unique
+     * @param fields array of fields to create in the table: see below for an example. `name` and
+     * `type` must be specified for all fields, while `options` is only required for fields that
+     * have field options. `description` is optional and will be `''` if not specified or if
+     * specified as `null`.
+     *
+     * @example
+     * ```js
+     * async function createNewTable() {
+     *     const name = 'My new table';
+     *     const fields = [
+     *         // Name will be the primary field of the table.
+     *         {name: 'Name', type: FieldType.SINGLE_LINE_TEXT, description: 'This is the primary field'},
+     *         {name: 'Notes', type: FieldType.RICH_TEXT},
+     *         {name: 'Attachments', type: FieldType.MULTIPLE_ATTACHMENTS},
+     *         {name: 'Number', type: FieldType.NUMBER, options: {
+     *             precision: 8,
+     *         }},
+     *         {name: 'Select', type: FieldType.SINGLE_SELECT, options: {
+     *             choices: [
+     *                 {name: 'A'},
+     *                 {name: 'B'},
+     *             ],
+     *         }},
+     *     ];
+     *
+     *     if (base.hasPermissionToCreateTable(name, fields)) {
+     *         await base.createTableAsync(name, fields);
+     *     }
+     * }
+     * ```
+     */
+    createTableAsync(name: string, fields: Array<{
+        name: string;
+        type: FieldType;
+        options?: {
+            [key: string]: unknown;
+        } | null;
+        description?: string | null;
+    }>): Promise<Table>;
+}
+export default Base;
+//# sourceMappingURL=base.d.ts.map

package/dist/types/src/base/models/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/base/models/base.ts"],"names":[],"mappings":"AAAA,4CAA4C,CAAC,MAAM;AACnD,OAAO,EAAC,QAAQ,EAAyC,MAAM,+BAA+B,CAAC;AAE/F,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAC,qBAAqB,EAAC,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAM3C,OAAO,KAAK,MAAM,SAAS,CAAC;AAE5B;;;;;;;;;;;;;;GAcG;AACH,cAAM,IAAK,SAAQ,QAAQ,CAAC,WAAW,CAAC;IAoBpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,8BAA8B,CAC1B,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,KAAK,CAAC;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,SAAS,CAAC;QACjB,OAAO,CAAC,EAAE;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAC,GAAG,IAAI,CAAC;QAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,CAAC,GACH,qBAAqB;IAuBxB;;;;;;;;;;;;;;;;;;OAkBG;IACH,0BAA0B,CACtB,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,KAAK,CAAC;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,SAAS,CAAC;QACjB,OAAO,CAAC,EAAE;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAC,GAAG,IAAI,CAAC;QAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,CAAC,GACH,OAAO;IAIV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACG,gBAAgB,CAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,KAAK,CAAC;QACV,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,SAAS,CAAC;QAChB,OAAO,CAAC,EAAE;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAC,GAAG,IAAI,CAAC;QAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,CAAC,GACH,OAAO,CAAC,KAAK,CAAC;CAyDpB;AAED,eAAe,IAAI,CAAC"}

package/dist/types/src/base/models/create_aggregators.d.ts

@@ -0,0 +1,59 @@
+/** @module @airtable/blocks/models: Aggregators */ /** */
+import { AggregatorKey } from '../types/aggregators';
+import Sdk from '../sdk';
+import Record from './record';
+import Field from './field';
+/**
+ * Aggregators can be used to compute aggregates for cell values.
+ *
+ * @example
+ * ```js
+ * import {aggregators} from '@airtable/blocks/models';
+ *
+ * // To get a list of aggregators supported for a specific field:
+ * const fieldAggregators = myField.availableAggregators;
+ *
+ * // To compute the total attachment size of an attachment field:
+ * const aggregator = aggregators.totalAttachmentSize;
+ * const value = aggregator.aggregate(myRecords, myAttachmentField);
+ * const valueAsString = aggregate.aggregateToString(myRecords, myAttachmentField);
+ * ```
+ * @docsPath models/Aggregator
+ */
+export interface Aggregator {
+    /** A unique key for this aggregator that can be used to identify it in code. */
+    key: AggregatorKey;
+    /** A user friendly name for this aggregator that can be displayed to users. */
+    displayName: string;
+    /** A short user friendly name for this aggregator that can be displayed to users. */
+    shortDisplayName: string;
+    /** Aggregates the value of `field` in each of `records` to produce a single value. */
+    aggregate(records: Array<Record>, field: Field): unknown;
+    /** Aggregates the value of `field` in each of `records` to produce a single value, formatted as a string. */
+    aggregateToString(records: Array<Record>, field: Field): string;
+}
+/**
+ * Note: this is hidden instead of internal as it is the type of the public models.aggregators.
+ *
+ * If its internal, typescript won't know about it since the types will be stripped, and typescript
+ * blocks will error due to incomplete type definitions.
+ *
+ * @hidden
+ */
+export interface Aggregators {
+    [key: string]: Aggregator;
+}
+/**
+ * Note: this is hidden instead of internal as it is used to determine the type of the public
+ * models.aggregators.
+ *
+ * If its internal, typescript won't know about it since the types will be stripped, and typescript
+ * blocks will error due to incomplete type definitions.
+ *
+ * TODO: this should be made less brittle.
+ *
+ * @hidden
+ */
+export default function createAggregators(): Aggregators;
+export declare function __injectSdkIntoCreateAggregators(_sdk: Sdk): void;
+//# sourceMappingURL=create_aggregators.d.ts.map

package/dist/types/src/base/models/create_aggregators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_aggregators.d.ts","sourceRoot":"","sources":["../../../../../src/base/models/create_aggregators.ts"],"names":[],"mappings":"AACA,mDAAmD,CAAC,MAAM;AAC1D,OAAO,EAAC,aAAa,EAAC,MAAM,sBAAsB,CAAC;AAEnD,OAAO,GAAG,MAAM,QAAQ,CAAC;AACzB,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,KAAK,MAAM,SAAS,CAAC;AAE5B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,UAAU;IACvB,gFAAgF;IAChF,GAAG,EAAE,aAAa,CAAC;IACnB,+EAA+E;IAC/E,WAAW,EAAE,MAAM,CAAC;IACpB,qFAAqF;IACrF,gBAAgB,EAAE,MAAM,CAAC;IAKzB,sFAAsF;IACtF,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IACzD,6GAA6G;IAC7G,iBAAiB,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;CACnE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;CAC7B;AAwCD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,gBAmBxC;AAMD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,GAAG,QAEzD"}