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

package/dist/types/src/shared/global_config.d.ts

@@ -0,0 +1,235 @@
+import Watchable from './watchable';
+import { GlobalConfigKey, PartialGlobalConfigKey, GlobalConfigValue, GlobalConfigUpdate, PartialGlobalConfigUpdate } from './types/global_config';
+import { PermissionCheckResult } from './types/mutations_core';
+/**
+ * You can watch any top-level key in global config. Use '*' to watch every change.
+ */
+type WatchableGlobalConfigKey = string;
+/**
+ * A key-value store for persisting configuration options for an extension installation.
+ *
+ * The contents will be synced in real-time to all logged-in users of the installation.
+ * Contents will not be updated in real-time when the installation is running in
+ * a publicly shared base.
+ *
+ * Any key can be watched to know when the value of the key changes. If you want your
+ * component to automatically re-render whenever any key on GlobalConfig changes, try using the
+ * {@link useGlobalConfig} hook.
+ *
+ * You should not need to construct this object yourself.
+ *
+ * The maximum allowed size for a given GlobalConfig instance is 150kB.
+ * The maximum number of keys for a given GlobalConfig instance is 1000.
+ *
+ * @example
+ * ```js
+ * import {globalConfig} from '@airtable/blocks';
+ * ```
+ * @docsPath models/GlobalConfig
+ */
+declare class GlobalConfig extends Watchable<WatchableGlobalConfigKey> {
+    /**
+     * Get the value at a path. Throws an error if the path is invalid.
+     *
+     * Returns undefined if no value exists at that path.
+     *
+     * @param key A string for the top-level key, or an array of strings describing the path to the value.
+     * @example
+     * ```js
+     * import {globalConfig} from '@airtable/blocks';
+     *
+     * const topLevelValue = globalConfig.get('topLevelKey');
+     * const nestedValue = globalConfig.get(['topLevelKey', 'nested', 'deeply']);
+     * ```
+     */
+    get(key: GlobalConfigKey): unknown;
+    /**
+     * Checks whether the current user has permission to set the given global config key.
+     *
+     * Accepts partial input, in the same format as {@link setAsync}.
+     * The more information provided, the more accurate the permissions check will be.
+     *
+     * Returns `{hasPermission: true}` if the current user can set the specified key,
+     * `{hasPermission: false, reasonDisplayString: string}` otherwise.  `reasonDisplayString` may
+     * be used to display an error message to the user.
+     *
+     * @param key A string for the top-level key, or an array of strings describing the path to set.
+     * @param value The value to set at the specified path. Use `undefined` to delete the value at the given path.
+     *
+     * @example
+     * ```js
+     * // Check if user can update a specific key and value.
+     * const setCheckResult =
+     *     globalConfig.checkPermissionsForSet('favoriteColor', 'purple');
+     * if (!setCheckResult.hasPermission) {
+     *     alert(setCheckResult.reasonDisplayString);
+     * }
+     *
+     * // Check if user can update a specific key without knowing the value
+     * const setKeyCheckResult =
+     *     globalConfig.checkPermissionsForSet('favoriteColor');
+     *
+     * // Check if user can update globalConfig without knowing key or value
+     * const setUnknownKeyCheckResult = globalConfig.checkPermissionsForSet();
+     * ```
+     */
+    checkPermissionsForSet(key?: PartialGlobalConfigKey, value?: GlobalConfigValue): PermissionCheckResult;
+    /**
+     * An alias for `globalConfig.checkPermissionsForSet(key, value).hasPermission`.
+     *
+     * Checks whether the current user has permission to set the given global config key.
+     *
+     * Accepts partial input, in the same format as {@link setAsync}.
+     * The more information provided, the more accurate the permissions check will be.
+     *
+     * @param key A string for the top-level key, or an array of strings describing the path to set.
+     * @param value The value to set at the specified path. Use `undefined` to delete the value at the given path.
+     *
+     * @example
+     * ```js
+     * // Check if user can update a specific key and value.
+     * const canSetFavoriteColorToPurple =
+     *     globalConfig.hasPermissionToSet('favoriteColor', 'purple');
+     * if (!canSetFavoriteColorToPurple) {
+     *     alert('Not allowed!');
+     * }
+     *
+     * // Check if user can update a specific key without knowing the value
+     * const canSetFavoriteColor = globalConfig.hasPermissionToSet('favoriteColor');
+     *
+     * // Check if user can update globalConfig without knowing key or value
+     * const canSetGlobalConfig = globalConfig.hasPermissionToSet();
+     * ```
+     */
+    hasPermissionToSet(key?: PartialGlobalConfigKey, value?: GlobalConfigValue): boolean;
+    /**
+     * Sets a value at a path. Throws an error if the path or value is invalid.
+     *
+     * This action is asynchronous: `await` the returned promise if you wish to wait for the
+     * update to be persisted to Airtable servers.
+     *
+     * Updates are applied optimistically locally, so your change will be reflected in
+     * {@link GlobalConfig} before the promise resolves.
+     *
+     * @param key A string for the top-level key, or an array of strings describing the path to set.
+     * @param value The value to set at the specified path. Use `undefined` to delete the value at the given path.
+     * @example
+     * ```js
+     * import {globalConfig} from '@airtable/blocks';
+     *
+     * function updateFavoriteColorIfPossible(color) {
+     *     if (globalConfig.hasPermissionToSetPaths('favoriteColor', color)) {
+     *         globalConfig.setAsync('favoriteColor', color);
+     *     }
+     *     // The update is now applied within your extension (eg will be
+     *     // reflected in globalConfig) but are still being saved to
+     *     // Airtable servers (e.g. may not be updated for other users yet)
+     * }
+     *
+     * async function updateFavoriteColorIfPossibleAsync(color) {
+     *     if (globalConfig.hasPermissionToSet('favoriteColor', color)) {
+     *         await globalConfig.setAsync('favoriteColor', color);
+     *     }
+     *     // globalConfig updates have been saved to Airtable servers.
+     *     alert('favoriteColor has been updated');
+     * }
+     * ```
+     */
+    setAsync(key: GlobalConfigKey, value?: GlobalConfigValue): Promise<void>;
+    /**
+     * Checks whether the current user has permission to perform the specified updates to global config.
+     *
+     * Accepts partial input, in the same format as {@link setPathsAsync}.
+     * The more information provided, the more accurate the permissions check will be.
+     *
+     * Returns `{hasPermission: true}` if the current user can set the specified key,
+     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+     * used to display an error message to the user.
+     *
+     * @param updates The paths and values to set.
+     * @example
+     * ```js
+     * // Check if user can update a specific keys and values.
+     * const setPathsCheckResult = globalConfig.checkPermissionsForSet([
+     *     {path: ['topLevelKey1', 'nestedKey1'], value: 'foo'},
+     *     {path: ['topLevelKey2', 'nestedKey2'], value: 'bar'},
+     * ]);
+     * if (!setPathsCheckResult.hasPermission) {
+     *     alert(setPathsCheckResult.reasonDisplayString);
+     * }
+     *
+     * // Check if user could potentially set globalConfig values.
+     * // Equivalent to globalConfig.checkPermissionsForSet()
+     * const setUnknownPathsCheckResult =
+     *     globalConfig.checkPermissionsForSetPaths();
+     * ```
+     */
+    checkPermissionsForSetPaths(updates?: ReadonlyArray<PartialGlobalConfigUpdate>): PermissionCheckResult;
+    /**
+     * An alias for `globalConfig.checkPermissionsForSetPaths(updates).hasPermission`.
+     *
+     * Checks whether the current user has permission to perform the specified updates to global
+     * config.
+     *
+     * Accepts partial input, in the same format as {@link setPathsAsync}.
+     * The more information provided, the more accurate the permissions check will be.
+     *
+     * @param updates The paths and values to set.
+     *
+     * @example
+     * ```js
+     * // Check if user can update a specific keys and values.
+     * const canSetPaths = globalConfig.hasPermissionToSetPaths([
+     *     {path: ['topLevelKey1', 'nestedKey1'], value: 'foo'},
+     *     {path: ['topLevelKey2', 'nestedKey2'], value: 'bar'},
+     * ]);
+     * if (!canSetPaths) {
+     *     alert('not allowed!');
+     * }
+     *
+     * // Check if user could potentially set globalConfig values.
+     * // Equivalent to globalConfig.hasPermissionToSet()
+     * const canSetAnyPaths = globalConfig.hasPermissionToSetPaths();
+     * ```
+     */
+    hasPermissionToSetPaths(updates?: ReadonlyArray<PartialGlobalConfigUpdate>): boolean;
+    /**
+     * Sets multiple values. Throws if any path or value is invalid.
+     *
+     * This action is asynchronous: `await` the returned promise if you wish to wait for the
+     * updates to be persisted to Airtable servers.
+     * Updates are applied optimistically locally, so your changes will be reflected in
+     * {@link GlobalConfig} before the promise resolves.
+     *
+     * @param updates The paths and values to set.
+     * @example
+     * ```js
+     * import {globalConfig} from '@airtable/blocks';
+     *
+     * const updates = [
+     *     {path: ['topLevelKey1', 'nestedKey1'], value: 'foo'},
+     *     {path: ['topLevelKey2', 'nestedKey2'], value: 'bar'},
+     * ];
+     *
+     * function applyUpdatesIfPossible() {
+     *     if (globalConfig.hasPermissionToSetPaths(updates)) {
+     *         globalConfig.setPathsAsync(updates);
+     *     }
+     *     // The updates are now applied within your extension (eg will be reflected in
+     *     // globalConfig) but are still being saved to Airtable servers (e.g. they
+     *     // may not be updated for other users yet)
+     * }
+     *
+     * async function applyUpdatesIfPossibleAsync() {
+     *     if (globalConfig.hasPermissionToSetPaths(updates)) {
+     *         await globalConfig.setPathsAsync(updates);
+     *     }
+     *     // globalConfig updates have been saved to Airtable servers.
+     *     alert('globalConfig has been updated');
+     * }
+     * ```
+     */
+    setPathsAsync(updates: Array<GlobalConfigUpdate>): Promise<void>;
+}
+export default GlobalConfig;
+//# sourceMappingURL=global_config.d.ts.map

package/dist/types/src/shared/global_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global_config.d.ts","sourceRoot":"","sources":["../../../../src/shared/global_config.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,aAAa,CAAC;AAEpC,OAAO,EAEH,eAAe,EACf,sBAAsB,EACtB,iBAAiB,EAEjB,kBAAkB,EAClB,yBAAyB,EAE5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAC,qBAAqB,EAAoB,MAAM,wBAAwB,CAAC;AAKhF;;GAEG;AACH,KAAK,wBAAwB,GAAG,MAAM,CAAC;AASvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,cAAM,YAAa,SAAQ,SAAS,CAAC,wBAAwB,CAAC;IA6D1D;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO;IAalC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAAsB,CAClB,GAAG,CAAC,EAAE,sBAAsB,EAC5B,KAAK,CAAC,EAAE,iBAAiB,GAC1B,qBAAqB;IAKxB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,kBAAkB,CAAC,GAAG,CAAC,EAAE,sBAAsB,EAAE,KAAK,CAAC,EAAE,iBAAiB,GAAG,OAAO;IAGpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,QAAQ,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9E;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,2BAA2B,CACvB,OAAO,CAAC,EAAE,aAAa,CAAC,yBAAyB,CAAC,GACnD,qBAAqB;IAQxB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,uBAAuB,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,yBAAyB,CAAC,GAAG,OAAO;IAGpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAiDzE;AAED,eAAe,YAAY,CAAC"}

package/dist/types/src/shared/models/abstract_model.d.ts

@@ -0,0 +1,29 @@
+import Watchable from '../watchable';
+import { SdkMode } from '../../sdk_mode';
+/**
+ * Abstract superclass for all models. You won't use this class directly.
+ *
+ * @docsPath models/advanced/AbstractModel
+ */
+declare abstract class AbstractModel<SdkModeT extends SdkMode, DataType, WatchableKey extends string> extends Watchable<WatchableKey> {
+    /**
+     * The ID for this model.
+     */
+    get id(): string;
+    /**
+     * `true` if the model has been deleted, and `false` otherwise.
+     *
+     * In general, it's best to avoid keeping a reference to an object past the
+     * current event loop, since it may be deleted and trying to access any data
+     * of a deleted object (other than its ID) will throw. But if you keep a
+     * reference, you can use `isDeleted` to check that it's safe to access the
+     * model's data.
+     */
+    get isDeleted(): boolean;
+    /**
+     * A string representation of the model for use in debugging.
+     */
+    toString(): string;
+}
+export default AbstractModel;
+//# sourceMappingURL=abstract_model.d.ts.map

package/dist/types/src/shared/models/abstract_model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract_model.d.ts","sourceRoot":"","sources":["../../../../../src/shared/models/abstract_model.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAEvC;;;;GAIG;AACH,uBAAe,aAAa,CACxB,QAAQ,SAAS,OAAO,EACxB,QAAQ,EACR,YAAY,SAAS,MAAM,CAC7B,SAAQ,SAAS,CAAC,YAAY,CAAC;IAsC7B;;OAEG;IACH,IAAI,EAAE,IAAI,MAAM,CAEf;IAeD;;;;;;;;OAQG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAUD;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGrB;AAED,eAAe,aAAa,CAAC"}

package/dist/types/src/shared/models/base_core.d.ts

@@ -0,0 +1,168 @@
+import { CollaboratorData } from '../types/collaborator';
+import { TableId, UserId } from '../types/hyper_ids';
+import { ObjectValues } from '../private_utils';
+import { SdkMode } from '../../sdk_mode';
+import AbstractModel from './abstract_model';
+export declare const WatchableBaseKeys: Readonly<{
+    name: "name";
+    tables: "tables";
+    collaborators: "collaborators";
+    schema: "schema";
+    color: "color";
+}>;
+/**
+ * Any key in base that can be watched:
+ * - `name`: the name of the base
+ * - `tables`: the order of tables in the base
+ * - `collaborators`: all the collaborators in the base
+ * - `schema`: the base schema (essentially everything except for record data)
+ */
+type WatchableBaseKey = ObjectValues<typeof WatchableBaseKeys>;
+/** @hidden */
+export declare abstract class BaseCore<SdkModeT extends SdkMode> extends AbstractModel<SdkModeT, SdkModeT['BaseDataT'], WatchableBaseKey> {
+    /**
+     * The name of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log('The name of your base is', base.name);
+     * ```
+     */
+    get name(): string;
+    /**
+     * The workspace id of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log('The workspace id of your base is', base.workspaceId);
+     * ```
+     */
+    get workspaceId(): string;
+    /**
+     * The color of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * import {Box} from '@airtable/blocks/ui';
+     * const exampleBox = <Box backgroundColor={base.color}> This box's background is the same color as the base background</Box>
+     * ```
+     */
+    get color(): string;
+    /**
+     * The tables in this base. Can be watched to know when tables are created, deleted, or reordered in the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log(`You have ${base.tables.length} tables`);
+     * ```
+     */
+    get tables(): Array<SdkModeT['TableT']>;
+    /**
+     * The users who have access to this base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log(base.activeCollaborators[0].email);
+     * ```
+     */
+    get activeCollaborators(): Array<CollaboratorData>;
+    /**
+     * The user matching the given ID, or `null` if that user does not exist or does not have access
+     * to this base.
+     *
+     * @param collaboratorId The ID of the user.
+     */
+    getCollaboratorByIdIfExists(collaboratorId: UserId): CollaboratorData | null;
+    /**
+     * The user matching the given ID. Throws if that user does not exist
+     * or does not have access to this base. Use {@link getCollaboratorByIdIfExists}
+     * instead if you are unsure whether a collaborator with the given ID exists
+     * and has access to this base.
+     *
+     * @param collaboratorId The ID of the user.
+     */
+    getCollaboratorById(collaboratorId: UserId): CollaboratorData;
+    /**
+     * The user matching the given ID, name, or email address. Returns null if that user does not
+     * exist or does not have access to this base.
+     *
+     * This method is convenient when building an extension for a specific base, but for more generic
+     * extensions the best practice is to use the {@link getCollaboratorByIdIfExists} method instead.
+     *
+     * @param collaboratorIdOrNameOrEmail The ID of the user.
+     */
+    getCollaboratorIfExists(idOrNameOrEmail: UserId | string): CollaboratorData | null;
+    /**
+     * The user matching the given ID, name, or email address. Throws if that user does not exist
+     * or does not have access to this base. Use {@link getCollaboratorIfExists} instead if you are
+     * unsure whether a collaborator with the given ID exists and has access to this base.
+     *
+     * This method is convenient when building an extension for a specific base, but for more generic
+     * extensions the best practice is to use the {@link getCollaboratorById} method instead.
+     *
+     * @param collaboratorIdOrNameOrEmail The ID of the user.
+     */
+    getCollaborator(idOrNameOrEmail: UserId | string): CollaboratorData | null;
+    /**
+     * The table matching the given ID, or `null` if that table does not exist in this base.
+     *
+     * @param tableId The ID of the table.
+     */
+    getTableByIdIfExists(tableId: string): SdkModeT['TableT'] | null;
+    /**
+     * The table matching the given ID. Throws if that table does not exist in this base. Use
+     * {@link getTableByIdIfExists} instead if you are unsure whether a table exists with the given
+     * ID.
+     *
+     * @param tableId The ID of the table.
+     */
+    getTableById(tableId: string): SdkModeT['TableT'];
+    /**
+     * The table matching the given name, or `null` if no table exists with that name in this base.
+     *
+     * @param tableName The name of the table you're looking for.
+     */
+    getTableByNameIfExists(tableName: string): SdkModeT['TableT'] | null;
+    /**
+     * The table matching the given name. Throws if no table exists with that name in this base. Use
+     * {@link getTableByNameIfExists} instead if you are unsure whether a table exists with the
+     * given name.
+     *
+     * @param tableName The name of the table you're looking for.
+     */
+    getTableByName(tableName: string): SdkModeT['TableT'];
+    /**
+     * The table matching the given ID or name. Returns `null` if no matching table exists within
+     * this base.
+     *
+     * This method is convenient when building an extension for a specific base, but for more generic
+     * extensions the best practice is to use the {@link getTableByIdIfExists} or
+     * {@link getTableByNameIfExists} methods instead.
+     *
+     * @param tableIdOrName The ID or name of the table you're looking for.
+     */
+    getTableIfExists(tableIdOrName: TableId | string): SdkModeT['TableT'] | null;
+    /**
+     * The table matching the given ID or name. Throws if no matching table exists within this base.
+     * Use {@link getTableIfExists} instead if you are unsure whether a table exists with the given
+     * name/ID.
+     *
+     * This method is convenient when building an extension for a specific base, but for more generic
+     * extensions the best practice is to use the {@link getTableById} or {@link getTableByName} methods
+     * instead.
+     *
+     * @param tableIdOrName The ID or name of the table you're looking for.
+     */
+    getTable(tableIdOrName: TableId | string): SdkModeT['TableT'];
+    /**
+     * Returns the maximum number of records allowed in each table of this base.
+     */
+    getMaxRecordsPerTable(): number;
+}
+export {};
+//# sourceMappingURL=base_core.d.ts.map

package/dist/types/src/shared/models/base_core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_core.d.ts","sourceRoot":"","sources":["../../../../../src/shared/models/base_core.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,gBAAgB,EAAC,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAC,OAAO,EAAE,MAAM,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAoC,YAAY,EAAiB,MAAM,kBAAkB,CAAC;AAEjG,OAAO,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AACvC,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAgB7C,eAAO,MAAM,iBAAiB;;;;;;EAM5B,CAAC;AAEH;;;;;;GAMG;AACH,KAAK,gBAAgB,GAAG,YAAY,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAa/D,cAAc;AACd,8BAAsB,QAAQ,CAAC,QAAQ,SAAS,OAAO,CAAE,SAAQ,aAAa,CAC1E,QAAQ,EACR,QAAQ,CAAC,WAAW,CAAC,EACrB,gBAAgB,CACnB;IAwCG;;;;;;;;OAQG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;OAQG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;;;;;;;OASG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;;;;;;;OAQG;IACH,IAAI,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CActC;IAYD;;;;;;;;OAQG;IACH,IAAI,mBAAmB,IAAI,KAAK,CAAC,gBAAgB,CAAC,CAIjD;IACD;;;;;OAKG;IACH,2BAA2B,CAAC,cAAc,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAI5E;;;;;;;OAOG;IACH,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,gBAAgB;IAW7D;;;;;;;;OAQG;IACH,uBAAuB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,GAAG,IAAI;IA2BlF;;;;;;;;;OASG;IACH,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAiB1E;;;;OAIG;IACH,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI;IAUhE;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAOjD;;;;OAIG;IACH,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI;IAQpE;;;;;;OAMG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAOrD;;;;;;;;;OASG;IACH,gBAAgB,CAAC,aAAa,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI;IAK5E;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAY7D;;OAEG;IACH,qBAAqB,IAAI,MAAM;CA4HlC"}

package/dist/types/src/shared/models/field_core.d.ts

@@ -0,0 +1,133 @@
+import { FieldData, FieldType, FieldOptions, FieldConfig } from '../types/field';
+import { ObjectValues } from '../private_utils';
+import { SdkMode } from '../../sdk_mode';
+import { FieldTypeConfig } from '../types/airtable_interface_core';
+import AbstractModel from './abstract_model';
+declare const WatchableFieldKeys: Readonly<{
+    name: "name";
+    type: "type";
+    options: "options";
+    isComputed: "isComputed";
+    description: "description";
+    isFieldSynced: "isFieldSynced";
+}>;
+/**
+ * All the watchable keys in a field.
+ * - `name`
+ * - `type`
+ * - `options`
+ * - `isComputed`
+ * - `description`
+ */
+export type WatchableFieldKey = ObjectValues<typeof WatchableFieldKeys>;
+/** @hidden */
+export declare abstract class FieldCore<SdkModeT extends SdkMode> extends AbstractModel<SdkModeT, FieldData, WatchableFieldKey> {
+    /**
+     * The name of the field. Can be watched.
+     *
+     * @example
+     * ```js
+     * console.log(myField.name);
+     * // => 'Name'
+     * ```
+     */
+    get name(): string;
+    /**
+     * The type of the field. Can be watched.
+     *
+     * @example
+     * ```js
+     * console.log(myField.type);
+     * // => 'singleLineText'
+     * ```
+     */
+    get type(): FieldType;
+    /**
+     * The configuration options of the field. The structure of the field's
+     * options depend on the field's type. `null` if the field has no options.
+     * Can be watched.
+     *
+     * @see {@link FieldType}
+     * @example
+     * ```js
+     * import {FieldType} from '@airtable/blocks/models';
+     *
+     * if (myField.type === FieldType.CURRENCY) {
+     *     console.log(myField.options.symbol);
+     *     // => '$'
+     * }
+     * ```
+     */
+    get options(): FieldOptions | null;
+    _getCachedConfigFromFieldTypeProvider(): FieldTypeConfig;
+    _clearCachedConfig(): void;
+    /**
+     * The type and options of the field to make type narrowing `FieldOptions` easier.
+     *
+     * @see {@link FieldConfig}
+     * @example
+     * const fieldConfig = field.config;
+     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
+     *     return fieldConfig.options.choices;
+     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
+     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
+     *         return fieldConfig.options.result.options.choices;
+     *     }
+     * }
+     * return DEFAULT_CHOICES;
+     */
+    get config(): FieldConfig;
+    /**
+     * `true` if this field is synced, `false` otherwise. A field is
+     * "synced" if it's source is from another airtable base or external data source
+     * like Google Calendar, Jira, etc..
+     *
+     * @hidden
+     */
+    get isFieldSynced(): boolean;
+    /**
+     * `true` if this field is computed, `false` otherwise. A field is
+     * "computed" if it's value is not set by user input (e.g. autoNumber, formula,
+     * etc.). Can be watched
+     *
+     * @example
+     * ```js
+     * console.log(mySingleLineTextField.isComputed);
+     * // => false
+     * console.log(myAutoNumberField.isComputed);
+     * // => true
+     * ```
+     */
+    get isComputed(): boolean;
+    /**
+     * `true` if this field is its parent table's primary field, `false` otherwise.
+     * Should never change because the primary field of a table cannot change.
+     */
+    get isPrimaryField(): boolean;
+    /**
+     * The description of the field, if it has one. Can be watched.
+     *
+     * @example
+     * ```js
+     * console.log(myField.description);
+     * // => 'This is my field'
+     * ```
+     */
+    get description(): string | null;
+    /**
+     * Attempt to parse a given string and return a valid cell value for the field's current config.
+     * Returns `null` if unable to parse the given string.
+     *
+     * @param string The string to parse.
+     * @example
+     * ```js
+     * const inputString = '42';
+     * const cellValue = myNumberField.convertStringToCellValue(inputString);
+     * console.log(cellValue === 42);
+     * // => true
+     * ```
+     */
+    convertStringToCellValue(string: string): unknown;
+}
+export {};
+//# sourceMappingURL=field_core.d.ts.map

package/dist/types/src/shared/models/field_core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field_core.d.ts","sourceRoot":"","sources":["../../../../../src/shared/models/field_core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAyB,YAAY,EAAgB,MAAM,kBAAkB,CAAC;AACrF,OAAO,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAC,eAAe,EAAC,MAAM,kCAAkC,CAAC;AACjE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAI7C,QAAA,MAAM,kBAAkB;;;;;;;EAOtB,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAExE,cAAc;AACd,8BAAsB,SAAS,CAAC,QAAQ,SAAS,OAAO,CAAE,SAAQ,aAAa,CAC3E,QAAQ,EACR,SAAS,EACT,iBAAiB,CACpB;IA0CG;;;;;;;;OAQG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IACD;;;;;;;;OAQG;IACH,IAAI,IAAI,IAAI,SAAS,CAUpB;IACD;;;;;;;;;;;;;;;OAeG;IACH,IAAI,OAAO,IAAI,YAAY,GAAG,IAAI,CAOjC;IAKD,qCAAqC,IAAI,eAAe;IAexD,kBAAkB,IAAI,IAAI;IAI1B;;;;;;;;;;;;;;OAcG;IACH,IAAI,MAAM,IAAI,WAAW,CAKxB;IAED;;;;;;OAMG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,UAAU,IAAI,OAAO,CAGxB;IACD;;;OAGG;IACH,IAAI,cAAc,IAAI,OAAO,CAE5B;IAED;;;;;;;;OAQG;IACH,IAAI,WAAW,IAAI,MAAM,GAAG,IAAI,CAE/B;IACD;;;;;;;;;;;;OAYG;IACH,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;CA8DpD"}

package/dist/types/src/shared/models/mutations_core.d.ts

@@ -0,0 +1,17 @@
+import { SdkMode } from '../../sdk_mode';
+import { ModelChange } from '../types/base_core';
+import { GlobalConfigUpdate } from '../types/global_config';
+import { PermissionCheckResult } from '../types/mutations_core';
+export declare const MUTATIONS_MAX_BATCH_SIZE = 50;
+/** @hidden */
+export declare abstract class MutationsCore<SdkModeT extends SdkMode> {
+    /** @hidden */
+    constructor(sdk: SdkModeT['SdkT'], session: SdkModeT['SessionT'], base: SdkModeT['BaseT'], applyModelChanges: (arg1: ReadonlyArray<ModelChange>) => void, applyGlobalConfigUpdates: (arg1: ReadonlyArray<GlobalConfigUpdate>) => void);
+    /** @hidden */
+    applyMutationAsync(mutation: SdkModeT['MutationT']): Promise<void>;
+    /** @hidden */
+    checkPermissionsForMutation(mutation: SdkModeT['PartialMutationT']): PermissionCheckResult;
+    /** @hidden */
+    private _getAirtableInterfaceAsAirtableInterfaceCore;
+}
+//# sourceMappingURL=mutations_core.d.ts.map

package/dist/types/src/shared/models/mutations_core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations_core.d.ts","sourceRoot":"","sources":["../../../../../src/shared/models/mutations_core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EACH,qBAAqB,EAGxB,MAAM,yBAAyB,CAAC;AAQjC,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAQ3C,cAAc;AACd,8BAAsB,aAAa,CAAC,QAAQ,SAAS,OAAO;IAcxD,cAAc;gBAEV,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,EACrB,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC7B,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,EACvB,iBAAiB,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,KAAK,IAAI,EAC7D,wBAAwB,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,kBAAkB,CAAC,KAAK,IAAI;IAU/E,cAAc;IACR,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAwCxE,cAAc;IACd,2BAA2B,CAAC,QAAQ,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAAG,qBAAqB;IAS1F,cAAc;IACd,OAAO,CAAC,4CAA4C;CAuDvD"}

package/dist/types/src/shared/models/record_core.d.ts

@@ -0,0 +1,60 @@
+import { SdkMode } from '../../sdk_mode';
+import { ObjectValues } from '../private_utils';
+import { FieldId } from '../types/hyper_ids';
+import AbstractModel from './abstract_model';
+export declare const WatchableRecordKeysCore: Readonly<{
+    name: "name";
+    cellValues: "cellValues";
+}>;
+/** @hidden */
+type WatchableRecordKeyCore = ObjectValues<typeof WatchableRecordKeysCore>;
+/** @hidden */
+export declare abstract class RecordCore<SdkModeT extends SdkMode, WatchableKeys extends string = WatchableRecordKeyCore> extends AbstractModel<SdkModeT, SdkModeT['RecordDataT'], WatchableRecordKeyCore | WatchableKeys> {
+    /**
+     * Gets the cell value of the given field for this record.
+     *
+     * @param fieldOrFieldIdOrFieldName The field (or field ID or field name) whose cell value you'd like to get.
+     * @example
+     * ```js
+     * const cellValue = myRecord.getCellValue(mySingleLineTextField);
+     * console.log(cellValue);
+     * // => 'cell value'
+     * ```
+     */
+    getCellValue(fieldOrFieldIdOrFieldName: SdkModeT['FieldT'] | FieldId | string): unknown;
+    /**
+     * 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: SdkModeT['FieldT'] | FieldId | string): string;
+    /**
+     * The primary cell value in this record, formatted as a `string`.
+     *
+     * @example
+     * ```js
+     * console.log(myRecord.name);
+     * // => '42'
+     * ```
+     */
+    get name(): string;
+    /**
+     * The created time of this record.
+     *
+     * @example
+     * ```js
+     * console.log(`
+     *     This record was created at ${myRecord.createdTime.toISOString()}
+     * `);
+     * ```
+     */
+    get createdTime(): Date;
+}
+export {};
+//# sourceMappingURL=record_core.d.ts.map

package/dist/types/src/shared/models/record_core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record_core.d.ts","sourceRoot":"","sources":["../../../../../src/shared/models/record_core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAuD,YAAY,EAAC,MAAM,kBAAkB,CAAC;AAEpG,OAAO,EAAC,OAAO,EAAW,MAAM,oBAAoB,CAAC;AAErD,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAG7C,eAAO,MAAM,uBAAuB;;;EAKlC,CAAC;AAEH,cAAc;AACd,KAAK,sBAAsB,GAAG,YAAY,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,cAAc;AACd,8BAAsB,UAAU,CAC5B,QAAQ,SAAS,OAAO,EACxB,aAAa,SAAS,MAAM,GAAG,sBAAsB,CACvD,SAAQ,aAAa,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,sBAAsB,GAAG,aAAa,CAAC;IAyF9F;;;;;;;;;;OAUG;IACH,YAAY,CAAC,yBAAyB,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO;IAoCvF;;;;;;;;;;OAUG;IACH,oBAAoB,CAAC,yBAAyB,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM;IAiB9F;;;;;;;;OAQG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IACD;;;;;;;;;OASG;IACH,IAAI,WAAW,IAAI,IAAI,CAEtB;CAmBJ"}