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

package/dist/types/src/interface/ui/expand_record.d.ts

@@ -0,0 +1,16 @@
+/** @module @airtable/blocks/interface/ui: expandRecord */ /** */
+import { Record } from '../models/record';
+/**
+ * Expands the given record in the Airtable UI.
+ *
+ * @param record The record to expand.
+ *
+ * @example
+ * ```js
+ * import {expandRecord} from '@airtable/blocks/interface/ui';
+ * expandRecord(record);
+ * ```
+ * @docsPath UI/utils/expandRecord
+ */
+export declare function expandRecord(record: Record): void;
+//# sourceMappingURL=expand_record.d.ts.map

package/dist/types/src/interface/ui/expand_record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expand_record.d.ts","sourceRoot":"","sources":["../../../../../src/interface/ui/expand_record.ts"],"names":[],"mappings":"AAAA,0DAA0D,CAAC,MAAM;AACjE,OAAO,EAAC,MAAM,EAAC,MAAM,kBAAkB,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAQjD"}

package/dist/types/src/interface/ui/initialize_block.d.ts

@@ -0,0 +1,4 @@
+import { InterfaceBlockSdk } from '../sdk';
+export declare function __injectSdkIntoInitializeBlock(_sdk: InterfaceBlockSdk): void;
+export declare function __resetHasBeenInitialized(): void;
+//# sourceMappingURL=initialize_block.d.ts.map

package/dist/types/src/interface/ui/initialize_block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize_block.d.ts","sourceRoot":"","sources":["../../../../../src/interface/ui/initialize_block.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAC,iBAAiB,EAAC,MAAM,QAAQ,CAAC;AAmFzC,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,iBAAiB,QAErE;AAGD,wBAAgB,yBAAyB,SAExC"}

package/dist/types/src/interface/ui/ui.d.ts

@@ -0,0 +1,16 @@
+import '..';
+export { expandRecord } from './expand_record';
+export { initializeBlock } from './initialize_block';
+export { useBase } from './use_base';
+export { useCustomProperties } from './use_custom_properties';
+export { useRecords } from './use_records';
+export { useRunInfo } from './use_run_info';
+export { useSession } from './use_session';
+export { default as useGlobalConfig } from '../../shared/ui/use_global_config';
+export { default as useLoadable } from '../../shared/ui/use_loadable';
+export { default as useSynced } from '../../shared/ui/use_synced';
+export { default as useWatchable } from '../../shared/ui/use_watchable';
+export { default as withHooks } from '../../shared/ui/with_hooks';
+export { default as colors } from '../../shared/colors';
+export { default as colorUtils } from '../../shared/color_utils';
+//# sourceMappingURL=ui.d.ts.map

package/dist/types/src/interface/ui/ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.d.ts","sourceRoot":"","sources":["../../../../../src/interface/ui/ui.ts"],"names":[],"mappings":"AAEA,OAAO,IAAI,CAAC;AAEZ,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAC;AACnC,OAAO,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAC,OAAO,IAAI,MAAM,EAAC,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,0BAA0B,CAAC"}

package/dist/types/src/interface/ui/use_base.d.ts

@@ -0,0 +1,33 @@
+import { Base } from '../models/base';
+/**
+ * A hook for connecting a React component to your base's schema. This returns a {@link Base}
+ * instance and will re-render your component whenever the base's schema changes. That means any
+ * change to your base like tables being added or removed, fields getting renamed, etc. It excludes
+ * any change to the actual records in the base.
+ *
+ * `useBase` should meet most of your needs for working with base schema. If you need more granular
+ * control of when your component updates or want to do anything other than re-render, the lower
+ * level {@link useWatchable} hook might help.
+ *
+ * Returns the current base.
+ *
+ * @example
+ * ```js
+ * import {useBase} from '@airtable/blocks/interface/ui';
+ *
+ * // renders a list of tables and automatically updates
+ * function TableList() {
+ *      const base = useBase();
+ *
+ *      const tables = base.tables.map(table => {
+ *          return <li key={table.id}>{table.name}</li>;
+ *      });
+ *
+ *      return <ul>{tables}</ul>;
+ * }
+ * ```
+ * @docsPath UI/hooks/useBase
+ * @hook
+ */
+export declare function useBase(): Base;
+//# sourceMappingURL=use_base.d.ts.map

package/dist/types/src/interface/ui/use_base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_base.d.ts","sourceRoot":"","sources":["../../../../../src/interface/ui/use_base.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}

package/dist/types/src/interface/ui/use_custom_properties.d.ts

@@ -0,0 +1,45 @@
+import { Table } from '../models/table';
+import { Base } from '../models/base';
+import { Field } from '../models/field';
+/**
+ * TODO document
+ * @hidden
+ */
+type BlockPageElementCustomProperty = {
+    key: string;
+    label: string;
+} & ({
+    type: 'boolean';
+    defaultValue: boolean;
+} | {
+    type: 'string';
+    defaultValue?: string;
+} | {
+    type: 'enum';
+    possibleValues: Array<{
+        value: string;
+        label: string;
+    }>;
+    defaultValue?: string;
+} | {
+    type: 'field';
+    table: Table;
+    /** If not provided, all visible fields in the table will be shown in the dropdown. */
+    possibleValues?: Array<Field>;
+    defaultValue?: Field;
+});
+/**
+ * TODO document. Make sure to describe that getCustomProperties
+ * should be wrapped in useCallback.
+ * @hidden
+ */
+export declare function useCustomProperties(getCustomProperties: (base: Base) => Array<BlockPageElementCustomProperty>): {
+    customPropertyValueByKey: {
+        [key: string]: unknown;
+    };
+    errorState: {
+        error: Error;
+    } | null;
+};
+export {};
+//# sourceMappingURL=use_custom_properties.d.ts.map

package/dist/types/src/interface/ui/use_custom_properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_custom_properties.d.ts","sourceRoot":"","sources":["../../../../../src/interface/ui/use_custom_properties.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAEtC,OAAO,EAAC,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAEpC,OAAO,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAQtC;;;GAGG;AACH,KAAK,8BAA8B,GAAG;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,GAAG,CAC/D;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAC,GACxC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAC,GACvC;IACI,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IACtD,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB,GACD;IACI,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,sFAAsF;IACtF,cAAc,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAC9B,YAAY,CAAC,EAAE,KAAK,CAAC;CACxB,CACN,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAC/B,mBAAmB,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,KAAK,CAAC,8BAA8B,CAAC,GAC3E;IAAC,wBAAwB,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAC,CAAC;IAAC,UAAU,EAAE;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,GAAG,IAAI,CAAA;CAAC,CAkDzF"}

package/dist/types/src/interface/ui/use_records.d.ts

@@ -0,0 +1,40 @@
+import { Record } from '../models/record';
+import { Table } from '../models/table';
+/**
+ * A hook for working with all of the records (including cell values) in a
+ * particular table. Automatically handles loading data and updating
+ * your component when the underlying data changes.
+ *
+ * This hook re-renders when data concerning the records changes (specifically, when cell values
+ * change and when records are added or removed).
+ *
+ * Returns a list of records.
+ *
+ * @param table The {@link Table} you want the records from.
+ *
+ * @example
+ * ```js
+ *  import {useBase, useRecords} from '@airtable/blocks/interface/ui';
+ *
+ *  function RecordList() {
+ *      const base = useBase();
+ *      const table = base.tables[0];
+ *
+ *      // grab all the records from that table
+ *      const records = useRecords(table);
+ *
+ *      // render a list of records:
+ *      return (
+ *          <ul>
+ *              {records.map(record => {
+ *                  return <li key={record.id}>{record.name}</li>;
+ *              })}
+ *          </ul>
+ *      );
+ *  }
+ * ```
+ * @docsPath UI/hooks/useRecords
+ * @hook
+ */
+export declare function useRecords(table: Table): Array<Record>;
+//# sourceMappingURL=use_records.d.ts.map

package/dist/types/src/interface/ui/use_records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_records.d.ts","sourceRoot":"","sources":["../../../../../src/interface/ui/use_records.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAC,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,CAMtD"}

package/dist/types/src/interface/ui/use_run_info.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A hook for getting information about the current run context. This can be
+ * useful if you'd like to display some configuration options when the page
+ * element is in edit mode.
+ *
+ * `useRunInfo`
+ *
+ * @example
+ * ```js
+ * import {useRunInfo} from '@airtable/blocks/interface/ui';
+ *
+ * // renders a list of tables and automatically updates
+ * function MyApp() {
+ *      const runInfo = useRunInfo();
+ *      return (
+ *          <div>
+ *              <p>Is development mode: {runInfo.isDevelopmentMode ? 'Yes' : 'No'}</p>
+ *              <p>Is page element in edit mode: {runInfo.isPageElementInEditMode ? 'Yes' : 'No'}</p>
+ *          </div>
+ *      );
+ * }
+ * ```
+ * @docsPath UI/hooks/useRunInfo
+ * @hook
+ */
+export declare function useRunInfo(): {
+    isDevelopmentMode: boolean;
+    isPageElementInEditMode: boolean;
+};
+//# sourceMappingURL=use_run_info.d.ts.map

package/dist/types/src/interface/ui/use_run_info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_run_info.d.ts","sourceRoot":"","sources":["../../../../../src/interface/ui/use_run_info.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,IAAI;IAAC,iBAAiB,EAAE,OAAO,CAAC;IAAC,uBAAuB,EAAE,OAAO,CAAA;CAAC,CAO3F"}

package/dist/types/src/interface/ui/use_session.d.ts

@@ -0,0 +1,30 @@
+import { Session } from '../models/session';
+/**
+ * A hook for connecting a React component to the current session. This returns a {@link Session}
+ * instance and will re-render your component whenever the session changes (e.g. when the current user's
+ * permissions change or when the current user's name changes).
+ *
+ * `useSession` should meet most of your needs for working with {@link Session}. If you need more granular
+ * control of when your component updates or want to do anything other than re-render, the lower
+ * level {@link useWatchable} hook might help.
+ *
+ * @example
+ * ```js
+ * import {useSession} from '@airtable/blocks/interface/ui';
+ *
+ * // Says hello to the current user and updates in realtime if the current user's
+ * // name or profile pic changes.
+ * function CurrentUserGreeter() {
+ *     const session = useSession();
+ *     return (
+ *         <React.Fragment>
+ *             Hello {session.currentUser?.name ?? 'stranger'}!
+ *         </React.Fragment>
+ *     );
+ * }
+ * ```
+ * @docsPath UI/hooks/useSession
+ * @hook
+ */
+export declare function useSession(): Session;
+//# sourceMappingURL=use_session.d.ts.map

package/dist/types/src/interface/ui/use_session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_session.d.ts","sourceRoot":"","sources":["../../../../../src/interface/ui/use_session.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAC,MAAM,mBAAmB,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAEpC"}

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

@@ -0,0 +1,65 @@
+import BaseBlockSdk from './base/sdk';
+import { BaseData as BaseDataForBaseSdkMode } from './base/types/base';
+import { TableData as TableDataForBaseSdkMode } from './base/types/table';
+import { RecordData as RecordDataForBaseSdkMode } from './base/types/record';
+import { BaseData as BaseDataForInterfaceSdkMode } from './interface/types/base';
+import { TableData as TableDataForInterfaceSdkMode } from './interface/types/table';
+import { RecordData as RecordDataForInterfaceSdkMode } from './interface/types/record';
+import BaseForBaseSdkMode from './base/models/base';
+import { Base as BaseForInterfaceSdkMode } from './interface/models/base';
+import FieldForBaseSdkMode from './base/models/field';
+import { InterfaceBlockSdk } from './interface/sdk';
+import TableForBaseSdkMode from './base/models/table';
+import { Table as TableForInterfaceSdkMode } from './interface/models/table';
+import { Field as FieldForInterfaceSdkMode } from './interface/models/field';
+import { Record as RecordForInterfaceSdkMode } from './interface/models/record';
+import RecordForBaseSdkMode from './base/models/record';
+import { AirtableInterface as AirtableInterfaceForBaseSdkMode, BlockRunContext as BlockRunContextForBaseSdkMode, SdkInitData as SdkInitDataForBaseSdkMode } from './base/types/airtable_interface';
+import { AirtableInterface as AirtableInterfaceForInterfaceSdkMode, BlockRunContext as BlockRunContextForInterfaceSdkMode, SdkInitData as SdkInitDataForInterfaceSdkMode } from './interface/types/airtable_interface';
+import MutationsForBaseSdkMode from './base/models/mutations';
+import { Mutations as MutationsForInterfaceSdkMode } from './interface/models/mutations';
+import { Mutation as MutationForBaseSdkMode, PartialMutation as PartialMutationForBaseSdkMode } from './base/types/mutations';
+import { Mutation as MutationForInterfaceSdkMode, PartialMutation as PartialMutationForInterfaceSdkMode } from './interface/types/mutations';
+import SesssionForBaseSdkMode from './base/models/session';
+import { Session as SessionForInterfaceSdkMode } from './interface/models/session';
+/** @hidden */
+export interface BaseSdkMode {
+    mode: 'base';
+    runContextT: BlockRunContextForBaseSdkMode;
+    SdkT: BaseBlockSdk;
+    SdkInitDataT: SdkInitDataForBaseSdkMode;
+    AirtableInterfaceT: AirtableInterfaceForBaseSdkMode;
+    SessionT: SesssionForBaseSdkMode;
+    MutationsModelT: MutationsForBaseSdkMode;
+    MutationT: MutationForBaseSdkMode;
+    PartialMutationT: PartialMutationForBaseSdkMode;
+    BaseDataT: BaseDataForBaseSdkMode;
+    TableDataT: TableDataForBaseSdkMode;
+    RecordDataT: RecordDataForBaseSdkMode;
+    BaseT: BaseForBaseSdkMode;
+    TableT: TableForBaseSdkMode;
+    FieldT: FieldForBaseSdkMode;
+    RecordT: RecordForBaseSdkMode;
+}
+/** @hidden */
+export interface InterfaceSdkMode {
+    mode: 'interface';
+    runContextT: BlockRunContextForInterfaceSdkMode;
+    SdkT: InterfaceBlockSdk;
+    SdkInitDataT: SdkInitDataForInterfaceSdkMode;
+    AirtableInterfaceT: AirtableInterfaceForInterfaceSdkMode;
+    SessionT: SessionForInterfaceSdkMode;
+    MutationsModelT: MutationsForInterfaceSdkMode;
+    MutationT: MutationForInterfaceSdkMode;
+    PartialMutationT: PartialMutationForInterfaceSdkMode;
+    BaseDataT: BaseDataForInterfaceSdkMode;
+    TableDataT: TableDataForInterfaceSdkMode;
+    RecordDataT: RecordDataForInterfaceSdkMode;
+    BaseT: BaseForInterfaceSdkMode;
+    TableT: TableForInterfaceSdkMode;
+    FieldT: FieldForInterfaceSdkMode;
+    RecordT: RecordForInterfaceSdkMode;
+}
+/** @hidden */
+export type SdkMode = BaseSdkMode | InterfaceSdkMode;
+//# sourceMappingURL=sdk_mode.d.ts.map

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

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

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

@@ -0,0 +1,72 @@
+import { Color } from './colors';
+/** A red/green/blue color object. Each property is a number from 0 to 255. */
+interface RGB {
+    /** The red component. */
+    r: number;
+    /** The green component. */
+    g: number;
+    /** The blue component. */
+    b: number;
+}
+/**
+ * Utilities for working with {@link Color} names from the {@link colors} enum.
+ *
+ * @docsPath UI/utils/colorUtils
+ */
+interface ColorUtils {
+    /**
+     * Given a {@link Color}, return the hex color value for that color, or null if the value isn't a {@link Color}
+     *
+     * @param colorString
+     * @example
+     * ```js
+     * import {colorUtils, colors} from '@airtable/blocks/ui';
+     *
+     * colorUtils.getHexForColor(colors.RED);
+     * // => '#ef3061'
+     *
+     * colorUtils.getHexForColor('uncomfortable beige');
+     * // => null
+     * ```
+     */
+    getHexForColor(colorString: Color): string;
+    /** */
+    getHexForColor(colorString: string): null | string;
+    /**
+     * Given a {@link Color}, return an {@link RGB} object representing it, or null if the value isn't a {@link Color}
+     *
+     * @param colorString
+     * @example
+     * ```js
+     * import {colorUtils, colors} from '@airtable/blocks/ui';
+     *
+     * colorUtils.getRgbForColor(colors.PURPLE_DARK_1);
+     * // => {r: 107, g: 28, b: 176}
+     *
+     * colorUtils.getRgbForColor('disgruntled pink');
+     * // => null
+     * ```
+     */
+    getRgbForColor(colorString: Color): RGB;
+    /** */
+    getRgbForColor(colorString: string): RGB | null;
+    /**
+     * Given a {@link Color}, returns true or false to indicate whether that color should have light text on top of it when used as a background color.
+     *
+     * @param colorString
+     * @example
+     * ```js
+     * import {colorUtils, colors} from '@airtable/blocks/ui';
+     *
+     * colorUtils.shouldUseLightTextOnColor(colors.PINK_LIGHT_1);
+     * // => false
+     *
+     * colorUtils.shouldUseLightTextOnColor(colors.PINK_DARK_1);
+     * // => true
+     * ```
+     */
+    shouldUseLightTextOnColor(colorString: string): boolean;
+}
+declare const colorUtils: ColorUtils;
+export default colorUtils;
+//# sourceMappingURL=color_utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"color_utils.d.ts","sourceRoot":"","sources":["../../../../src/shared/color_utils.ts"],"names":[],"mappings":"AAEA,OAAe,EAAC,KAAK,EAAmB,MAAM,UAAU,CAAC;AAEzD,8EAA8E;AAC9E,UAAU,GAAG;IACT,yBAAyB;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,0BAA0B;IAC1B,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,UAAU,UAAU;IAChB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,WAAW,EAAE,KAAK,GAAG,MAAM,CAAC;IAC3C,MAAM;IACN,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;IAEnD;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,WAAW,EAAE,KAAK,GAAG,GAAG,CAAC;IACxC,MAAM;IACN,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC;IAEhD;;;;;;;;;;;;;;OAcG;IACH,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3D;AAED,QAAA,MAAM,UAAU,EAAE,UAmCjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

@@ -0,0 +1,180 @@
+/** @module @airtable/blocks/ui: colors */ /** */
+import { ObjectValues } from './private_utils';
+/**
+ * Airtable color names.
+ *
+ * To get the corresponding RGB or HEX values, use
+ * {@link getRgbForColor} or {@link getHexForColor}.
+ *
+ * You can also pass these values into the color props for components:
+ *
+ * @example
+ * ```js
+ * import {Box, colors} from '@airtable/blocks/ui';
+ *
+ * <Box backgroundColor={colors.BLUE} />
+ * ```
+ *
+ * @docsPath UI/utils/colors
+ */
+declare const Colors: {
+    /** @docsPath UI/utils/Colors */
+    BLUE_BRIGHT: "blueBright";
+    /** @docsPath UI/utils/Colors */
+    BLUE_DARK_1: "blueDark1";
+    /** @docsPath UI/utils/Colors */
+    BLUE_LIGHT_1: "blueLight1";
+    /** @docsPath UI/utils/Colors */
+    BLUE_LIGHT_2: "blueLight2";
+    /** @docsPath UI/utils/Colors */
+    BLUE: "blue";
+    /** @docsPath UI/utils/Colors */
+    CYAN_BRIGHT: "cyanBright";
+    /** @docsPath UI/utils/Colors */
+    CYAN_DARK_1: "cyanDark1";
+    /** @docsPath UI/utils/Colors */
+    CYAN_LIGHT_1: "cyanLight1";
+    /** @docsPath UI/utils/Colors */
+    CYAN_LIGHT_2: "cyanLight2";
+    /** @docsPath UI/utils/Colors */
+    CYAN: "cyan";
+    /** @docsPath UI/utils/Colors */
+    GRAY_BRIGHT: "grayBright";
+    /** @docsPath UI/utils/Colors */
+    GRAY_DARK_1: "grayDark1";
+    /** @docsPath UI/utils/Colors */
+    GRAY_LIGHT_1: "grayLight1";
+    /** @docsPath UI/utils/Colors */
+    GRAY_LIGHT_2: "grayLight2";
+    /** @docsPath UI/utils/Colors */
+    GRAY: "gray";
+    /** @docsPath UI/utils/Colors */
+    GREEN_BRIGHT: "greenBright";
+    /** @docsPath UI/utils/Colors */
+    GREEN_DARK_1: "greenDark1";
+    /** @docsPath UI/utils/Colors */
+    GREEN_LIGHT_1: "greenLight1";
+    /** @docsPath UI/utils/Colors */
+    GREEN_LIGHT_2: "greenLight2";
+    /** @docsPath UI/utils/Colors */
+    GREEN: "green";
+    /** @docsPath UI/utils/Colors */
+    ORANGE_BRIGHT: "orangeBright";
+    /** @docsPath UI/utils/Colors */
+    ORANGE_DARK_1: "orangeDark1";
+    /** @docsPath UI/utils/Colors */
+    ORANGE_LIGHT_1: "orangeLight1";
+    /** @docsPath UI/utils/Colors */
+    ORANGE_LIGHT_2: "orangeLight2";
+    /** @docsPath UI/utils/Colors */
+    ORANGE: "orange";
+    /** @docsPath UI/utils/Colors */
+    PINK_BRIGHT: "pinkBright";
+    /** @docsPath UI/utils/Colors */
+    PINK_DARK_1: "pinkDark1";
+    /** @docsPath UI/utils/Colors */
+    PINK_LIGHT_1: "pinkLight1";
+    /** @docsPath UI/utils/Colors */
+    PINK_LIGHT_2: "pinkLight2";
+    /** @docsPath UI/utils/Colors */
+    PINK: "pink";
+    /** @docsPath UI/utils/Colors */
+    PURPLE_BRIGHT: "purpleBright";
+    /** @docsPath UI/utils/Colors */
+    PURPLE_DARK_1: "purpleDark1";
+    /** @docsPath UI/utils/Colors */
+    PURPLE_LIGHT_1: "purpleLight1";
+    /** @docsPath UI/utils/Colors */
+    PURPLE_LIGHT_2: "purpleLight2";
+    /** @docsPath UI/utils/Colors */
+    PURPLE: "purple";
+    /** @docsPath UI/utils/Colors */
+    RED_BRIGHT: "redBright";
+    /** @docsPath UI/utils/Colors */
+    RED_DARK_1: "redDark1";
+    /** @docsPath UI/utils/Colors */
+    RED_LIGHT_1: "redLight1";
+    /** @docsPath UI/utils/Colors */
+    RED_LIGHT_2: "redLight2";
+    /** @docsPath UI/utils/Colors */
+    RED: "red";
+    /** @docsPath UI/utils/Colors */
+    TEAL_BRIGHT: "tealBright";
+    /** @docsPath UI/utils/Colors */
+    TEAL_DARK_1: "tealDark1";
+    /** @docsPath UI/utils/Colors */
+    TEAL_LIGHT_1: "tealLight1";
+    /** @docsPath UI/utils/Colors */
+    TEAL_LIGHT_2: "tealLight2";
+    /** @docsPath UI/utils/Colors */
+    TEAL: "teal";
+    /** @docsPath UI/utils/Colors */
+    YELLOW_BRIGHT: "yellowBright";
+    /** @docsPath UI/utils/Colors */
+    YELLOW_DARK_1: "yellowDark1";
+    /** @docsPath UI/utils/Colors */
+    YELLOW_LIGHT_1: "yellowLight1";
+    /** @docsPath UI/utils/Colors */
+    YELLOW_LIGHT_2: "yellowLight2";
+    /** @docsPath UI/utils/Colors */
+    YELLOW: "yellow";
+};
+export default Colors;
+/**
+ * A color name from the list of {@link Colors}.
+ */
+export type Color = ObjectValues<typeof Colors>;
+/** @hidden */
+export declare const rgbTuplesByColor: {
+    blueBright: number[];
+    blueDark1: number[];
+    blueLight1: number[];
+    blueLight2: number[];
+    blue: number[];
+    cyanBright: number[];
+    cyanDark1: number[];
+    cyanLight1: number[];
+    cyanLight2: number[];
+    cyan: number[];
+    grayBright: number[];
+    grayDark1: number[];
+    grayLight1: number[];
+    grayLight2: number[];
+    gray: number[];
+    greenBright: number[];
+    greenDark1: number[];
+    greenLight1: number[];
+    greenLight2: number[];
+    green: number[];
+    orangeBright: number[];
+    orangeDark1: number[];
+    orangeLight1: number[];
+    orangeLight2: number[];
+    orange: number[];
+    pinkBright: number[];
+    pinkDark1: number[];
+    pinkLight1: number[];
+    pinkLight2: number[];
+    pink: number[];
+    purpleBright: number[];
+    purpleDark1: number[];
+    purpleLight1: number[];
+    purpleLight2: number[];
+    purple: number[];
+    redBright: number[];
+    redDark1: number[];
+    redLight1: number[];
+    redLight2: number[];
+    red: number[];
+    tealBright: number[];
+    tealDark1: number[];
+    tealLight1: number[];
+    tealLight2: number[];
+    teal: number[];
+    yellowBright: number[];
+    yellowDark1: number[];
+    yellowLight1: number[];
+    yellowLight2: number[];
+    yellow: number[];
+};
+//# sourceMappingURL=colors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../../../src/shared/colors.ts"],"names":[],"mappings":"AAAA,0CAA0C,CAAC,MAAM;AACjD,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC7C;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,MAAM;IACR,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAGhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;IAEhC,gCAAgC;;CAEnC,CAAC;AAEF,eAAe,MAAM,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,MAAM,CAAC,CAAC;AAEhD,cAAc;AACd,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4D5B,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * @hidden
+ */
+export declare function spawnError(errorMessageFormat: string, ...errorMessageArgs: ReadonlyArray<unknown>): Error;
+/**
+ * Logs an error to Sentry
+ *
+ * @hidden
+ */
+export declare function logErrorToSentry(errorMessage: string, metadata?: {
+    [key: string]: unknown;
+}): void;
+/**
+ * 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/shared/error_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error_utils.d.ts","sourceRoot":"","sources":["../../../../src/shared/error_utils.ts"],"names":[],"mappings":"AAsCA;;GAEG;AACH,wBAAgB,UAAU,CACtB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,gBAAgB,EAAE,aAAa,CAAC,OAAO,CAAC,SAO9C;AAGD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,QAazF;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/shared/event_tracker.d.ts

@@ -0,0 +1,17 @@
+/** @hidden */
+export declare function trackEvent(eventSchemaName: string, eventData?: {
+    [key: string]: unknown;
+}): void;
+/**
+ * Used for logging blockInstallation.performRecordAction event
+ * Mirrored from hyperbase block_installation_record_action_status.tsx
+ *
+ * @hidden
+ * */
+export declare enum RecordActionStatus {
+    SUCCESS = "SUCCESS",
+    IGNORED = "IGNORED",
+    SETTINGS_INVALID = "SETTINGS_INVALID",
+    TABLE_MISMATCH = "TABLE_MISMATCH"
+}
+//# sourceMappingURL=event_tracker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event_tracker.d.ts","sourceRoot":"","sources":["../../../../src/shared/event_tracker.ts"],"names":[],"mappings":"AACA,cAAc;AACd,wBAAgB,UAAU,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,GAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAM,QAE3F;AAED;;;;;KAKK;AACL,oBAAY,kBAAkB;IAE1B,OAAO,YAAY;IAKnB,OAAO,YAAY;IAGnB,gBAAgB,qBAAqB;IAGrC,cAAc,mBAAmB;CACpC"}