@xh/hoist 57.0.0 → 57.0.2

package/build/types/data/cube/Cube.d.ts

@@ -0,0 +1,159 @@
+import { HoistBase, PlainObject } from '@xh/hoist/core';
+import { CubeField, CubeFieldSpec } from './CubeField';
+import { QueryConfig } from './Query';
+import { View } from './View';
+import { Store, StoreRecordIdSpec, StoreTransaction } from '../Store';
+import { StoreRecord } from '../StoreRecord';
+import { AggregateRow } from './row/AggregateRow';
+import { BucketRow } from './row/BucketRow';
+import { BaseRow } from './row/BaseRow';
+import { BucketSpec } from './BucketSpec';
+export interface CubeConfig {
+    fields: CubeField[] | CubeFieldSpec[];
+    /** Default configs applied to all `CubeField`s constructed internally by this Cube. */
+    fieldDefaults?: Partial<CubeFieldSpec>;
+    /** Array of initial raw data. */
+    data?: PlainObject[];
+    /** See {@link StoreConfig.idSpec} */
+    idSpec?: StoreRecordIdSpec;
+    /** See {@link StoreConfig.processRawData} */
+    processRawData?: (data: PlainObject) => PlainObject;
+    /** Convenience bucket for app-specific metadata associated with the loaded dataset. */
+    info?: PlainObject;
+    /**
+     * Optional function to be called for each aggregate node to determine if it should be "locked",
+     * preventing drill-down into its children.
+     */
+    lockFn?: LockFn;
+    /**
+     * Optional function to be called for each dimension during row generation to determine if the
+     * children of that dimension should be bucketed into additional dynamic dimensions.
+     */
+    bucketSpecFn?: BucketSpecFn;
+    /**
+     * Optional function to be called on all single child rows during view processing.
+     * Return true to omit the row.
+     */
+    omitFn?: OmitFn;
+}
+/**
+ * A data store that supports grouping, aggregating, and filtering data on multiple dimensions.
+ *
+ * This object is a wrapper around a "flat" Store containing leaf-level facts. It supports creating
+ * Views on that data via structured Queries that can filter, group, and aggregate the flat source
+ * data and produce a hierarchical result ready for use in (e.g.) tree grids and maps. Views can
+ * be transiently created to run a Query once, on demand, or can be retained to provide efficient,
+ * auto-updating results in response to updates to the underlying data.
+ */
+export declare class Cube extends HoistBase {
+    static RECORD_ID_DELIMITER: string;
+    store: Store;
+    lockFn: LockFn;
+    bucketSpecFn: BucketSpecFn;
+    omitFn: OmitFn;
+    info: any;
+    _connectedViews: Set<View>;
+    constructor({ fields, fieldDefaults, data, idSpec, processRawData, info, lockFn, bucketSpecFn, omitFn }: CubeConfig);
+    /** Fields configured for this Cube. */
+    get fields(): CubeField[];
+    /** Dimension Fields configured for this Cube. */
+    get dimensions(): CubeField[];
+    /** Records loaded in to this Cube. */
+    get records(): StoreRecord[];
+    /** Count of currently connected, auto-updating Views. */
+    get connectedViewCount(): number;
+    /**
+     * Query the cube.
+     *
+     * This method will return a snapshot of javascript objects representing the filtered
+     * and aggregated data in the query.  In addition to the fields specified in Query, nodes will
+     * each contain a 'cubeLabel' and a 'cubeDimension' property.
+     *
+     * @param query - Config for query defining the shape of the view.
+     * @returns data containing the results of the query as a hierarchical set of rows.
+     */
+    executeQuery(query: QueryConfig): any;
+    /**
+     * Create a View on this data.
+     *
+     * Creates a dynamic View of the cube data, based on a query.  Useful for binding to grids a
+     * and efficiently displaying changing results in the Cube.
+     *
+     * Note: Applications should call {@link View.disconnect} or {@link View.destroy} on the View
+     * created by this method when appropriate to avoid unnecessary processing.
+     *
+     * @param query - query to be used to construct this view.
+     * @param stores - Stores to be loaded/reloaded with data from this view.
+     *      To receive data only, use the 'results' property of the returned View instead.
+     * @param connect - true to update View automatically when data in
+     *      the underlying cube is changed. Default false.
+     */
+    createView({ query, stores, connect }: {
+        query: QueryConfig;
+        stores?: Store[] | Store;
+        connect?: boolean;
+    }): View;
+    /**
+     * True if the provided view is connected to this Cube for live updates.
+     */
+    viewIsConnected(view: View): boolean;
+    /** @param view - view to disconnect from live updates. */
+    disconnectView(view: View): void;
+    /**
+     * Populate this cube with a new dataset.
+     *
+     * This method largely delegates to Store.loadData().  See that method for more
+     * information.
+     *
+     * Note that this method will update its views asynchronously, in order to avoid locking
+     * up the browser when attached to multiple expensive views.
+     *
+     * @param rawData - flat array of lowest/leaf level data rows.
+     * @param info - optional metadata to associate with this cube/dataset.
+     */
+    loadDataAsync(rawData: PlainObject[], info?: PlainObject): Promise<void>;
+    /**
+     * Update this cube with incremental data set changes and/or info.
+     * This method largely delegates to {@link Store.updateData} - see that method for more info.
+     *
+     * Note that this method will update its views asynchronously in order to avoid locking
+     * up the browser when attached to multiple expensive views.
+     *
+     * @param rawData - data changes to process. If provided as an array, rawData will be processed
+     *      into adds and updates, with updates determined by matching existing records by ID.
+     * @param infoUpdates - new key-value pairs to be applied to existing info on this cube.
+     */
+    updateDataAsync(rawData: PlainObject[] | StoreTransaction, infoUpdates?: PlainObject): Promise<void>;
+    /** Clear any/all data and info from this Cube. */
+    clearAsync(): Promise<void>;
+    /**
+     * Populate the metadata associated with this cube.
+     * @param infoUpdates - new key-value pairs to be applied to existing info on this cube.
+     */
+    updateInfo(infoUpdates?: PlainObject): void;
+    private setInfo;
+    private parseFields;
+    destroy(): void;
+}
+/**
+ * Function to be called for each node to aggregate to determine if it should be "locked",
+ * preventing drilldown into its children. If true returned for a node, no drilldown will be
+ * allowed, and the row will be marked with a boolean "locked" property.
+ */
+export type LockFn = (row: AggregateRow | BucketRow) => boolean;
+/**
+ * Function to be called for each node during row generation to determine if it should be
+ * skipped in tree output.  Useful for removing aggregates that are degenerate due to context.
+ * Note that skipping in this way has no effect on aggregations -- all children of this node are
+ * simply promoted to their parent node.
+ */
+export type OmitFn = (row: AggregateRow | BucketRow) => boolean;
+/**
+ * Function to be called for each dimension to determine if children of said dimension should be
+ * bucketed into additional dynamic dimensions.
+ *
+ * @param rows - the rows being checked for bucketing
+ * @returns a BucketSpec for configuring the bucket to place child rows into, or null to perform
+ *          no bucketing
+ */
+export type BucketSpecFn = (rows: BaseRow[]) => BucketSpec;

package/build/types/data/cube/CubeField.d.ts

@@ -0,0 +1,52 @@
+import { PlainObject } from '@xh/hoist/core';
+import { Aggregator, AverageAggregator, AverageStrictAggregator, ChildCountAggregator, Field, FieldSpec, LeafCountAggregator, MaxAggregator, MinAggregator, NullAggregator, SingleAggregator, SumAggregator, SumStrictAggregator, UniqueAggregator } from '@xh/hoist/data';
+export interface CubeFieldSpec extends FieldSpec {
+    /** True to allow this field to be used for grouping.*/
+    isDimension?: boolean;
+    /**
+     * Instance of a Hoist Cube Aggregator (from the aggregate package), or string alias for the
+     * same (e.g. 'MAX').
+     */
+    aggregator?: Aggregator | 'AVG' | 'AVG_STRICT' | 'CHILD_COUNT' | 'LEAF_COUNT' | 'MAX' | 'MIN' | 'NULL' | 'SINGLE' | 'SUM' | 'SUM_STRICT' | 'UNIQUE';
+    /** Function to determine if aggregation should be performed at a given level of a query result. */
+    canAggregateFn?: CanAggregateFn;
+    /** True if any further groupings below this dimension would be derivative (have only one member). */
+    isLeafDimension?: boolean;
+    /**
+     * Name of field that is a 'parent' dimension of this dimension. This marks this dimension as a
+     * sub-dimension of the parent dimension (e.g. 'asset group' and 'asset'). This allows the view
+     * to skip creating derivative nodes when a parent node has a single identical child node.
+     */
+    parentDimension?: string;
+}
+/**
+ * @param dimension - dimension of aggregation
+ * @param value - value of record on dimension
+ * @param appliedDims - *all* applied dimension values for this record
+ */
+export type CanAggregateFn = (dimension: string, value: any, appliedDims: PlainObject) => boolean;
+/**
+ * Metadata used to define a measure or dimension in Cube. For properties present on raw data source
+ * objects to be included in a Cube, the Cube must be configured with a matching Field that tells
+ * it to extract the data from the source objects and how to aggregate or filter on that data.
+ */
+export declare class CubeField extends Field {
+    aggregator: Aggregator;
+    canAggregateFn: CanAggregateFn;
+    isDimension: boolean;
+    isLeafDimension: boolean;
+    parentDimension: string;
+    static averageAggregator: AverageAggregator;
+    static averageStrictAggregator: AverageStrictAggregator;
+    static childCountAggregator: ChildCountAggregator;
+    static leafCountAggregator: LeafCountAggregator;
+    static maxAggregator: MaxAggregator;
+    static minAggregator: MinAggregator;
+    static nullAggregator: NullAggregator;
+    static singleAggregator: SingleAggregator;
+    static sumAggregator: SumAggregator;
+    static sumStrictAggregator: SumStrictAggregator;
+    static uniqueAggregator: UniqueAggregator;
+    constructor({ isDimension, aggregator, canAggregateFn, isLeafDimension, parentDimension, ...fieldArgs }: CubeFieldSpec);
+    private parseAggregator;
+}

package/build/types/data/cube/Query.d.ts

@@ -0,0 +1,63 @@
+import { Filter, StoreRecord } from '@xh/hoist/data';
+import { FilterLike } from '../filter/Types';
+import { CubeField } from './CubeField';
+import { Cube } from './Cube';
+/**
+ * Queries determine what data is extracted from a cube and how it should be grouped + aggregated.
+ *
+ * Note that if no dimensions are provided, 'includeRoot' or 'includeLeaves' should be true -
+ * otherwise no data will be returned!
+ */
+export interface QueryConfig {
+    /**
+     * Associated Cube. Required, but note that `Cube.executeQuery()` will install a reference to
+     * itself on the query config (automatically)
+     */
+    cube?: Cube;
+    /**
+     * Fields or field names. If unspecified will include all available fields
+     * from the source Cube, otherwise supply a subset to optimize aggregation performance.
+     */
+    fields?: string[] | CubeField[];
+    /**
+     * Fields or field names to group on. Any fields provided must also be in fields config, above. If none
+     * given the resulting data will not be grouped.
+     */
+    dimensions?: string[] | CubeField[];
+    /**
+     * One or more filters or configs to create one.  If an array, a single 'AND' filter will
+     * be created.
+     */
+    filter?: FilterLike;
+    /**
+     * IncludeRoot?: True to include a synthetic root node in the return with grand total
+     * aggregate values.
+     */
+    includeRoot?: boolean;
+    /** True to include leaf nodes in return.*/
+    includeLeaves?: boolean;
+}
+/** {@inheritDoc QueryConfig} */
+export declare class Query {
+    readonly fields: CubeField[];
+    readonly dimensions: CubeField[];
+    readonly filter: Filter;
+    readonly includeRoot: boolean;
+    readonly includeLeaves: boolean;
+    readonly cube: Cube;
+    private readonly _testFn;
+    constructor({ cube, fields, dimensions, filter, includeRoot, includeLeaves }: QueryConfig);
+    clone(overrides: Partial<QueryConfig>): Query;
+    test(record: StoreRecord): boolean;
+    /**
+     * True if the provided other Query is equivalent to this instance.
+     */
+    equals(other: Query): boolean;
+    /**
+     * True if the provided other Query is equivalent to this instance,
+     * not considering the filter.
+     */
+    equalsExcludingFilter(other: Query): boolean;
+    private parseFields;
+    private parseDimensions;
+}

package/build/types/data/cube/View.d.ts

@@ -0,0 +1,97 @@
+import { HoistBase, PlainObject, Some } from '@xh/hoist/core';
+import { Cube, CubeField, Filter, FilterLike, Query, QueryConfig, Store, StoreRecordId } from '@xh/hoist/data';
+import { AggregationContext } from './aggregate/AggregationContext';
+import { LeafRow } from './row/LeafRow';
+export interface ViewConfig {
+    /** Query to be used to construct this view. */
+    query: Query;
+    /**
+     * Store(s) to be automatically (re)loaded with data from this view. Optional - read the View's
+     * observable `result` property directly to use without a Store.
+     */
+    stores?: Store[] | Store;
+    /**
+     * True to reactively update the View's `result` and any connected store(s) when data in the
+     * underlying Cube is changed. False (default) to have this view run its query once to capture
+     * a snapshot without further updates based on Cube changes.
+     */
+    connect?: boolean;
+}
+export interface DimensionValue {
+    /** Dimension field. */
+    field: CubeField;
+    /** Unique non-null values for the dimension */
+    values: Set<any>;
+}
+/**
+ * Primary interface for consuming grouped and aggregated data from the cube.
+ * Applications should create via the {@link Cube.createView} factory.
+ */
+export declare class View extends HoistBase {
+    get isView(): boolean;
+    /** Query defining this View. Update via `updateQuery()`. */
+    query: Query;
+    /**
+     * Results of this view, an observable object with a `rows` property
+     * containing an array of hierarchical data objects.
+     */
+    result: {
+        rows: PlainObject[];
+        leafMap: Map<StoreRecordId, LeafRow>;
+    };
+    /** Stores to which results of this view should be (re)loaded. */
+    stores: Store[];
+    /** Cube info associated with this View when last updated. */
+    info: PlainObject;
+    /** timestamp (ms) of the last time this view's data was changed. */
+    lastUpdated: number;
+    private _rows;
+    private _rowCache;
+    private _leafMap;
+    private _recordMap;
+    _aggContext: AggregationContext;
+    /** @internal - applications should use {@link Cube.createView} */
+    constructor(config: ViewConfig);
+    get cube(): Cube;
+    get fields(): CubeField[];
+    get fieldNames(): string[];
+    get filter(): Filter;
+    get isConnected(): boolean;
+    get isFiltered(): boolean;
+    /** Stop receiving live updates into this view when the linked Cube data changes. */
+    disconnect(): void;
+    /**
+     * Change the query in some way, re-computing the data in this View to reflect the new query.
+     *
+     * @param overrides - changes to be applied to the query. May include any arguments to the query
+     *      constructor except `cube`, which cannot be changed on a view once set
+     *      via the initial query.
+     */
+    updateQuery(overrides: Partial<QueryConfig>): void;
+    /**
+     * Gathers all unique values for each dimension field in the query
+     */
+    getDimensionValues(): DimensionValue[];
+    /** Get a specific Field by name.*/
+    getField(name: string): CubeField;
+    /** Set stores to be loaded/reloaded with data from this view. */
+    setStores(stores: Some<Store>): void;
+    /** Update the filter on the current Query.*/
+    setFilter(filter: FilterLike): void;
+    noteCubeLoaded(): void;
+    noteCubeUpdated(changeLog: PlainObject): void;
+    private fullUpdate;
+    private dataOnlyUpdate;
+    private loadStores;
+    private updateResults;
+    private generateRows;
+    private groupAndInsertRecords;
+    private bucketRows;
+    private getSimpleUpdates;
+    private hasDimUpdates;
+    private cachedRow;
+    private filterRecords;
+    private createAggregationContext;
+    private get aggregatorsAreSimple();
+    destroy(): void;
+}

package/build/types/data/cube/aggregate/AggregationContext.d.ts

@@ -0,0 +1,21 @@
+import { StoreRecord } from '../../StoreRecord';
+import { View } from '../View';
+/**
+ * Context provided to aggregators.
+ *
+ * This context will remain over the lifetime of an aggregation update of a view, and can therefore
+ * be used by aggregators to accumulate or cache values needed for the current set of records.
+ * It will be replaced if the current set of records is being changed in any way.
+ */
+export declare class AggregationContext {
+    /** View being aggregated. */
+    view: View;
+    /** All records currently meeting the filter for this view.*/
+    filteredRecords: StoreRecord[];
+    /**
+     * Custom aggregators may use to store pre-computed values.  Custom aggregators should
+     * take care to appropriately namespace any data stored within this object.
+     */
+    appData: any;
+    constructor(view: View, filteredRecords: StoreRecord[]);
+}

package/build/types/data/cube/aggregate/Aggregator.d.ts

@@ -0,0 +1,40 @@
+import { AggregationContext } from './AggregationContext';
+import { BaseRow } from '../row/BaseRow';
+import { LeafRow } from '../row/LeafRow';
+import { RowUpdate } from '../row/RowUpdate';
+export declare abstract class Aggregator {
+    /**
+     * Does this aggregator depend only on leaf nodes contained by the node being aggregated?
+     *
+     * By default this property returns true, indicating to the cube that if all children of a
+     * given node are the same, the node does not need to be re-aggregated.  Aggregators that
+     * depend on global values (e.g. % of total) should return false for this value.
+     */
+    get dependsOnChildrenOnly(): boolean;
+    /**
+     * Aggregate values
+     * @param rows - current rows in aggregation.  Will never be empty.
+     * @param fieldName - name of field to perform the aggregation on.
+     * @param context - current aggregation context
+     */
+    abstract aggregate(rows: BaseRow[], fieldName: string, context: AggregationContext): any;
+    /**
+     * Adjust an aggregated value, by replacing one of its constituent components.
+     *
+     * @param rows - current rows in aggregation.  Will never be empty.
+     * @param currVal - current value of aggregation
+     * @param update - update that occurred to child of this aggregation.
+     *      Sub-classes may use this method to provide efficient implementations for dynamic changes
+     *      to an aggregation.  The default implementation will simply re-aggregate.
+     * @param context - current aggregation context
+     * @returns new aggregate value
+     */
+    replace(rows: BaseRow[], currVal: any, update: RowUpdate, context: AggregationContext): any;
+    /**
+     * Call function on all *leaf* children of a set of children.
+     *
+     * @param rows - array of child rows
+     * @param fn - the function to call on each leaf.
+     */
+    protected forEachLeaf(rows: BaseRow[], fn: (leaf: LeafRow) => boolean | void): boolean;
+}

package/build/types/data/cube/aggregate/AverageAggregator.d.ts

@@ -0,0 +1,4 @@
+import { Aggregator } from './Aggregator';
+export declare class AverageAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): number;
+}

package/build/types/data/cube/aggregate/AverageStrictAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class AverageStrictAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): number;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/ChildCountAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class ChildCountAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/LeafCountAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class LeafCountAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): number;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/MaxAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class MaxAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/MinAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class MinAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/NullAggregator.d.ts

@@ -0,0 +1,4 @@
+import { Aggregator } from './Aggregator';
+export declare class NullAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+}

package/build/types/data/cube/aggregate/SingleAggregator.d.ts

@@ -0,0 +1,4 @@
+import { Aggregator } from './Aggregator';
+export declare class SingleAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+}

package/build/types/data/cube/aggregate/SumAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class SumAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/SumStrictAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class SumStrictAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/aggregate/UniqueAggregator.d.ts

@@ -0,0 +1,5 @@
+import { Aggregator } from './Aggregator';
+export declare class UniqueAggregator extends Aggregator {
+    aggregate(rows: any, fieldName: any): any;
+    replace(rows: any, currAgg: any, update: any, context: any): any;
+}

package/build/types/data/cube/row/AggregateRow.d.ts

@@ -0,0 +1,13 @@
+import { PlainObject } from '@xh/hoist/core';
+import { CubeField } from '../CubeField';
+import { View } from '../View';
+import { BaseRow } from './BaseRow';
+/**
+ *  Object used by views to gather Aggregate rows.
+ */
+export declare class AggregateRow extends BaseRow {
+    get isAggregate(): boolean;
+    readonly dim: CubeField;
+    readonly dimName: string;
+    constructor(view: View, id: string, children: BaseRow[], dim: CubeField, val: any, strVal: string, appliedDimensions: PlainObject);
+}

package/build/types/data/cube/row/BaseRow.d.ts

@@ -0,0 +1,27 @@
+import { PlainObject, Some } from '@xh/hoist/core';
+import { BucketSpec } from '@xh/hoist/data/cube/BucketSpec';
+import { View } from '../View';
+import { RowUpdate } from './RowUpdate';
+/**
+ * Base class for a view row.
+ */
+export declare abstract class BaseRow {
+    readonly view: View;
+    readonly id: string;
+    readonly data: PlainObject;
+    parent: BaseRow;
+    children: BaseRow[];
+    locked: boolean;
+    canAggregate: PlainObject;
+    get isLeaf(): boolean;
+    get isAggregate(): boolean;
+    get isBucket(): boolean;
+    constructor(view: View, id: string);
+    noteBucketed(bucketSpec: BucketSpec, bucketVal: any): void;
+    getVisibleDatas(): Some<PlainObject>;
+    private getVisibleChildrenDatas;
+    private isRedundantChild;
+    protected initAggregate(children: BaseRow[], dimOrBucketName: string, val: any, appliedDimensions: PlainObject): void;
+    applyDataUpdate(childUpdates: RowUpdate[], updatedRowDatas: Set<PlainObject>): void;
+    protected computeAggregates(): void;
+}

package/build/types/data/cube/row/BucketRow.d.ts

@@ -0,0 +1,12 @@
+import { PlainObject } from '@xh/hoist/core';
+import { BaseRow } from './BaseRow';
+import { BucketSpec } from '../BucketSpec';
+import { View } from '../View';
+/**
+ *  Object used by views to gather bucket rows.
+ */
+export declare class BucketRow extends BaseRow {
+    get isBucket(): boolean;
+    readonly bucketSpec: BucketSpec;
+    constructor(view: View, id: string, children: BaseRow[], bucketVal: any, bucketSpec: BucketSpec, appliedDimensions: PlainObject);
+}

package/build/types/data/cube/row/LeafRow.d.ts

@@ -0,0 +1,12 @@
+import { PlainObject } from '@xh/hoist/core';
+import { StoreRecord } from '../../StoreRecord';
+import { View } from '../View';
+import { BaseRow } from './BaseRow';
+/**
+ * Object used to track leaf rows in a View
+ */
+export declare class LeafRow extends BaseRow {
+    get isLeaf(): boolean;
+    constructor(view: View, id: string, rawRecord: StoreRecord);
+    applyLeafDataUpdate(newRec: StoreRecord, updatedRowDatas: Set<PlainObject>): void;
+}

package/build/types/data/cube/row/RowUpdate.d.ts

@@ -0,0 +1,10 @@
+import { CubeField } from '../CubeField';
+/**
+ * @internal
+ */
+export declare class RowUpdate {
+    readonly field: CubeField;
+    oldValue: any;
+    newValue: any;
+    constructor(field: CubeField, oldValue: any, newValue: any);
+}

package/build/types/data/filter/BaseFilterFieldSpec.d.ts

@@ -0,0 +1,73 @@
+import { HoistBase } from '@xh/hoist/core';
+import { Field, Store, FieldType, View } from '@xh/hoist/data';
+import { FieldFilterOperator } from './Types';
+export interface BaseFilterFieldSpecConfig {
+    /** Identifying field name to filter on. */
+    field: string;
+    /** Type of field, will default from related field on source if provided, or 'auto'. */
+    fieldType?: FieldType;
+    /** DisplayName, will default from related field on source if provided */
+    displayName?: string;
+    /** Operators available for filtering, will default to a supported set based on type.*/
+    ops?: FieldFilterOperator[];
+    /** Used to source matching data `Field` and extract values if configured. */
+    source?: Store | View;
+    /**
+     * True to provide interfaces and auto-complete options
+     * with enumerated matches for creating '=' or '!=' filters. Defaults to true for
+     * enumerable fieldTypes. Always true if 'values' provided or if fieldType is BOOL.
+     */
+    enableValues?: boolean;
+    /**
+     * True to require value entered to be an available value for '=' and '!=' operators.
+     * Defaults to false.
+     */
+    forceSelection?: boolean;
+    /** Explicit list of available values for this field. */
+    values?: any[];
+}
+/**
+ * Defines field-level filtering options and provides metadata for presenting these options in
+ * UI affordances such as FilterChooser to Grid Column Filters.
+ *
+ * @see FilterChooserFieldSpec
+ * @see GridFilterFieldSpec
+ */
+export declare abstract class BaseFilterFieldSpec extends HoistBase {
+    field: string;
+    fieldType: FieldType;
+    displayName: string;
+    ops: FieldFilterOperator[];
+    source: Store | View;
+    enableValues: boolean;
+    forceSelection: boolean;
+    values: any[];
+    hasExplicitValues: boolean;
+    constructor({ field, fieldType, displayName, ops, source, enableValues, forceSelection, values }: BaseFilterFieldSpecConfig);
+    /** Full Field derived from source. */
+    get sourceField(): Field;
+    /**
+     * Determines operations supported by this field.
+     *
+     * Type 'range' indicates the field should use mathematical / logical operations:
+     * `(>, >=, <, <=, =, !=)`.
+     *
+     * Type 'value' indicates the field should use equality operators:
+     * `(=, !=, like, not like, begins, ends)`
+     * against a suggested exact value or user-provided input.
+     */
+    get filterType(): 'range' | 'value' | 'collection';
+    get isRangeType(): boolean;
+    get isValueType(): boolean;
+    get isCollectionType(): boolean;
+    get isDateBasedFieldType(): boolean;
+    get isNumericFieldType(): boolean;
+    get isBoolFieldType(): boolean;
+    loadValues(): void;
+    supportsOperator(op: FieldFilterOperator): boolean;
+    supportsSuggestions(op: FieldFilterOperator): boolean;
+    abstract loadValuesFromSource(): any;
+    private parseOperators;
+    private getDefaultOperators;
+    private get isEnumerableByDefault();
+}