ember-headless-table 0.0.0 → 1.0.0

package/dist/-private/interfaces/plugins.d.ts

@@ -0,0 +1,314 @@
+/**
+ * NOTE:
+ *  Empty, EmptyObject, and GetOrElse are copied from @glimmer/component
+ */
+import { Constructor } from "../private-types";
+import { Column, Row, Table } from "../../index";
+import { Destructor } from "./index";
+type DataTypeOf<T> = T extends Table<infer DataType> ? DataType : T;
+/**
+ * @private utility class
+ *
+ * This class exists because there isn't a way to, in TS,
+ * get access to static properties from an instance type
+ */
+type PluginClass<PluginType> = PluginType & {
+    new: (...args: unknown[]) => PluginType;
+    features?: string[];
+    requires?: string[];
+};
+type PluginSubclassInstance<PluginType> = PluginType & {
+    constructor: PluginClass<PluginType>;
+};
+/**
+ * @public
+ *
+ * The data passed to a plugin's column APIs
+ */
+interface ColumnApi<T extends Table = Table> {
+    column: Column<DataTypeOf<T>>;
+    table: T;
+}
+/**
+ * @public
+ *
+ * The data passed to a plugin's row APIs
+ */
+interface RowApi<T extends Table = Table> {
+    row: Row<DataTypeOf<T>>;
+    table: T;
+}
+/**
+ * @private utility type
+ *
+ * Note that this exists here, and the Plugin interface exists in general
+ * because we need to derive types in a static context on BasePlugin,
+ * and the source of types need to exist somewhere other than BasePlugin,
+ * so that:
+ * - inference will work
+ * - we avoid infinite recursive type definitions
+ */
+type SignatureFrom<Klass extends Plugin<any>> = Klass extends Plugin<infer Signature> ? Signature : never;
+/**
+ * @public
+ *
+ * Table plugins are stateless objects that optionally provide hooks based on what
+ * the plugin wishes to modify.
+ *
+ * If state is desired, Metadata classes may be provided to manage that state.
+ * As a convenience, when the meta classes are instantiated, they'll be given the same
+ * `owner` as everything else in the application, so service injection will be available
+ * within the meta class instances.
+ *
+ * A plugin can provide components that the consuming Table can opt in to rendering.
+ * (though, often these components will be required to be rendered for the plugin to work)
+ *
+ * a `Plugin` has one type argument:
+ * - Signature - which can provide optional information about the Meta/State and Options the plugin can take
+ *
+ *   Any particular plugin instantiation will have at most 1 instance of their TableMeta
+ *   and `n` instances of their ColumnMeta, where `n` is at most the number of columns.
+ */
+interface Plugin<Signature = unknown> {
+    /**
+     * Unique name for the plugin.
+     * - only one plugin of the same name is allowed
+     * - the name is used for storing preferences / serializable information
+     */
+    name: string;
+    /**
+     * Some plugins may require that other plugins be present.
+     * and because plugins can be interchangeable, the features implemented
+     * by those plugins must be declared via strings so that we can have
+     * a semi-stable reference that isn't tied to object equality or anything like that.
+     *
+     * This enables, for example, the StickyColumns plugin to work with different implementations of the ColumnResizing plugin (such as one
+     * might have between an aria-grid and a data table)
+     */
+    features?: string[];
+    /**
+     * List of features to lookup "somewhere" in the list of plugins
+     * order does not matter.
+     */
+    requires?: string[];
+    /**
+     * Optional state that this plugin may or may not choose to use
+     *
+     * columns will each have an instance of meta.column.
+     * the table will have only one instance of meta.table.
+     */
+    meta?: {
+        /**
+         * @public
+         *
+         * Specifies the class definition to use for storing column-related state / behavior for this plugin
+         */
+        column?: Constructor<ColumnMetaFor<Signature>>;
+        /**
+         * @public
+         *
+         * Specifies the class definition to use for storing table-related state / behavior for this plugin
+         */
+        table?: Constructor<TableMetaFor<Signature>>;
+        /**
+         * @public
+         *
+         * Specifies the class definition to use for storing the row-related state / behavior for this plugin
+         */
+        row?: Constructor<RowMetaFor<Signature>>;
+    };
+    /**
+     * @public
+     * @kind Column property
+     *
+     * Specify a modifier setup/teardown function to attach to each of the header cells
+     *
+     * Can be used to add / remove attributes, event listeners, etc
+     */
+    headerCellModifier?: (element: HTMLElement, ...args: [ColumnApi<Table<any>>]) => void | Destructor;
+    /**
+     * @public
+     * @kind Row property
+     *
+     * Specify a modifier setup/teardown function to attach to each of the rows
+     *
+     * Can be used to add / remove attributes, event listeners, etc
+     */
+    rowModifier?: (element: HTMLElement, ...args: [RowApi<Table<any>>]) => void | Destructor;
+    /**
+     * @public
+     * @kind Table hook
+     *
+     * Specify a modifier setup/teardown function to attach to the table's containing element
+     */
+    containerModifier?: (element: HTMLElement, ...args: [Table<any>]) => void | Destructor;
+    /**
+     * @public
+     * @kind Table Hook
+     *
+     * If the plugin has state, this should be used to reset that state
+     */
+    reset?: () => void;
+    /**
+     * @public
+     * @kind Table Hook
+     *
+     * A plugin may change the columns order, visibility, etc.
+     * By implementing this getter, this plugin's
+     * `columns` property will be used by other plugins via
+     * the `columns.for(table, RequestingPlugin)` api.
+     *
+     * For the end-consumer, they may choose to do
+     * `columns.for(table)`, which will aggregate all column modifications
+     * from all plugins.
+     *
+     * As always, `table.columns` is the way to get the unmodified list of columns.
+     */
+    columns?: Column<any>[];
+}
+/**
+ * @private utility type
+ */
+type GetOrElse<Obj, K, Fallback> = K extends keyof Obj ? Obj[K] : Fallback;
+/**
+ * @public
+ *
+ * utility class to help with autocompletion / documentation
+ * in the editor while while defining the signature of custom plugins.
+ */
+interface PluginSignature {
+    /**
+     * Meta is how plugins can manage per-{table,columns,rows}
+     * state, event listeners, and general public API
+     */
+    Meta?: {
+        /**
+         * If a plugin has Table meta/state,
+         * the shape of that state can be described here
+         */
+        Table?: unknown;
+        /**
+         * If a plugin has Column meta/state,
+         * the shape of that state can be described here
+         */
+        Column?: unknown;
+        /**
+         * If a plugin has Row meta/state,
+         * the shape of that state can be described here
+         */
+        Row?: unknown;
+    };
+    Options?: {
+        /**
+         * If a plugin has options configurable for the whole table,
+         * those can be specified here.
+         *
+         * These are passed via the the `withOptions` API
+         *
+         * ```js
+         * headlessTable(this?, {
+         *   // ...
+         *   plugins: [
+         *     MyPlugin.withOptions(() => {
+         *       // the return value here is this is Signature['Options']['Plugin']
+         *       return {};
+         *     })
+         *   ]
+         * })
+         * ```
+         */
+        Plugin?: unknown;
+        /**
+         * If a plugin has options configurable per column,
+         * those can be specified here
+         *
+         * These are passed via the the `forColumn` API
+         *
+         * ```js
+         * headlessTable(this?, {
+         *   // ...
+         *   columns: () => [
+         *     MyPlugin.forColumn(() => {
+         *       // the return value here is this is Signature['Options']['Column']
+         *       return {};
+         *     })
+         *   ]
+         * })
+         * ```
+         */
+        Column?: unknown;
+    };
+}
+/**
+ * @private default type
+ *
+ * Describes the shape of all the dynamic parts of a Plugin.
+ *
+ * There are no row options, because rows are not statically configurable.
+ */
+interface DefaultPluginSignature {
+    Meta: {
+        Row: unknown;
+        Column: unknown;
+        Table: unknown;
+    };
+    Options: {
+        Plugin: unknown;
+        Column: unknown;
+    };
+}
+/**
+ * @private utility type
+ */
+type TableMetaFor<Signature> = Signature extends {
+    Meta: {
+        Table: unknown;
+    };
+} ? GetOrElse<Signature['Meta'], 'Table', never> : never;
+/**
+ * @private utility type
+ */
+type ColumnMetaFor<Signature> = Signature extends {
+    Meta: {
+        Column: unknown;
+    };
+} ? GetOrElse<Signature['Meta'], 'Column', never> : never;
+/**
+ * @private utility type
+ */
+type RowMetaFor<Signature> = Signature extends {
+    Meta: {
+        Row: unknown;
+    };
+} ? GetOrElse<Signature['Meta'], 'Row', never> : never;
+/**
+ * @private utility type
+ */
+type OptionsFor<Signature> = Signature extends {
+    Options: object;
+} ? GetOrElse<Signature['Options'], 'Plugin', EmptyObject> : EmptyObject;
+/**
+ * @private utility type
+ */
+type ColumnOptionsFor<Signature> = Signature extends {
+    Options: object;
+} ? GetOrElse<Signature['Options'], 'Column', EmptyObject> : EmptyObject;
+declare const Empty: unique symbol;
+/**
+ * This provides us a way to have a "fallback" which represents an empty object,
+ * without the downsides of how TS treats `{}`. Specifically: this will
+ * correctly leverage "excess property checking" so that, given a component
+ * which has no named args, if someone invokes it with any named args, they will
+ * get a type error.
+ *
+ * @internal This is exported so declaration emit works (if it were not emitted,
+ *   declarations which fall back to it would not work). It is *not* intended for
+ *   public usage, and the specific mechanics it uses may change at any time.
+ *   The location of this export *is* part of the public API, because moving it
+ *   will break existing declarations, but is not legal for end users to import
+ *   themselves, so ***DO NOT RELY ON IT***.
+ */
+type EmptyObject = {
+    [Empty]?: true;
+};
+export { PluginClass, PluginSubclassInstance, ColumnApi, RowApi, SignatureFrom, Plugin, PluginSignature, DefaultPluginSignature, TableMetaFor, ColumnMetaFor, RowMetaFor, OptionsFor, ColumnOptionsFor, EmptyObject };

package/dist/-private/interfaces/plugins.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=plugins.js.map

package/dist/-private/interfaces/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/-private/interfaces/preferences.d.ts

@@ -0,0 +1,74 @@
+interface PreferencesAdapter {
+    persist?(key: string, data?: TablePreferencesData): void;
+    restore?(key: string): TablePreferencesData | undefined;
+}
+/**
+ * The root preferences object
+ *
+ * This object is serialized to JSON for your `PreferencesAdapter` to consume.
+ * This could allow for saving the data off to an API or local storage.
+ */
+interface TablePreferencesData {
+    /**
+     * Every plugin has its own namespace for preferences storage.
+     *
+     * This is so that plugins can not worry about colliding with other plugins'
+     * keys within the preferences. For example: multiple plugins may use "enabled"
+     */
+    plugins?: Registry;
+}
+/**
+ * A type registry for ember-headless-table Plugin's Preferences.
+ * Meant to be declaration-merged so string lookups resolve to the correct type.
+ *
+ * And so that accessing the full "preferences" object from "persist"
+ * and within "restore" can be fully typed.
+ * This also helps out with Glint, as `unknown` types are not allowed to be rendered
+ *
+ * As a plugin author, to help define what your preferences shape is, you may
+ * ```ts
+ * import { type PluginPreferences } from 'ember-headless-table/plugins';
+ *
+ * interface SortingPreferences extends PluginPreferences {
+ *
+ * }
+ *
+ * declare module 'ember-headless-table/plugins' {
+ *   interface Registry {
+ *     // The key *must* match the same of the class
+ *     Sorting: SortingPreferences;
+ *   }
+ * }
+ * ```
+ */
+interface Registry {
+}
+type PluginPreferenceFor<PluginName> = PluginName extends keyof Registry ? Registry[PluginName] & PluginPreferences : PluginPreferences;
+type PreferencesTableKey<PluginName> = keyof PluginPreferenceFor<PluginName>['table'];
+type PreferencesTableValues<PluginName> = PluginPreferenceFor<PluginName>['table'][PreferencesTableKey<PluginName>];
+type PreferencesColumnValues<PluginName> = PluginPreferenceFor<PluginName>['columns'][keyof PluginPreferenceFor<PluginName>['columns']];
+/**
+ * Preferences for a column may store a map of key-value pairs
+ * for each of
+ * - the table
+ * - each column
+ */
+interface PluginPreferences {
+    /**
+     * A plugin's preferences for the table can be any
+     * string -> stringifyable mapping
+     */
+    table: Record<string, unknown>;
+    /**
+     * preferences for a plugin's columns-of-interest are mapped out by
+     * the column's key
+     */
+    columns: {
+        /**
+         * For any particular column that a plugin may desire to store preferences on,
+         * the data can be any string -> stringifyable mapping
+         */
+        [columnKey: string]: Record<string, unknown>;
+    };
+}
+export { PreferencesAdapter, TablePreferencesData, Registry, PluginPreferenceFor, PreferencesTableKey, PreferencesTableValues, PreferencesColumnValues, PluginPreferences };

package/dist/-private/interfaces/preferences.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=preferences.js.map

package/dist/-private/interfaces/preferences.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preferences.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/-private/interfaces/selection.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Types minimally replicated here so we don't need to depend on the package that
+ * actually defines these types
+ *
+ * This also enables a much broader variety of implementations as these interfaces
+ * describe only what's needed by the headless table, and not the concrete implementation
+ */
+type CurrentState<T> = {
+    state: 'ALL' | 'NONE';
+} | {
+    state: 'SOME';
+    includeItems: T[];
+} | {
+    state: 'ALL_EXCEPT';
+    excludeItems: T[];
+};
+/**
+ * A table can provide a `Selection` object that matches this API
+ */
+interface Selection<Item = object> {
+    get selected(): Item[];
+    get currentState(): CurrentState<Item>;
+    get isIndeterminate(): boolean;
+    get isAllSelected(): boolean;
+    get numSelected(): number;
+    get numTotal(): number;
+    isSelected(item: Item): boolean;
+    selectItem(item: Item): void;
+    toggleItem(item: Item): void;
+    toggleAll(): void;
+    selectAll(): void;
+    deselectAll(): void;
+    deselectItem(item: Item): void;
+}
+export { Selection };

package/dist/-private/interfaces/selection.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=selection.js.map

package/dist/-private/interfaces/selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/-private/interfaces/table.d.ts

@@ -0,0 +1,109 @@
+import { Plugins } from "../../plugins/-private/utils";
+import { ColumnConfig } from "./column";
+import { Pagination } from "./pagination";
+import { PreferencesAdapter } from "./preferences";
+import { Selection } from "./selection";
+interface TableMeta {
+    totalRowCount?: number;
+    totalRowsSelectedCount?: number;
+}
+interface TableConfig<DataType> {
+    /**
+     * Configuration describing how the table will crawl through `data`
+     * and render it. Within this `columns` config, there will also be opportunities
+     * to set the behavior of columns when rendered
+     */
+    columns: () => ColumnConfig<DataType>[];
+    /**
+     * The data to render, as described via the `columns` option.
+     *
+     * This data may or may not match the shape requested by the columns configuration.
+     * When a key-value pair matches what a column config requests, the data will be rendered.
+     * When a key-value pair is misisng, a fallback or empty representation of a value will be
+     * shown instead.
+     */
+    data: () => DataType[];
+    /**
+     * A collection of plugins for use in extending table behavior.
+     * plugins have a collection of hooks and properties to use, but for anything
+     * requiring user interaction there will be manual connecting.
+     *
+     * The instance for each plugin can be accessed via HeadlessTable's `pluginOf(<Plugin>)`
+     * method, where it takes the plugin constructor/class/object for lookup purposes.
+     *
+     * Some plugins may require setting options for hooking into behavior
+     * provided by the plugin (for example sorting).
+     *
+     * Example:
+     * ```js
+     * import { DataSorting } from '@crowdstrike/ember-headless-table/plugins/data-sorting';
+     * import { ColumnResizing }  from '@crowdstrike/ember-headless-table/plugins/column-resizing';
+     *
+     *  ...
+     *
+     *  plugins: [
+     *    DataSorting.with(() => {
+     *      return {
+     *        sorts: [array of sorts],
+     *        onSort: this.doThingWhenSortsChange,
+     *      };
+     *    }),
+     *    ColumnResizing.with(() => {
+     *      return {
+     *        enabled: true,
+     *      }
+     *    }),
+     *  ]
+     * ```
+     *
+     * However, for plugins with no needed options, the list can be simplified:
+     * ```js
+     * import { ColumnResizing }  from '@crowdstrike/ember-headless-table/plugins/column-resizing';
+     * import { StickyColumns }  from '@crowdstrike/ember-headless-table/plugins/sticky-columns';
+     *
+     *  ...
+     *
+     *  plugins: [
+     *    ColumnResizing,
+     *    StickyColumns,
+     *  ]
+     * ```
+     */
+    plugins?: Plugins;
+    bulkSelection?: Selection;
+    isCheckboxSelectable?: boolean;
+    isRowSelectable?: boolean;
+    rowSelection?: () => DataType;
+    onRowSelectionChange?: (selection: DataType | undefined) => void;
+    meta?: TableMeta;
+    pagination?: Pagination;
+    /**
+     * Foundational to tables is how to store settings within them.
+     * The `key` is meant to identify a particular kind of table. For example, if
+     * you have a table representing "blog posts", your table key may be "blog-posts".
+     *
+     * And most importantly, the `adapter` is how you load and save the preferences.
+     * This may bo to local storage, or some API.
+     */
+    preferences?: {
+        /**
+         * What to name the table in the preferences storage of your choice.
+         * Any string is valid provided that the storage adapter of your choice supports
+         * the format.
+         *
+         * For example, if you have a table of "blog posts", the preferences key might be
+         * `"all-blog-posts"`
+         */
+        key: string;
+        /**
+         * Configuration for how you wish to `persist` and `restore` the configuration for your table.
+         *
+         * `persist` may be async as it is a fire-and-forget type of action.
+         *
+         * However, `restore` must be synchronous, as this is a blocking operation for rendering the table.
+         * So it's best to load up the table preferences before rendering a table.
+         */
+        adapter?: PreferencesAdapter;
+    };
+}
+export { TableMeta, TableConfig };

package/dist/-private/interfaces/table.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=table.js.map

package/dist/-private/interfaces/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/-private/js-helper.d.ts

@@ -0,0 +1,39 @@
+import { Table } from "../table-8e46554b";
+import { TableConfig } from "./interfaces/index";
+/**
+ * Represents a UI-less version of a table
+ *
+ * _For use for building tables in ui frameworks_.
+ *
+ * @example
+ * ```js
+ * import { use } from 'ember-resources';
+ * import { headlessTable } '@crowdstrike/ember-headless-table';
+ *
+ * class MyImplementation {
+ *   @use table = headlessTable({
+ *     // your config here
+ *   })
+ * }
+ * ```
+ */
+declare function headlessTable<T = unknown>(options: TableConfig<T>): Table<T>;
+/**
+ * Represents a UI-less version of a table
+ *
+ * _For use for building tables in ui frameworks_.
+ *
+ * @example
+ * ```js
+ * import { headlessTable } '@crowdstrike/ember-headless-table';
+ *
+ * class MyImplementation {
+ *   table = headlessTable(this, {
+ *     // your config here
+ *   })
+ * }
+ * ```
+ *
+ */
+declare function headlessTable<T = unknown>(destroyable: object, options: TableConfig<T>): Table<T>;
+export { headlessTable };

package/dist/-private/js-helper.js

@@ -0,0 +1,20 @@
+import { a as Table } from '../table-8e46554b.js';
+
+function headlessTable(...args) {
+  if (args.length === 2) {
+    let [destroyable, options] = args;
+    /**
+     * If any "root level" config changes, we need to throw-away everything.
+     * otherwise individual-property reactivity can be managed on a per-property
+     * "thunk"-basis
+     */
+
+    return Table.from(destroyable, () => options);
+  }
+
+  let [options] = args;
+  return Table.from(() => options);
+}
+
+export { headlessTable };
+//# sourceMappingURL=js-helper.js.map

package/dist/-private/js-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-helper.js","sources":["../../src/-private/js-helper.ts"],"sourcesContent":["import { Table } from './table';\n\nimport type { TableConfig } from '#interfaces';\n\ntype Args<T> = [destroyable: object, options: TableConfig<T>] | [options: TableConfig<T>];\n\n/**\n * Represents a UI-less version of a table\n *\n * _For use for building tables in ui frameworks_.\n *\n * @example\n * ```js\n * import { use } from 'ember-resources';\n * import { headlessTable } '@crowdstrike/ember-headless-table';\n *\n * class MyImplementation {\n *   @use table = headlessTable({\n *     // your config here\n *   })\n * }\n * ```\n */\nexport function headlessTable<T = unknown>(options: TableConfig<T>): Table<T>;\n\n/**\n * Represents a UI-less version of a table\n *\n * _For use for building tables in ui frameworks_.\n *\n * @example\n * ```js\n * import { headlessTable } '@crowdstrike/ember-headless-table';\n *\n * class MyImplementation {\n *   table = headlessTable(this, {\n *     // your config here\n *   })\n * }\n * ```\n *\n */\nexport function headlessTable<T = unknown>(destroyable: object, options: TableConfig<T>): Table<T>;\n\nexport function headlessTable<T = unknown>(...args: Args<T>): Table<T> {\n  if (args.length === 2) {\n    let [destroyable, options] = args;\n\n    /**\n     * If any \"root level\" config changes, we need to throw-away everything.\n     * otherwise individual-property reactivity can be managed on a per-property\n     * \"thunk\"-basis\n     */\n    return Table.from<Table<T>>(destroyable, () => options);\n  }\n\n  let [options] = args;\n\n  return Table.from<Table<T>>(() => options);\n}\n"],"names":["headlessTable","args","length","destroyable","options","Table","from"],"mappings":";;AA4CO,SAASA,aAAT,CAAoC,GAAGC,IAAvC,EAAgE;AACrE,EAAA,IAAIA,IAAI,CAACC,MAAL,KAAgB,CAApB,EAAuB;AACrB,IAAA,IAAI,CAACC,WAAD,EAAcC,OAAd,IAAyBH,IAA7B,CAAA;AAEA;AACJ;AACA;AACA;AACA;;IACI,OAAOI,KAAK,CAACC,IAAN,CAAqBH,WAArB,EAAkC,MAAMC,OAAxC,CAAP,CAAA;AACD,GAAA;;EAED,IAAI,CAACA,OAAD,CAAA,GAAYH,IAAhB,CAAA;AAEA,EAAA,OAAOI,KAAK,CAACC,IAAN,CAAqB,MAAMF,OAA3B,CAAP,CAAA;AACD;;;;"}

package/dist/-private/preferences.d.ts

@@ -0,0 +1,56 @@
+import { TrackedMap } from 'tracked-built-ins';
+import { PluginPreferenceFor, PluginPreferences, TablePreferencesData } from "./interfaces/index";
+import { PreferencesAdapter as Adapter } from "./interfaces/index";
+declare class TablePreferences {
+    private key;
+    private adapter?;
+    storage: TrackedPreferences;
+    constructor(key: string, adapter?: Adapter | undefined);
+    hasAdapter(): boolean;
+    getIsAtDefault(): boolean;
+    /**
+     * Passes a JSON-compatible structure to `adapter.persist`
+     *
+     * This structure could be stored in a remote database or
+     * local storage. The `adpater.restore` method can be used to restore
+     * this structure back in to the {@link TrackedPreferences }
+     */
+    /**
+     * Passes a JSON-compatible structure to `adapter.persist`
+     *
+     * This structure could be stored in a remote database or
+     * local storage. The `adpater.restore` method can be used to restore
+     * this structure back in to the {@link TrackedPreferences }
+     */
+    persist(): void | undefined;
+    /**
+     * Using the `adapter.restore` method, convert the JSON structure
+     * to {@link TrackedPreferences }
+     */
+    /**
+     * Using the `adapter.restore` method, convert the JSON structure
+     * to {@link TrackedPreferences }
+     */
+    restore(adapter: Adapter): void;
+}
+/**
+ * @public
+ *
+ * The API for reactively interacting with preferences
+ */
+declare class TrackedPreferences {
+    plugins: Map<string, TrackedPluginPrefs<unknown>>;
+    get isAtDefault(): boolean;
+    forPlugin(name: string): TrackedPluginPrefs<unknown>;
+    serialize(): TablePreferencesData;
+    restore(data: TablePreferencesData): void;
+}
+declare class TrackedPluginPrefs<PluginName = unknown> {
+    table: TrackedMap<string, unknown>;
+    columns: Map<string, TrackedMap<string, unknown>>;
+    get isAtDefault(): boolean;
+    forColumn: (key: string) => TrackedMap<string, unknown>;
+    serialize(): PluginPreferenceFor<PluginName>;
+    restore(data: PluginPreferences): void;
+}
+export { TablePreferences };