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

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

@@ -0,0 +1,144 @@
+/** @module @airtable/blocks/models: Record */ /** */
+import { Color } from '../../shared/colors';
+import { RecordCore } from '../../shared/models/record_core';
+import { ViewId, FieldId } from '../../shared/types/hyper_ids';
+import { BaseSdkMode } from '../../sdk_mode';
+import { ObjectValues } from '../../shared/private_utils';
+import LinkedRecordsQueryResult from './linked_records_query_result';
+import Field from './field';
+import View from './view';
+import { RecordQueryResultOpts } from './record_query_result';
+declare const WatchableRecordKeys: Readonly<{
+    commentCount: "commentCount";
+    name: "name";
+    cellValues: "cellValues";
+}>;
+/**
+ * Any key within record that can be watched:
+ * - `'name'`
+ * - `'commentCount'`
+ * - `'cellValues'`
+ * - `'cellValueInField:' + someFieldId`
+ * - `'colorInView:' + someViewId`
+ */
+type WatchableRecordKey = ObjectValues<typeof WatchableRecordKeys> | string;
+/**
+ * Model class representing a record in a table.
+ *
+ * Do not instantiate. You can get instances of this class by calling `table.selectRecords`
+ * or `view.selectRecords` and using the resulting {@link RecordQueryResult}.
+ *
+ * @docsPath models/Record
+ */
+declare class Record extends RecordCore<BaseSdkMode, WatchableRecordKey> {
+    /**
+     * Gets the cell value of the given field for this record, formatted as a `string`.
+     *
+     * @param fieldOrFieldIdOrFieldName The field (or field ID or field name) whose cell value you'd like to get.
+     * @example
+     * ```js
+     * const stringValue = myRecord.getCellValueAsString(myNumberField);
+     * console.log(stringValue);
+     * // => '42'
+     * ```
+     */
+    getCellValueAsString(fieldOrFieldIdOrFieldName: Field | FieldId | string): string;
+    _getRawCellValue(field: Field): unknown;
+    /**
+     * Returns a URL that is suitable for rendering an attachment on the current client.
+     * The URL that is returned will only work for the current user.
+     *
+     * @param attachmentId The ID of the attachment.
+     * @param attachmentUrl The attachment's URL (which is not suitable for rendering on the client).
+     * @example
+     * ```js
+     * import React from 'react';
+     *
+     * function RecordAttachments(props) {
+     *     const {record, attachmentField} = props;
+     *     const attachmentCellValue = record.getCellValue(attachmentField);
+     *     if (attachmentCellValue === null) {
+     *         return null;
+     *     }
+     *     return (
+     *         <div>
+     *             {attachmentCellValue.map(attachmentObj => {
+     *                 const clientUrl =
+     *                     record.getAttachmentClientUrlFromCellValueUrl(
+     *                         attachmentObj.id,
+     *                         attachmentObj.url
+     *                     );
+     *                 return (
+     *                     <img key={attachmentObj.id} src={clientUrl} width={200} />
+     *                 );
+     *             })}
+     *         </div>
+     *     );
+     * }
+     * ```
+     */
+    getAttachmentClientUrlFromCellValueUrl(attachmentId: string, attachmentUrl: string): string;
+    /**
+     * Gets the color of this record in a given view, or null if the record has no color in that
+     * view.
+     *
+     * Can be watched with the 'colorInView:${ViewId}' key.
+     *
+     * @param viewOrViewIdOrViewName The view (or view ID or view name) to use for record coloring.
+     */
+    getColorInView(viewOrViewIdOrViewName: View | ViewId | string): Color | null;
+    /**
+     * Gets the CSS hex string for this record in a given view, or null if the record has no color
+     * in that view.
+     *
+     * Can be watched with the 'colorInView:${ViewId}' key.
+     *
+     * @param viewOrViewIdOrViewName The view (or view ID or view name) to use for record coloring.
+     */
+    getColorHexInView(viewOrViewIdOrViewName: View | string): string | null;
+    /**
+     * Select records referenced in a `multipleRecordLinks` cell value. Returns a query result
+     * containing the records in the given `multipleRecordLinks` field.
+     * See {@link RecordQueryResult} for more.
+     *
+     * @param fieldOrFieldIdOrFieldName The `multipleRecordLinks` field (or field ID or field name) to use.
+     * @param opts Options for the query, such as sorts and fields.
+     */
+    selectLinkedRecordsFromCell(fieldOrFieldIdOrFieldName: Field | FieldId | string, opts?: RecordQueryResultOpts): LinkedRecordsQueryResult;
+    /**
+     * Select and load records referenced in a `multipleRecordLinks` cell value. Returns a query result
+     * promise containing the records in the given `multipleRecordLinks` field.
+     * See {@link RecordQueryResult} for more.
+     *
+     * Remember to call `queryResult.unloadData` once you're finished with the query.
+     *
+     * @param fieldOrFieldIdOrFieldName The `multipleRecordLinks` field (or field ID or field name) to use.
+     * @param opts Options for the query, such as sorts and fields.
+     */
+    selectLinkedRecordsFromCellAsync(fieldOrFieldIdOrFieldName: Field | FieldId | string, opts?: RecordQueryResultOpts): Promise<LinkedRecordsQueryResult>;
+    /**
+     * The URL for the record. You can visit this URL in the browser to be taken to the record in the Airtable UI.
+     *
+     * @example
+     * ```js
+     * console.log(myRecord.url);
+     * // => 'https://airtable.com/appxxxxxxxxxxxxxx/tblxxxxxxxxxxxxxx/recxxxxxxxxxxxxxx'
+     * ```
+     */
+    get url(): string;
+    /**
+     * The number of comments on this record.
+     *
+     * @example
+     * ```js
+     * const commentCount = myRecord.commentCount;
+     * const isSingular = commentCount === 1;
+     * console.log(
+     *     `This record has ${commentCount} comment${isSingular ? '' : 's'}`
+     * );
+     * ```
+     */
+    get commentCount(): number;
+}
+export default Record;
+//# sourceMappingURL=record.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../../../src/base/models/record.ts"],"names":[],"mappings":"AAAA,8CAA8C,CAAC,MAAM;AACrD,OAAO,EAAC,KAAK,EAAC,MAAM,qBAAqB,CAAC;AAC1C,OAAO,EAAC,UAAU,EAA0B,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAc,YAAY,EAA+B,MAAM,4BAA4B,CAAC;AAInG,OAAO,wBAAwB,MAAM,+BAA+B,CAAC;AAGrE,OAAO,KAAK,MAAM,SAAS,CAAC;AAE5B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAA0B,EAAC,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAE/E,QAAA,MAAM,mBAAmB;;;;EAGvB,CAAC;AAOH;;;;;;;GAOG;AACH,KAAK,kBAAkB,GAAG,YAAY,CAAC,OAAO,mBAAmB,CAAC,GAAG,MAAM,CAAC;AAE5E;;;;;;;GAOG;AACH,cAAM,MAAO,SAAQ,UAAU,CAAC,WAAW,EAAE,kBAAkB,CAAC;IAoC5D;;;;;;;;;;OAUG;IACH,oBAAoB,CAAC,yBAAyB,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM;IASjF,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IASvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,sCAAsC,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAS3F;;;;;;;OAOG;IACH,cAAc,CAAC,sBAAsB,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,IAAI;IAK5E;;;;;;;OAOG;IACH,iBAAiB,CAAC,sBAAsB,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI;IAOvE;;;;;;;OAOG;IACH,2BAA2B,CACvB,yBAAyB,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,EACnD,IAAI,GAAE,qBAA0B,GACjC,wBAAwB;IAoB3B;;;;;;;;;OASG;IACG,gCAAgC,CAClC,yBAAyB,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,EACnD,IAAI,GAAE,qBAA0B,GACjC,OAAO,CAAC,wBAAwB,CAAC;IAKpC;;;;;;;;OAQG;IACH,IAAI,GAAG,IAAI,MAAM,CAKhB;IACD;;;;;;;;;;;OAWG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;CAsBJ;AAED,eAAe,MAAM,CAAC"}

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

@@ -0,0 +1,97 @@
+/** @module @airtable/blocks/models: Record Coloring */ /** */
+import { ObjectValues } from '../../shared/private_utils';
+import Field from './field';
+import View from './view';
+/**
+ * An enum of the different types of {@link recordColoring.modes}
+ *
+ * @hidden
+ * @alias recordColoring.ModeTypes
+ */
+export declare const ModeTypes: {
+    /**
+     * @alias recordColoring.ModeTypes.NONE
+     */
+    NONE: "none";
+    /**
+     * @alias recordColoring.ModeTypes.BY_SELECT_FIELD
+     */
+    BY_SELECT_FIELD: "bySelectField";
+    /**
+     * @alias recordColoring.ModeTypes.BY_VIEW
+     */
+    BY_VIEW: "byView";
+};
+/**
+ * @hidden
+ */
+export type RecordColorModeType = ObjectValues<typeof ModeTypes>;
+/** */
+interface NoRecordColorMode {
+    /** */
+    type: typeof ModeTypes.NONE;
+}
+/** */
+interface BySelectFieldRecordColorMode {
+    /** */
+    type: typeof ModeTypes.BY_SELECT_FIELD;
+    /** */
+    selectField: Field;
+}
+/** */
+interface ByViewRecordColorMode {
+    /** */
+    type: typeof ModeTypes.BY_VIEW;
+    /** */
+    view: View;
+}
+/** */
+export type RecordColorMode = NoRecordColorMode | BySelectFieldRecordColorMode | ByViewRecordColorMode;
+export declare const serialize: (mode: RecordColorMode) => string;
+/**
+ * Record coloring config creators.
+ *
+ * @alias recordColoring.modes
+ * @example
+ * ```js
+ * import {recordColoring} from '@airtable/blocks/models';
+ * import {useRecords} from '@airtable/blocks/ui';
+ *
+ * // no record coloring:
+ * const recordColorMode = recordColoring.modes.none();
+ * // color by select field:
+ * const recordColorMode = recordColoring.modes.bySelectField(someSelectField);
+ * // color from view:
+ * const recordColorMode = recordColoring.modes.byView(someView);
+ *
+ * // with useRecords:
+ * const queryResult = useRecords(table, { recordColorMode })
+ *
+ * // with a query result:
+ * const queryResult = table.selectRecords({ recordColorMode });
+ * ```
+ */
+export declare const modes: {
+    /**
+     * Returns a {@link RecordColorMode} that represents no record coloring.
+     *
+     * @alias recordColoring.modes.none
+     */
+    none(): NoRecordColorMode;
+    /**
+     * Returns a {@link RecordColorMode} that colors records by the specified Select field.
+     *
+     * @alias recordColoring.modes.bySelectField
+     * @param selectField
+     */
+    bySelectField(selectField: Field): BySelectFieldRecordColorMode;
+    /**
+     * Returns a {@link RecordColorMode} that colors records by the specified View.
+     *
+     * @alias recordColoring.modes.byView
+     * @param view
+     */
+    byView(view: View): ByViewRecordColorMode;
+};
+export {};
+//# sourceMappingURL=record_coloring.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"record_coloring.d.ts","sourceRoot":"","sources":["../../../../../src/base/models/record_coloring.ts"],"names":[],"mappings":"AAAA,uDAAuD,CAAC,MAAM;AAC9D,OAAO,EAAC,YAAY,EAAC,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAG1B;;;;;GAKG;AACH,eAAO,MAAM,SAAS;IAClB;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;CAEN,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,YAAY,CAAC,OAAO,SAAS,CAAC,CAAC;AAEjE,MAAM;AACN,UAAU,iBAAiB;IACvB,MAAM;IACN,IAAI,EAAE,OAAO,SAAS,CAAC,IAAI,CAAC;CAC/B;AAED,MAAM;AACN,UAAU,4BAA4B;IAClC,MAAM;IACN,IAAI,EAAE,OAAO,SAAS,CAAC,eAAe,CAAC;IACvC,MAAM;IACN,WAAW,EAAE,KAAK,CAAC;CACtB;AAED,MAAM;AACN,UAAU,qBAAqB;IAC3B,MAAM;IACN,IAAI,EAAE,OAAO,SAAS,CAAC,OAAO,CAAC;IAC/B,MAAM;IACN,IAAI,EAAE,IAAI,CAAC;CACd;AAED,MAAM;AACN,MAAM,MAAM,eAAe,GACrB,iBAAiB,GACjB,4BAA4B,GAC5B,qBAAqB,CAAC;AAE5B,eAAO,MAAM,SAAS,SAAU,eAAe,WAQ9C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK;IACd;;;;OAIG;YACK,iBAAiB;IAKzB;;;;;OAKG;+BACwB,KAAK,GAAG,4BAA4B;IAM/D;;;;;OAKG;iBACU,IAAI,GAAG,qBAAqB;CAM5C,CAAC"}

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

@@ -0,0 +1,341 @@
+/** @module @airtable/blocks/models: RecordQueryResult */ /** */
+import { Color } from '../../shared/colors';
+import { FieldId, RecordId } from '../../shared/types/hyper_ids';
+import { ObjectValues, FlowAnyFunction, FlowAnyObject } from '../../shared/private_utils';
+import AbstractModelWithAsyncData from './abstract_model_with_async_data';
+import Field from './field';
+import Record from './record';
+import { RecordColorMode } from './record_coloring';
+declare const WatchableRecordQueryResultKeys: Readonly<{
+    records: "records";
+    recordIds: "recordIds";
+    cellValues: "cellValues";
+    recordColors: "recordColors";
+    groups: "groups";
+    groupLevels: "groupLevels";
+    isDataLoaded: "isDataLoaded";
+}>;
+/**
+ * A key in {@link RecordQueryResult} that can be watched
+ * - `records`
+ * - `recordIds`
+ * - `cellValues`
+ * - `recordColors`
+ * - `isDataLoaded`
+ * - `cellValuesInField:{FIELD_ID}`
+ */
+export type WatchableRecordQueryResultKey = ObjectValues<typeof WatchableRecordQueryResultKeys> | string;
+/** */
+interface SortConfig {
+    /** A field, field id, or field name. */
+    field: Field | FieldId | string;
+    /** The order to sort in. Defaults to asc. */
+    direction?: 'asc' | 'desc';
+}
+/** @hidden */
+export interface NormalizedSortConfig {
+    fieldId: string;
+    direction: 'asc' | 'desc';
+}
+/**
+ * NormalizedGroupLevel is in airtable_interface
+ *
+ * @hidden
+ */
+export interface GroupLevelForUpdate {
+    /** A field, field id, or field name. */
+    field: Field | FieldId | string;
+    /** The order to sort this group in. Defaults to asc. */
+    direction?: 'asc' | 'desc' | undefined;
+}
+/**
+ * View Config that can be set by developer
+ *
+ * @hidden
+ */
+export interface ViewMetadataForUpdate {
+    /** Groups config that can be set by developer; null will clear it, undefined will skip it*/
+    groupLevels?: Array<GroupLevelForUpdate> | null | undefined;
+}
+/**
+ * Used to control what data is loaded in a {@link RecordQueryResult}. Used when creating a
+ * query result using `table/view.selectRecords()` and in convenience hooks {@link useRecords}.
+ *
+ * ## sorts
+ * Pass an array of sorts to control the order of records. The first sort in the array has the
+ * highest priority. If you don't specify sorts, the result will use the inherent order of the
+ * source model: the same order you'd see in the main UI for views and linked record fields, and
+ * an arbitrary (but stable) order for tables.
+ *
+ * Record creation time is used as a tiebreaker: pass an empty array to sort by creation time.
+ *
+ * ```js
+ * const opts = {
+ *     sorts: [
+ *         // sort by someField in ascending order...
+ *         {field: someField},
+ *         // then by someOtherField in descending order
+ *         {field: someOtherField, direction: 'desc'},
+ *     ]
+ * };
+ * const records = useRecords(table, opts);
+ * const queryResult = table.selectRecords(opts);
+ * ```
+ *
+ * ## fields
+ * Generally, it's a good idea to load as little data into your extension as possible - Airtable bases
+ * can get pretty big, and we have to keep all that information in memory and up to date if you ask
+ * for it. The fields option lets you make sure that only data relevant to you is loaded.
+ *
+ * You can specify fields with a {@link Field}, by ID, or by name:
+ * ```js
+ * const opts = {
+ *     fields: [
+ *         // we want to only load fieldA:
+ *         fieldA,
+ *         // the field with this id:
+ *         'fldXXXXXXXXXXXXXX',
+ *         // and the field named 'Rating':
+ *         'Rating',
+ *     ],
+ * };
+ * const records = useRecords(table, opts);
+ * const queryResult = table.selectRecords(opts);
+ * ```
+ *
+ * ## recordColorMode
+ * Just like a view in Airtable, you can control the colors of records in a field. There are three
+ * supported record color modes: none, by a view, and by a select field.
+ *
+ * ```js
+ * import {recordColoring} from '@airtable/blocks/models';
+ * // No record coloring:
+ * const opts = {
+ *     recordColorMode: recordColoring.modes.none(),
+ * };
+ *
+ * // Color according to the rules of a view:
+ * const opts = {
+ *     recordColorMode: recordColoring.modes.byView(someView),
+ * };
+ *
+ * // Color by a single select field:
+ * const opts = {
+ *     recordColorMode: recordColoring.modes.bySelectField(someSelectField),
+ * });
+ * ```
+ *
+ * You can access view coloring information directly from a {@link RecordQueryResult} or a
+ * {@link Record}, but you can only directly access single select coloring from a RecordQueryResult:
+ *
+ * ```
+ * const queryResult = table.selectRecords(opts);
+ * const records = useRecords(table, opts);
+ *
+ * // Returns based on opts coloring mode
+ * queryResult.getRecordColor(recordId);
+ *
+ * // Returns based on view
+ * // Will throw if you did not pass recordColoring.modes.byView(view) in opts
+ * records[0].getColorInView(view);
+ * ```
+ *
+ * Use `record.getCellValue(singleSelectField).color` to access the color of a single select field
+ * for a record.
+ *
+ * By default, views will have whichever coloring is set up in Airtable and tables won't have any
+ * record coloring:
+ *
+ * ```js
+ * // these two are the same:
+ * someView.selectRecords();
+ * someView.selectRecords({
+ *     recordColorMode: recordColoring.modes.byView(someView),
+ * });
+ *
+ * // as are these two:
+ * someTable.selectRecords();
+ * someTable.selectRecords({
+ *     recordColorMode: recordColoring.modes.none(),
+ * });
+ * ```
+ *
+ * */
+export interface RecordQueryResultOpts {
+    /** The order in which to sort the query result */
+    sorts?: Array<SortConfig>;
+    /** The fields (or field names or field ids) to load. Falsey values will be removed. */
+    fields?: Array<Field | FieldId | string | void | null | false>;
+    /** How records in this QueryResult should be colored. */
+    recordColorMode?: null | RecordColorMode;
+}
+/**
+ * A subset of {@link RecordQueryResultOpts} used in {@link useRecordById} that omits sorts, as
+ * there is only a single record.
+ *
+ * See RecordQueryResultOpts for full details and examples.
+ *
+ * ```js
+ * const opts = {
+ *     fields: ['My field'],
+ *     recordColorMode: recordColoring.modes.byView(view),
+ * };
+ * const record = useRecordById(table, recordId, opts);
+ * */
+export type SingleRecordQueryResultOpts = Pick<RecordQueryResultOpts, 'fields' | 'recordColorMode'>;
+/**
+ * A subset of {@link RecordQueryResultOpts} used in {@link useRecordIds} that omits fields and
+ * recordColorMode, as record cell values and color are not accessible via this hook.
+ *
+ * See RecordQueryResultOpts for full details and examples.
+ *
+ * ```js
+ * const opts = {
+ *     sorts: [
+ *         // sort by someField in ascending order...
+ *         {field: someField},
+ *         // then by someOtherField in descending order
+ *         {field: someOtherField, direction: 'desc'},
+ *     ]
+ * };
+ * const recordIds = useRecordIds(table, opts);
+ * */
+export type RecordIdQueryResultOpts = Pick<RecordQueryResultOpts, 'sorts'>;
+/**
+ * A RecordQueryResult represents a set of records. It's a little bit like a one-off View in Airtable: it
+ * contains a bunch of records, filtered to a useful subset of the records in the table. Those
+ * records can be sorted according to your specification, and they can be colored by a select field
+ * or using the color from a view. Just like a view, you can either have all the fields in a table
+ * available, or you can just ask for the fields that are relevant to you. There are two types of
+ * QueryResult:
+ *
+ * - {@link TableOrViewQueryResult} is the most common, and is a query result filtered to all the
+ *   records in a specific {@link Table} or {@link View}. You can get one of these with
+ *   `table.selectRecords()` or `view.selectRecords()`.
+ * - {@link LinkedRecordsQueryResult} is a query result of all the records in a particular
+ *   [linked record cell](https://support.airtable.com/hc/en-us/articles/206452848-Linked-record-fields).
+ *   You can get one of these with `record.selectLinkedRecordsFromCell(someField)`.
+ *
+ * Once you've got a query result, you need to load it before you can start working with it -
+ * extensions don't load record data by default. We recommend using {@link useRecords},
+ * {@link useRecordIds}, {@link useRecordById} or {@link useLoadable} to handle this.
+ *
+ * If you're not using a query result in a React component, you can manually load the data and
+ * unload it when you're finished:
+ *
+ * ```js
+ * async function fetchRecordsAndDoSomethingAsync(myTable) {
+ *     // query for all the records in "myTable"
+ *     const queryResult = myTable.selectRecords();
+ *
+ *     // load the data in the query result:
+ *     await queryResult.loadDataAsync();
+ *
+ *     // work with the data in the query result
+ *     doSomething(queryResult);
+ *
+ *     // when you're done, unload the data:
+ *     queryResult.unloadData();
+ * }
+ * ```
+ *
+ * Whilst loaded, a query result will automatically keep up to date with what's in Airtable:
+ * records will get added or removed, the order will change, cell values will be updated, etc.
+ * Again, if you're writing a React component then our hooks will look after that for you. If not,
+ * you can get notified of these changes with `.watch()`.
+ *
+ * When calling a `.select*` method, you can pass in a number of options to control the sort order,
+ * fields loaded and coloring mode of records: see {@link RecordQueryResultOpts} for examples.
+ *
+ * @docsPath models/query results/RecordQueryResult
+ */
+declare abstract class RecordQueryResult<DataType = {}> extends AbstractModelWithAsyncData<DataType, WatchableRecordQueryResultKey> {
+    /**
+     * The record IDs in this QueryResult.
+     * Throws if data is not loaded yet.
+     * Can be watched.
+     */
+    abstract get recordIds(): Array<RecordId>;
+    /**
+     * The fields that were used to create this QueryResult.
+     * Null if fields were not specified, which means the QueryResult
+     * will load all fields in the table.
+     */
+    abstract get fields(): Array<Field> | null;
+    /**
+     * The records in this RecordQueryResult.
+     * Throws if data is not loaded yet.
+     * Can be watched.
+     */
+    get records(): Array<Record>;
+    /**
+     * Get a specific record in the query result, or null if that record doesn't exist or is
+     * filtered out. Throws if data is not loaded yet. Watch using `'recordIds'`.
+     *
+     * @param recordId the ID of the {@link Record} you want
+     */
+    getRecordByIdIfExists(recordId: RecordId): Record | null;
+    /**
+     * Get a specific record in the query result, or throws if that record doesn't exist or is
+     * filtered out. Throws if data is not loaded yet. Watch using `'recordIds'`.
+     *
+     * @param recordId the ID of the {@link Record} you want
+     */
+    getRecordById(recordId: RecordId): Record;
+    /**
+     * Check to see if a particular record or record id is present in this query result. Returns
+     * false if the record has been deleted or is filtered out.
+     *
+     * @param recordOrRecordId the record or record id to check the presence of
+     */
+    hasRecord(recordOrRecordId: RecordId | Record): boolean;
+    /**
+     * Get the {@link Color} of a specific record in the query result. Returns null if the record
+     * has no color in this query result. Throws if the record isn't in the RecordQueryResult. Watch
+     * with the `'recordColors'` and `'recordIds` keys.
+     *
+     * @param recordOrRecordId the record or record ID you want the color of.
+     */
+    getRecordColor(recordOrRecordId: RecordId | Record): Color | null;
+    /**
+     * Get notified of changes to the query result.
+     *
+     * Watchable keys are:
+     * - `'records'`
+     * - `'recordIds'`
+     * - `'cellValues'`
+     * - `'recordColors'`
+     * - `'isDataLoaded'`
+     * - `'cellValuesInField:' + someFieldId`
+     *
+     * Every call to `.watch` should have a matching call to `.unwatch`.
+     *
+     * 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.
+     *
+     * Returns the array of keys that were watched.
+     *
+     * @param keys the keys to watch
+     * @param callback a function to call when those keys change
+     * @param context an optional context for `this` in `callback`.
+     */
+    watch(keys: WatchableRecordQueryResultKey | ReadonlyArray<WatchableRecordQueryResultKey>, callback: FlowAnyFunction, context?: FlowAnyObject | null): Array<WatchableRecordQueryResultKey>;
+    /**
+     * Unwatch keys watched with `.watch`.
+     *
+     * Should be called with the same arguments given to `.watch`.
+     *
+     * Unwatching a key that needs to load data asynchronously will automatically
+     * cause the data to be unloaded.
+     *
+     * Returns the array of keys that were unwatched
+     *
+     * @param keys the keys to unwatch
+     * @param callback the function passed to `.watch` for these keys
+     * @param context the context that was passed to `.watch` for this `callback`
+     */
+    unwatch(keys: WatchableRecordQueryResultKey | ReadonlyArray<WatchableRecordQueryResultKey>, callback: FlowAnyFunction, context?: FlowAnyObject | null): Array<WatchableRecordQueryResultKey>;
+}
+export default RecordQueryResult;
+//# sourceMappingURL=record_query_result.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"record_query_result.d.ts","sourceRoot":"","sources":["../../../../../src/base/models/record_query_result.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+export declare const WatchableRecordStoreKeys: Readonly<{
+    records: "records";
+    recordIds: "recordIds";
+    cellValues: "cellValues";
+}>;
+//# sourceMappingURL=record_store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"record_store.d.ts","sourceRoot":"","sources":["../../../../../src/base/models/record_store.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,wBAAwB;;;;EAEnC,CAAC"}