@deephaven/jsapi-types 1.0.0-dev0.36.0 → 1.0.0-dev0.36.1

package/dist/index.d.ts

@@ -17,6 +17,37 @@ export interface Iterator<T> {
 }
 export namespace dh.storage {
 
+	/**
+	* Storage service metadata about files and folders.
+	*/
+	export class ItemDetails {
+		protected constructor();
+
+		toString():string;
+		get filename():string;
+		get basename():string;
+		get size():number;
+		get etag():string;
+		get type():ItemTypeType;
+		get dirname():string;
+	}
+
+	/**
+	* Represents a file's contents loaded from the server. If an etag was specified when loading, client should first test
+	* if the etag of this instance matches - if so, the contents will be empty, and the client's existing contents should
+	* be used.
+	*/
+	export class FileContents {
+		protected constructor();
+
+		static blob(blob:Blob):FileContents;
+		static text(...text:string[]):FileContents;
+		static arrayBuffers(...buffers:ArrayBuffer[]):FileContents;
+		text():Promise<string>;
+		arrayBuffer():Promise<ArrayBuffer>;
+		get etag():string;
+	}
+
 	/**
 	* Remote service to read and write files on the server. Paths use "/" as a separator, and should not start with "/".
 	*/
@@ -75,37 +106,6 @@ export namespace dh.storage {
 		createDirectory(path:string):Promise<void>;
 	}
 
-	/**
-	* Storage service metadata about files and folders.
-	*/
-	export class ItemDetails {
-		protected constructor();
-
-		toString():string;
-		get filename():string;
-		get basename():string;
-		get size():number;
-		get etag():string;
-		get type():ItemTypeType;
-		get dirname():string;
-	}
-
-	/**
-	* Represents a file's contents loaded from the server. If an etag was specified when loading, client should first test
-	* if the etag of this instance matches - if so, the contents will be empty, and the client's existing contents should
-	* be used.
-	*/
-	export class FileContents {
-		protected constructor();
-
-		static blob(blob:Blob):FileContents;
-		static text(...text:string[]):FileContents;
-		static arrayBuffers(...buffers:ArrayBuffer[]):FileContents;
-		text():Promise<string>;
-		arrayBuffer():Promise<ArrayBuffer>;
-		get etag():string;
-	}
-
 
 	type ItemTypeType = string;
 	export class ItemType {
@@ -122,134 +122,13 @@ export namespace dh {
 		get children():string[]|null;
 		get color():string|null;
 	}
-	/**
-	* Behaves like a Table, but doesn't expose all of its API for changing the internal state. Instead, state is driven by
-	* the upstream table - when it changes handle, this listens and updates its own handle accordingly.
-	*
-	* Additionally, this is automatically subscribed to its one and only row, across all columns.
-	*
-	* A new config is returned any time it is accessed, to prevent accidental mutation, and to allow it to be used as a
-	* template when fetching a new totals table, or changing the totals table in use.
-	*
-	* A simplistic Table, providing access to aggregation of the table it is sourced from. This table is always
-	* automatically subscribed to its parent, and adopts changes automatically from it. This class has limited methods
-	* found on Table. Instances of this type always have a size of one when no groupBy is set on the config, but may
-	* potentially contain as few as zero rows, or as many as the parent table if each row gets its own group.
-	*
-	* When using the `groupBy` feature, it may be desireable to also provide a row to the user with all values across all
-	* rows. To achieve this, request the same Totals Table again, but remove the `groupBy` setting.
-	*/
-	export interface TotalsTable extends JoinableTable {
-		/**
-		* Specifies the range of items to pass to the client and update as they change. If the columns parameter is not
-		* provided, all columns will be used. Until this is called, no data will be available. Invoking this will result in
-		* events to be fired once data becomes available, starting with an <b>updated</b> event and one <b>rowadded</b>
-		* event per row in that range.
-		* @param firstRow - 
-		* @param lastRow - 
-		* @param columns - 
-		* @param updateIntervalMs - 
-		*/
-		setViewport(firstRow:number, lastRow:number, columns?:Array<Column>, updateIntervalMs?:number):void;
-		/**
-		* the currently visible viewport. If the current set of operations has not yet resulted in data, it will not
-		* resolve until that data is ready.
-		* @return Promise of {@link dh.TableData}
-		*/
-		getViewportData():Promise<TableData>;
-		/**
-		* a column by the given name. You should prefer to always retrieve a new Column instance instead of caching a
-		* returned value.
-		* @param key - 
-		* @return {@link dh.Column}
-		*/
-		findColumn(key:string):Column;
-		/**
-		* multiple columns specified by the given names.
-		* @param keys - 
-		* @return {@link dh.Column} array
-		*/
-		findColumns(keys:string[]):Column[];
-		/**
-		* Indicates that the table will no longer be used, and resources used to provide it can be freed up on the server.
-		*/
-		close():void;
-		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
-		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
-		nextEvent<T>(eventName:string, timeoutInMillis:number):Promise<CustomEvent<T>>;
-		hasListeners(name:string):boolean;
-		/**
-		* Replace the currently set sort on this table. Returns the previously set value. Note that the sort property will
-		* immediately return the new value, but you may receive update events using the old sort before the new sort is
-		* applied, and the <b>sortchanged</b> event fires. Reusing existing, applied sorts may enable this to perform
-		* better on the server. The <b>updated</b> event will also fire, but <b>rowadded</b> and <b>rowremoved</b> will
-		* not.
-		* @param sort - 
-		* @return {@link dh.Sort} array
-		*/
-		applySort(sort:Sort[]):Array<Sort>;
-		/**
-		* Replace the current custom columns with a new set. These columns can be used when adding new filter and sort
-		* operations to the table, as long as they are present.
-		* @param customColumns - 
-		* @return 
-		*/
-		applyCustomColumns(customColumns:Array<string|CustomColumn>):Array<CustomColumn>;
-		/**
-		* Replace the currently set filters on the table. Returns the previously set value. Note that the filter property
-		* will immediately return the new value, but you may receive update events using the old filter before the new one
-		* is applied, and the <b>filterchanged</b> event fires. Reusing existing, applied filters may enable this to
-		* perform better on the server. The <b>updated</b> event will also fire, but <b>rowadded</b> and <b>rowremoved</b>
-		* will not.
-		* @param filter - 
-		* @return {@link dh.FilterCondition} array
-		*/
-		applyFilter(filter:FilterCondition[]):Array<FilterCondition>;
-		/**
-		* An ordered list of Filters to apply to the table. To update, call applyFilter(). Note that this getter will
-		* return the new value immediately, even though it may take a little time to update on the server. You may listen
-		* for the <b>filterchanged</b> event to know when to update the UI.
-		* @return {@link dh.FilterCondition} array
-		*/
-		get filter():Array<FilterCondition>;
-		/**
-		* True if this table has been closed.
-		* @return boolean
-		*/
-		get isClosed():boolean;
-		/**
-		* The total number of rows in this table. This may change as the base table's configuration, filter, or contents
-		* change.
-		* @return double
-		*/
-		get size():number;
-		/**
-		* The columns present on this table. Note that this may not include all columns in the parent table, and in cases
-		* where a given column has more than one aggregation applied, the column name will have a suffix indicating the
-		* aggregation used. This suffixed name will be of the form <b>columnName + '__' + aggregationName</b>.
-		* @return {@link dh.Column} array
-		*/
-		get columns():Array<Column>;
-		get totalsTableConfig():TotalsTableConfig;
-		/**
-		* An ordered list of Sorts to apply to the table. To update, call applySort(). Note that this getter will return
-		* the new value immediately, even though it may take a little time to update on the server. You may listen for the
-		* <b>sortchanged</b> event to know when to update the UI.
-		* @return {@link dh.Sort} array
-		*/
-		get sort():Array<Sort>;
-		/**
-		* Read-only. An ordered list of custom column formulas to add to the table, either adding new columns or replacing
-		* existing ones. To update, call <b>applyCustomColumns()</b>.
-		* @return {@link dh.CustomColumn} array
-		*/
-		get customColumns():Array<CustomColumn>;
+	export interface WorkerHeapInfo {
 		/**
-		* True if this table may receive updates from the server, including size changed events, updated events after
-		* initial snapshot.
-		* @return boolean
+		* Total heap size available for this worker.
 		*/
-		get isRefreshing():boolean;
+		get totalHeapSize():number;
+		get freeMemory():number;
+		get maximumHeapSize():number;
 	}
 	/**
 	* Common interface for various ways of accessing table data and formatting.
@@ -319,14 +198,6 @@ export namespace dh {
 		getViewportData():Promise<TableData>;
 		snapshot(rows:RangeSet, columns:Column[]):Promise<TableData>;
 	}
-	export interface WorkerHeapInfo {
-		/**
-		* Total heap size available for this worker.
-		*/
-		get totalHeapSize():number;
-		get freeMemory():number;
-		get maximumHeapSize():number;
-	}
 	/**
 	* Event data, describing the indexes that were added/removed/updated, and providing access to Rows (and thus data
 	* in columns) either by index, or scanning the complete present index.
@@ -361,34 +232,25 @@ export namespace dh {
 		get modified():RangeSet;
 		get rows():Array<Row>;
 	}
-	export interface RefreshToken {
-		get bytes():string;
-		get expiry():number;
-	}
-	/**
-	* This object may be pooled internally or discarded and not updated. Do not retain references to it.
-	*/
-	export interface Format {
-		/**
-		* The format string to apply to the value of this cell.
-		* @return String
-		*/
-		readonly formatString?:string|null;
-		/**
-		* Color to apply to the cell's background, in <b>#rrggbb</b> format.
-		* @return String
-		*/
-		readonly backgroundColor?:string|null;
+	export interface HasEventHandling {
 		/**
-		* Color to apply to the text, in <b>#rrggbb</b> format.
-		* @return String
+		* Listen for events on this object.
+		* @param name - the name of the event to listen for
+		* @param callback - a function to call when the event occurs
+		* @return Returns a cleanup function.
+		* @typeParam T - the type of the data that the event will provide
 		*/
-		readonly color?:string|null;
+		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
+		hasListeners(name:string):boolean;
 		/**
-		* 
-		* @deprecated Prefer formatString. Number format string to apply to the value in this cell.
+		* Removes an event listener added to this table.
+		* @param name - 
+		* @param callback - 
+		* @return 
+		* @typeParam T - 
 		*/
-		readonly numberFormat?:string|null;
+		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
 	}
 	/**
 	* Represents a table which can be joined to another table. Current implementations are {@link dh.Table} and
@@ -504,35 +366,15 @@ export namespace dh {
 		get hasChildren():boolean;
 		get index():LongWrapper;
 	}
-	export interface HasEventHandling {
+	/**
+	* Contains data in the current viewport. Also contains the offset to this data, so that the actual row number may be
+	* determined. Do not assume that the first row in `rows` is the first visible row, because extra rows may be provided
+	* for easier scrolling without going to the server.
+	*/
+	export interface ViewportData extends TableData {
 		/**
-		* Listen for events on this object.
-		* @param name - the name of the event to listen for
-		* @param callback - a function to call when the event occurs
-		* @return Returns a cleanup function.
-		* @typeParam T - the type of the data that the event will provide
-		*/
-		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
-		hasListeners(name:string):boolean;
-		/**
-		* Removes an event listener added to this table.
-		* @param name - 
-		* @param callback - 
-		* @return 
-		* @typeParam T - 
-		*/
-		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
-	}
-	/**
-	* Contains data in the current viewport. Also contains the offset to this data, so that the actual row number may be
-	* determined. Do not assume that the first row in `rows` is the first visible row, because extra rows may be provided
-	* for easier scrolling without going to the server.
-	*/
-	export interface ViewportData extends TableData {
-		/**
-		* The index of the first returned row
-		* @return double
+		* The index of the first returned row
+		* @return double
 		*/
 		get offset():number;
 		/**
@@ -597,6 +439,31 @@ export namespace dh {
 		toString():string;
 	}
 	/**
+	* This object may be pooled internally or discarded and not updated. Do not retain references to it.
+	*/
+	export interface Format {
+		/**
+		* The format string to apply to the value of this cell.
+		* @return String
+		*/
+		readonly formatString?:string|null;
+		/**
+		* Color to apply to the cell's background, in <b>#rrggbb</b> format.
+		* @return String
+		*/
+		readonly backgroundColor?:string|null;
+		/**
+		* Color to apply to the text, in <b>#rrggbb</b> format.
+		* @return String
+		*/
+		readonly color?:string|null;
+		/**
+		* 
+		* @deprecated Prefer formatString. Number format string to apply to the value in this cell.
+		*/
+		readonly numberFormat?:string|null;
+	}
+	/**
 	* Javascript wrapper for {@link io.deephaven.web.shared.data.ColumnStatistics} This class holds the results of a call to generate statistics on a
 	* table column.
 	*/
@@ -656,173 +523,66 @@ export namespace dh {
 		*/
 		close():void;
 	}
-	export interface TreeViewportData extends TableData {
-		get offset():number;
-		get columns():Array<Column>;
-		get rows():Array<TreeRow>;
-	}
-	/**
-	* Wrap LocalDate values for use in JS. Provides text formatting for display and access to the underlying value.
-	*/
-	export interface LocalDateWrapper {
-		valueOf():string;
-		getYear():number;
-		getMonthValue():number;
-		getDayOfMonth():number;
-		toString():string;
-	}
-
-	export class LoginCredentials {
-		type?:string|null;
-		username?:string|null;
-		token?:string|null;
-
-		constructor();
+	export interface RefreshToken {
+		get bytes():string;
+		get expiry():number;
 	}
-
 	/**
-	* Describes how a Totals Table will be generated from its parent table. Each table has a default (which may be null)
-	* indicating how that table was configured when it was declared, and each Totals Table has a similar property
-	* describing how it was created. Both the <b>Table.getTotalsTable</b> and <b>Table.getGrandTotalsTable</b> methods take
-	* this config as an optional parameter - without it, the table's default will be used, or if null, a default instance
-	* of <b>TotalsTableConfig</b> will be supplied.
+	* Behaves like a Table, but doesn't expose all of its API for changing the internal state. Instead, state is driven by
+	* the upstream table - when it changes handle, this listens and updates its own handle accordingly.
 	*
-	* This class has a no-arg constructor, allowing an instance to be made with the default values provided. However, any
-	* JS object can be passed in to the methods which accept instances of this type, provided their values adhere to the
-	* expected formats.
+	* Additionally, this is automatically subscribed to its one and only row, across all columns.
+	*
+	* A new config is returned any time it is accessed, to prevent accidental mutation, and to allow it to be used as a
+	* template when fetching a new totals table, or changing the totals table in use.
+	*
+	* A simplistic Table, providing access to aggregation of the table it is sourced from. This table is always
+	* automatically subscribed to its parent, and adopts changes automatically from it. This class has limited methods
+	* found on Table. Instances of this type always have a size of one when no groupBy is set on the config, but may
+	* potentially contain as few as zero rows, or as many as the parent table if each row gets its own group.
+	*
+	* When using the `groupBy` feature, it may be desireable to also provide a row to the user with all values across all
+	* rows. To achieve this, request the same Totals Table again, but remove the `groupBy` setting.
 	*/
-	export class TotalsTableConfig {
-		/**
-		* @deprecated
-		*/
-		static readonly COUNT:string;
-		/**
-		* @deprecated
-		*/
-		static readonly MIN:string;
-		/**
-		* @deprecated
-		*/
-		static readonly MAX:string;
-		/**
-		* @deprecated
-		*/
-		static readonly SUM:string;
-		/**
-		* @deprecated
-		*/
-		static readonly ABS_SUM:string;
-		/**
-		* @deprecated
-		*/
-		static readonly VAR:string;
-		/**
-		* @deprecated
-		*/
-		static readonly AVG:string;
-		/**
-		* @deprecated
-		*/
-		static readonly STD:string;
-		/**
-		* @deprecated
-		*/
-		static readonly FIRST:string;
-		/**
-		* @deprecated
-		*/
-		static readonly LAST:string;
-		/**
-		* @deprecated
-		*/
-		static readonly SKIP:string;
-		/**
-		* Specifies if a Totals Table should be expanded by default in the UI. Defaults to false.
-		*/
-		showTotalsByDefault:boolean;
-		/**
-		* Specifies if a Grand Totals Table should be expanded by default in the UI. Defaults to false.
-		*/
-		showGrandTotalsByDefault:boolean;
-		/**
-		* Specifies the default operation for columns that do not have a specific operation applied; defaults to "Sum".
-		*/
-		defaultOperation:AggregationOperationType;
+	export interface TotalsTable extends JoinableTable {
 		/**
-		* Mapping from each column name to the aggregation(s) that should be applied to that column in the resulting Totals
-		* Table. If a column is omitted, the defaultOperation is used.
+		* Specifies the range of items to pass to the client and update as they change. If the columns parameter is not
+		* provided, all columns will be used. Until this is called, no data will be available. Invoking this will result in
+		* events to be fired once data becomes available, starting with an <b>updated</b> event and one <b>rowadded</b>
+		* event per row in that range.
+		* @param firstRow - 
+		* @param lastRow - 
+		* @param columns - 
+		* @param updateIntervalMs - 
 		*/
-		operationMap:{ [key: string]: Array<AggregationOperationType>; };
+		setViewport(firstRow:number, lastRow:number, columns?:Array<Column>, updateIntervalMs?:number):void;
 		/**
-		* Groupings to use when generating the Totals Table. One row will exist for each unique set of values observed in
-		* these columns. See also `Table.selectDistinct`.
+		* the currently visible viewport. If the current set of operations has not yet resulted in data, it will not
+		* resolve until that data is ready.
+		* @return Promise of {@link dh.TableData}
 		*/
-		groupBy:Array<string>;
-
-		constructor();
-
-		toString():string;
-	}
-
-	/**
-	* Provides access to data in a table. Note that several methods present their response through Promises. This allows
-	* the client to both avoid actually connecting to the server until necessary, and also will permit some changes not to
-	* inform the UI right away that they have taken place.
-	*/
-	export class Table implements JoinableTable, HasEventHandling {
-		readonly description?:string|null;
-		readonly pluginName?:string|null;
-		readonly layoutHints?:null|LayoutHints;
-		static readonly EVENT_SIZECHANGED:string;
-		static readonly EVENT_UPDATED:string;
-		static readonly EVENT_ROWADDED:string;
-		static readonly EVENT_ROWREMOVED:string;
-		static readonly EVENT_ROWUPDATED:string;
-		static readonly EVENT_SORTCHANGED:string;
-		static readonly EVENT_FILTERCHANGED:string;
-		static readonly EVENT_CUSTOMCOLUMNSCHANGED:string;
-		static readonly EVENT_DISCONNECT:string;
-		static readonly EVENT_RECONNECT:string;
-		static readonly EVENT_RECONNECTFAILED:string;
-		static readonly EVENT_REQUEST_FAILED:string;
-		static readonly EVENT_REQUEST_SUCCEEDED:string;
-		static readonly SIZE_UNCOALESCED:number;
-
-		protected constructor();
-
-		batch(userCode:(arg0:unknown)=>void):Promise<Table>;
+		getViewportData():Promise<TableData>;
 		/**
-		* Retrieve a column by the given name. You should prefer to always retrieve a new Column instance instead of
-		* caching a returned value.
+		* a column by the given name. You should prefer to always retrieve a new Column instance instead of caching a
+		* returned value.
 		* @param key - 
 		* @return {@link dh.Column}
 		*/
 		findColumn(key:string):Column;
 		/**
-		* Retrieve multiple columns specified by the given names.
+		* multiple columns specified by the given names.
 		* @param keys - 
 		* @return {@link dh.Column} array
 		*/
 		findColumns(keys:string[]):Column[];
-		isBlinkTable():boolean;
-		/**
-		* If .hasInputTable is true, you may call this method to gain access to an InputTable object which can be used to
-		* mutate the data within the table. If the table is not an Input Table, the promise will be immediately rejected.
-		* @return Promise of dh.InputTable
-		*/
-		inputTable():Promise<InputTable>;
 		/**
-		* Indicates that this Table instance will no longer be used, and its connection to the server can be cleaned up.
+		* Indicates that the table will no longer be used, and resources used to provide it can be freed up on the server.
 		*/
 		close():void;
-		getAttributes():string[];
-		/**
-		* null if no property exists, a string if it is an easily serializable property, or a ```Promise
-		* &lt;Table&gt;``` that will either resolve with a table or error out if the object can't be passed to JS.
-		* @param attributeName - 
-		* @return Object
-		*/
-		getAttribute(attributeName:string):unknown|undefined|null;
+		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
+		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
+		nextEvent<T>(eventName:string, timeoutInMillis:number):Promise<CustomEvent<T>>;
+		hasListeners(name:string):boolean;
 		/**
 		* Replace the currently set sort on this table. Returns the previously set value. Note that the sort property will
 		* immediately return the new value, but you may receive update events using the old sort before the new sort is
@@ -834,6 +594,13 @@ export namespace dh {
 		*/
 		applySort(sort:Sort[]):Array<Sort>;
 		/**
+		* Replace the current custom columns with a new set. These columns can be used when adding new filter and sort
+		* operations to the table, as long as they are present.
+		* @param customColumns - 
+		* @return 
+		*/
+		applyCustomColumns(customColumns:Array<string|CustomColumn>):Array<CustomColumn>;
+		/**
 		* Replace the currently set filters on the table. Returns the previously set value. Note that the filter property
 		* will immediately return the new value, but you may receive update events using the old filter before the new one
 		* is applied, and the <b>filterchanged</b> event fires. Reusing existing, applied filters may enable this to
@@ -844,163 +611,41 @@ export namespace dh {
 		*/
 		applyFilter(filter:FilterCondition[]):Array<FilterCondition>;
 		/**
-		* used when adding new filter and sort operations to the table, as long as they are present.
-		* @param customColumns - 
-		* @return {@link dh.CustomColumn} array
+		* An ordered list of Filters to apply to the table. To update, call applyFilter(). Note that this getter will
+		* return the new value immediately, even though it may take a little time to update on the server. You may listen
+		* for the <b>filterchanged</b> event to know when to update the UI.
+		* @return {@link dh.FilterCondition} array
 		*/
-		applyCustomColumns(customColumns:Array<string|CustomColumn>):Array<CustomColumn>;
+		get filter():Array<FilterCondition>;
 		/**
-		* If the columns parameter is not provided, all columns will be used. If the updateIntervalMs parameter is not
-		* provided, a default of one second will be used. Until this is called, no data will be available. Invoking this
-		* will result in events to be fired once data becomes available, starting with an `updated` event and a
-		* <b>rowadded</b> event per row in that range. The returned object allows the viewport to be closed when no longer
-		* needed.
-		* @param firstRow - 
-		* @param lastRow - 
-		* @param columns - 
-		* @param updateIntervalMs - 
-		* @return {@link dh.TableViewportSubscription}
-		*/
-		setViewport(firstRow:number, lastRow:number, columns?:Array<Column>|undefined|null, updateIntervalMs?:number|undefined|null):TableViewportSubscription;
-		/**
-		* Gets the currently visible viewport. If the current set of operations has not yet resulted in data, it will not
-		* resolve until that data is ready. If this table is closed before the promise resolves, it will be rejected - to
-		* separate the lifespan of this promise from the table itself, call
-		* {@link TableViewportSubscription.getViewportData} on the result from {@link Table.setViewport}.
-		* @return Promise of {@link dh.TableData}
-		*/
-		getViewportData():Promise<TableData>;
-		/**
-		* Creates a subscription to the specified columns, across all rows in the table. The optional parameter
-		* updateIntervalMs may be specified to indicate how often the server should send updates, defaulting to one second
-		* if omitted. Useful for charts or taking a snapshot of the table atomically. The initial snapshot will arrive in a
-		* single event, but later changes will be sent as updates. However, this may still be very expensive to run from a
-		* browser for very large tables. Each call to subscribe creates a new subscription, which must have <b>close()</b>
-		* called on it to stop it, and all events are fired from the TableSubscription instance.
-		* @param columns - 
-		* @param updateIntervalMs - 
-		* @return {@link dh.TableSubscription}
-		*/
-		subscribe(columns:Array<Column>, updateIntervalMs?:number):TableSubscription;
-		/**
-		* a new table containing the distinct tuples of values from the given columns that are present in the original
-		* table. This table can be manipulated as any other table. Sorting is often desired as the default sort is the
-		* order of appearance of values from the original table.
-		* @param columns - 
-		* @return Promise of dh.Table
-		*/
-		selectDistinct(columns:Column[]):Promise<Table>;
-		/**
-		* Creates a new copy of this table, so it can be sorted and filtered separately, and maintain a different viewport.
-		* @return Promise of dh.Table
-		*/
-		copy():Promise<Table>;
-		/**
-		* a promise that will resolve to a Totals Table of this table. This table will obey the configurations provided as
-		* a parameter, or will use the table's default if no parameter is provided, and be updated once per second as
-		* necessary. Note that multiple calls to this method will each produce a new TotalsTable which must have close()
-		* called on it when not in use.
-		* @param config - 
-		* @return Promise of dh.TotalsTable
-		*/
-		getTotalsTable(config?:TotalsTableConfig|undefined|null):Promise<TotalsTable>;
-		/**
-		* a promise that will resolve to a Totals Table of this table, ignoring any filters. See <b>getTotalsTable()</b>
-		* above for more specifics.
-		* @param config - 
-		* @return promise of dh.TotalsTable
-		*/
-		getGrandTotalsTable(config?:TotalsTableConfig|undefined|null):Promise<TotalsTable>;
-		/**
-		* a promise that will resolve to a new roll-up <b>TreeTable</b> of this table. Multiple calls to this method will
-		* each produce a new <b>TreeTable</b> which must have close() called on it when not in use.
-		* @param configObject - 
-		* @return Promise of dh.TreeTable
-		*/
-		rollup(configObject:RollupConfig):Promise<TreeTable>;
-		/**
-		* a promise that will resolve to a new `TreeTable` of this table. Multiple calls to this method will each produce a
-		* new `TreeTable` which must have close() called on it when not in use.
-		* @param configObject - 
-		* @return Promise dh.TreeTable
-		*/
-		treeTable(configObject:TreeTableConfig):Promise<TreeTable>;
-		/**
-		* a "frozen" version of this table (a server-side snapshot of the entire source table). Viewports on the frozen
-		* table will not update. This does not change the original table, and the new table will not have any of the client
-		* side sorts/filters/columns. New client side sorts/filters/columns can be added to the frozen copy.
-		* @return Promise of dh.Table
-		*/
-		freeze():Promise<Table>;
-		snapshot(baseTable:Table, doInitialSnapshot?:boolean, stampColumns?:string[]):Promise<Table>;
-		/**
-		* 
-		* @inheritDoc
-		* @deprecated
-		*/
-		join(joinType:string, rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, asOfMatchRule?:string|undefined|null):Promise<Table>;
-		asOfJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, asOfMatchRule?:string|undefined|null):Promise<Table>;
-		crossJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, reserveBits?:number|undefined|null):Promise<Table>;
-		exactJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>):Promise<Table>;
-		naturalJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>):Promise<Table>;
-		byExternal(keys:object, dropKeys?:boolean):Promise<PartitionedTable>;
-		/**
-		* Creates a new PartitionedTable from the contents of the current table, partitioning data based on the specified
-		* keys.
-		* @param keys - 
-		* @param dropKeys - 
-		* @return Promise dh.PartitionedTable
-		*/
-		partitionBy(keys:object, dropKeys?:boolean):Promise<PartitionedTable>;
-		/**
-		* a promise that will resolve to ColumnStatistics for the column of this table.
-		* @param column - 
-		* @return Promise of dh.ColumnStatistics
-		*/
-		getColumnStatistics(column:Column):Promise<ColumnStatistics>;
-		/**
-		* Seek the row matching the data provided
-		* @param startingRow - Row to start the seek from
-		* @param column - Column to seek for value on
-		* @param valueType - Type of value provided
-		* @param seekValue - Value to seek
-		* @param insensitive - Optional value to flag a search as case-insensitive. Defaults to `false`.
-		* @param contains - Optional value to have the seek value do a contains search instead of exact equality. Defaults to
-		*        `false`.
-		* @param isBackwards - Optional value to seek backwards through the table instead of forwards. Defaults to `false`.
-		* @return A promise that resolves to the row value found.
+		* True if this table has been closed.
+		* @return boolean
 		*/
-		seekRow(startingRow:number, column:Column, valueType:ValueTypeType, seekValue:any, insensitive?:boolean|undefined|null, contains?:boolean|undefined|null, isBackwards?:boolean|undefined|null):Promise<number>;
-		toString():string;
+		get isClosed():boolean;
 		/**
-		* True if this table represents a user Input Table (created by InputTable.newInputTable). When true, you may call
-		* .inputTable() to add or remove data from the underlying table.
-		* @return boolean
+		* The total number of rows in this table. This may change as the base table's configuration, filter, or contents
+		* change.
+		* @return double
 		*/
-		get hasInputTable():boolean;
+		get size():number;
 		/**
-		* The columns that are present on this table. This is always all possible columns. If you specify fewer columns in
-		* .setViewport(), you will get only those columns in your ViewportData. <b>Number size</b> The total count of rows
-		* in the table. The size can and will change; see the <b>sizechanged</b> event for details. Size will be negative
-		* in exceptional cases (eg. the table is uncoalesced, see the <b>isUncoalesced</b> property for details).
+		* The columns present on this table. Note that this may not include all columns in the parent table, and in cases
+		* where a given column has more than one aggregation applied, the column name will have a suffix indicating the
+		* aggregation used. This suffixed name will be of the form <b>columnName + '__' + aggregationName</b>.
 		* @return {@link dh.Column} array
 		*/
 		get columns():Array<Column>;
-		/**
-		* The default configuration to be used when building a <b>TotalsTable</b> for this table.
-		* @return dh.TotalsTableConfig
-		*/
 		get totalsTableConfig():TotalsTableConfig;
 		/**
-		* An ordered list of Sorts to apply to the table. To update, call <b>applySort()</b>. Note that this getter will
-		* return the new value immediately, even though it may take a little time to update on the server. You may listen
-		* for the <b>sortchanged</b> event to know when to update the UI.
+		* An ordered list of Sorts to apply to the table. To update, call applySort(). Note that this getter will return
+		* the new value immediately, even though it may take a little time to update on the server. You may listen for the
+		* <b>sortchanged</b> event to know when to update the UI.
 		* @return {@link dh.Sort} array
 		*/
 		get sort():Array<Sort>;
 		/**
-		* An ordered list of custom column formulas to add to the table, either adding new columns or replacing existing
-		* ones. To update, call <b>applyCustomColumns()</b>.
+		* Read-only. An ordered list of custom column formulas to add to the table, either adding new columns or replacing
+		* existing ones. To update, call <b>applyCustomColumns()</b>.
 		* @return {@link dh.CustomColumn} array
 		*/
 		get customColumns():Array<CustomColumn>;
@@ -1010,66 +655,22 @@ export namespace dh {
 		* @return boolean
 		*/
 		get isRefreshing():boolean;
-		/**
-		* An ordered list of Filters to apply to the table. To update, call applyFilter(). Note that this getter will
-		* return the new value immediately, even though it may take a little time to update on the server. You may listen
-		* for the <b>filterchanged</b> event to know when to update the UI.
-		* @return {@link dh.FilterCondition} array
-		*/
-		get filter():Array<FilterCondition>;
-		/**
-		* The total count of the rows in the table, excluding any filters. Unlike <b>size</b>, changes to this value will
-		* not result in any event. <b>Sort[] sort</b> an ordered list of Sorts to apply to the table. To update, call
-		* applySort(). Note that this getter will return the new value immediately, even though it may take a little time
-		* to update on the server. You may listen for the <b>sortchanged</b> event to know when to update the UI.
-		* @return double
-		*/
-		get totalSize():number;
-		/**
-		* The total count of rows in the table. The size can and will change; see the <b>sizechanged</b> event for details.
-		* Size will be negative in exceptional cases (e.g., the table is uncoalesced; see the <b>isUncoalesced</b>
-		* property). for details).
-		* @return double
-		*/
-		get size():number;
-		/**
-		* True if this table has been closed.
-		* @return boolean
-		*/
-		get isClosed():boolean;
-		/**
-		* Read-only. True if this table is uncoalesced. Set a viewport or filter on the partition columns to coalesce the
-		* table. Check the <b>isPartitionColumn</b> property on the table columns to retrieve the partition columns. Size
-		* will be unavailable until table is coalesced.
-		* @return boolean
-		*/
-		get isUncoalesced():boolean;
-		/**
-		* Listen for events on this object.
-		* @param name - the name of the event to listen for
-		* @param callback - a function to call when the event occurs
-		* @return Returns a cleanup function.
-		* @typeParam T - the type of the data that the event will provide
-		*/
-		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
-		hasListeners(name:string):boolean;
-		/**
-		* Removes an event listener added to this table.
-		* @param name - 
-		* @param callback - 
-		* @return 
-		* @typeParam T - 
-		*/
-		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
-		/**
-		* a Sort than can be used to reverse a table. This can be passed into n array in applySort. Note that Tree Tables
-		* do not support reverse.
-		* @return {@link dh.Sort}
-		*/
-		static reverse():Sort;
 	}
-
+	export interface TreeViewportData extends TableData {
+		get offset():number;
+		get columns():Array<Column>;
+		get rows():Array<TreeRow>;
+	}
+	/**
+	* Wrap LocalDate values for use in JS. Provides text formatting for display and access to the underlying value.
+	*/
+	export interface LocalDateWrapper {
+		valueOf():string;
+		getYear():number;
+		getMonthValue():number;
+		getDayOfMonth():number;
+		toString():string;
+	}
 
 	/**
 	* Represents a set of Tables each corresponding to some key. The keys are available locally, but a call must be made to
@@ -1306,15 +907,6 @@ export namespace dh {
 		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
 	}
 
-	export class QueryInfo {
-		static readonly EVENT_TABLE_OPENED:string;
-		static readonly EVENT_DISCONNECT:string;
-		static readonly EVENT_RECONNECT:string;
-		static readonly EVENT_CONNECT:string;
-
-		protected constructor();
-	}
-
 	/**
 	* Configuration object for running Table.treeTable to produce a hierarchical view of a given "flat" table.
 	*
@@ -1339,6 +931,18 @@ export namespace dh {
 		constructor();
 	}
 
+	/**
+	* Wrap BigInteger values for use in JS. Provides text formatting for display and access to the underlying value.
+	*/
+	export class BigIntegerWrapper {
+		protected constructor();
+
+		static ofString(str:string):BigIntegerWrapper;
+		asNumber():number;
+		valueOf():string;
+		toString():string;
+	}
+
 	/**
 	* Presently optional and not used by the server, this allows the client to specify some authentication details. String
 	* authToken <i>- base 64 encoded auth token. String serviceId -</i> The service ID to use for the connection.
@@ -1350,104 +954,178 @@ export namespace dh {
 	}
 
 	/**
-	* Describes a filter which can be applied to a table. Replacing these instances may be more expensive than reusing
-	* them. These instances are immutable - all operations that compose them to build bigger expressions return a new
+	* Describes data that can be filtered, either a column reference or a literal value. Used this way, the type of a value
+	* can be specified so that values which are ambiguous or not well supported in JS will not be confused with Strings or
+	* imprecise numbers (e.g., nanosecond-precision date values). Additionally, once wrapped in this way, methods can be
+	* called on these value literal instances. These instances are immutable - any method called on them returns a new
 	* instance.
 	*/
-	export class FilterCondition {
+	export class FilterValue {
 		protected constructor();
 
 		/**
-		* the opposite of this condition
-		* @return FilterCondition
+		* Constructs a number for the filter API from the given parameter. Can also be used on the values returned from
+		* {@link TableData.get} for DateTime values. To create
+		* a filter with a date, use <b>dh.DateWrapper.ofJsDate</b> or
+		* {@link i18n.DateTimeFormat.parse}. To create a filter with a
+		* 64-bit long integer, use {@link LongWrapper.ofString}.
+		* @param input - the number to wrap as a FilterValue
+		* @return an immutable FilterValue that can be built into a filter
 		*/
-		not():FilterCondition;
+		static ofNumber(input:LongWrapper|number):FilterValue;
 		/**
-		* a condition representing the current condition logically ANDed with the other parameters
-		* @param filters - 
-		* @return FilterCondition
+		* a filter condition checking if the current value is equal to the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		and(...filters:FilterCondition[]):FilterCondition;
+		eq(term:FilterValue):FilterCondition;
 		/**
-		* a condition representing the current condition logically ORed with the other parameters
-		* @param filters - 
-		* @return FilterCondition.
+		* a filter condition checking if the current value is equal to the given parameter, ignoring differences of upper
+		* vs lower case
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		or(...filters:FilterCondition[]):FilterCondition;
+		eqIgnoreCase(term:FilterValue):FilterCondition;
 		/**
-		* a string suitable for debugging showing the details of this condition.
-		* @return String.
+		* a filter condition checking if the current value is not equal to the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		toString():string;
-		get columns():Array<Column>;
+		notEq(term:FilterValue):FilterCondition;
 		/**
-		* a filter condition invoking a static function with the given parameters. Currently supported Deephaven static
-		* functions:
+		* a filter condition checking if the current value is not equal to the given parameter, ignoring differences of
+		* upper vs lower case
+		* @param term - 
+		* @return {@link dh.FilterCondition}
+		*/
+		notEqIgnoreCase(term:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the current value is greater than the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
+		*/
+		greaterThan(term:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the current value is less than the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
+		*/
+		lessThan(term:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the current value is greater than or equal to the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
+		*/
+		greaterThanOrEqualTo(term:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the current value is less than or equal to the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
+		*/
+		lessThanOrEqualTo(term:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the current value is in the given set of values
+		* @param terms - 
+		* @return {@link dh.FilterCondition}
+		*/
+		in(terms:FilterValue[]):FilterCondition;
+		/**
+		* a filter condition checking if the current value is in the given set of values, ignoring differences of upper vs
+		* lower case
+		* @param terms - 
+		* @return {@link dh.FilterCondition}
+		*/
+		inIgnoreCase(terms:FilterValue[]):FilterCondition;
+		/**
+		* a filter condition checking that the current value is not in the given set of values
+		* @param terms - 
+		* @return {@link dh.FilterCondition}
+		*/
+		notIn(terms:FilterValue[]):FilterCondition;
+		/**
+		* a filter condition checking that the current value is not in the given set of values, ignoring differences of
+		* upper vs lower case
+		* @param terms - 
+		* @return {@link dh.FilterCondition}
+		*/
+		notInIgnoreCase(terms:FilterValue[]):FilterCondition;
+		/**
+		* a filter condition checking if the given value contains the given string value
+		* @param term - 
+		* @return {@link dh.FilterCondition}
+		*/
+		contains(term:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the given value contains the given string value, ignoring differences of upper vs
+		* lower case
+		* @param term - 
+		* @return {@link dh.FilterCondition}
+		*/
+		containsIgnoreCase(term:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the given value matches the provided regular expressions string. Regex patterns
+		* use Java regex syntax
+		* @param pattern - 
+		* @return {@link dh.FilterCondition}
+		*/
+		matches(pattern:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the given value matches the provided regular expressions string, ignoring
+		* differences of upper vs lower case. Regex patterns use Java regex syntax
+		* @param pattern - 
+		* @return {@link dh.FilterCondition}
+		*/
+		matchesIgnoreCase(pattern:FilterValue):FilterCondition;
+		/**
+		* a filter condition checking if the current value is a true boolean
+		* @return {@link dh.FilterCondition}
+		*/
+		isTrue():FilterCondition;
+		/**
+		* a filter condition checking if the current value is a false boolean
+		* @return {@link dh.FilterCondition}
+		*/
+		isFalse():FilterCondition;
+		/**
+		* a filter condition checking if the current value is a null value
+		* @return {@link dh.FilterCondition}
+		*/
+		isNull():FilterCondition;
+		/**
+		* a filter condition invoking the given method on the current value, with the given parameters. Currently supported
+		* functions that can be invoked on a String:
 		* <ul>
-		* <li><b>inRange</b>: Given three comparable values, returns true if the first is less than the second but greater
-		* than the third</li>
-		* <li><b>isInf</b>:Returns true if the given number is <i>infinity</i></li>
-		* <li><b>isNaN</b>:Returns true if the given number is <i>not a number</i></li>
-		* <li><b>isNormal</b>:Returns true if the given number <i>is not null</i>, <i>is not infinity</i>, and <i>is not
-		* "not a number"</i></li>
-		* <li><b>startsWith</b>:Returns true if the first string starts with the second string</li>
-		* <li><b>endsWith</b>Returns true if the first string ends with the second string</li>
-		* <li><b>matches</b>:Returns true if the first string argument matches the second string used as a Java regular
-		* expression</li>
-		* <li><b>contains</b>:Returns true if the first string argument contains the second string as a substring</li>
-		* <li><b>in</b>:Returns true if the first string argument can be found in the second array argument.
+		* <li><b>startsWith</b>: Returns true if the current string value starts with the supplied string argument</li>
+		* <li><b>endsWith</b>: Returns true if the current string value ends with the supplied string argument</li>
+		* <li><b>matches</b>: Returns true if the current string value matches the supplied string argument used as a Java
+		* regular expression</li>
+		* <li><b>contains</b>: Returns true if the current string value contains the supplied string argument
 		* <p>
-		* Note that the array can only be specified as a column reference at this time - typically the `FilterValue.in`
-		* method should be used in other cases
+		* When invoking against a constant, this should be avoided in favor of FilterValue.contains
 		* </p>
 		* </li>
 		* </ul>
-		* @param function - 
+		* @param method - 
 		* @param args - 
-		* @return dh.FilterCondition
-		*/
-		static invoke(func:string, ...args:FilterValue[]):FilterCondition;
-		/**
-		* a filter condition which will check if the given value can be found in any supported column on whatever table
-		* this FilterCondition is passed to. This FilterCondition is somewhat unique in that it need not be given a column
-		* instance, but will adapt to any table. On numeric columns, with a value passed in which can be parsed as a
-		* number, the column will be filtered to numbers which equal, or can be "rounded" effectively to this number. On
-		* String columns, the given value will match any column which contains this string in a case-insensitive search. An
-		* optional second argument can be passed, an array of `FilterValue` from the columns to limit this search to (see
-		* {@link dh.Column.filter}).
-		* @param value - 
-		* @param columns - 
-		* @return dh.FilterCondition
+		* @return 
 		*/
-		static search(value:FilterValue, columns?:FilterValue[]):FilterCondition;
-	}
-
-	/**
-	* This class allows iteration over non-contiguous indexes. In the future, this will support the EcmaScript 2015
-	* Iteration protocol, but for now has one method which returns an iterator, and also supports querying the size.
-	* Additionally, we may add support for creating RangeSet objects to better serve some use cases.
-	*/
-	export class RangeSet {
-		protected constructor();
-
-		static ofRange(first:number, last:number):RangeSet;
-		static ofItems(rows:number[]):RangeSet;
-		static ofRanges(ranges:RangeSet[]):RangeSet;
-		static ofSortedRanges(ranges:RangeSet[]):RangeSet;
+		invoke(method:string, ...args:FilterValue[]):FilterCondition;
+		toString():string;
 		/**
-		* a new iterator over all indexes in this collection.
-		* @return Iterator of {@link dh.LongWrapper}
+		* Constructs a string for the filter API from the given parameter.
+		* @param input - 
+		* @return 
 		*/
-		iterator():Iterator<LongWrapper>;
+		static ofString(input:any):FilterValue;
 		/**
-		* The total count of items contained in this collection. In some cases this can be expensive to compute, and
-		* generally should not be needed except for debugging purposes, or preallocating space (i.e., do not call this
-		* property each time through a loop).
-		* @return double
+		* Constructs a boolean for the filter API from the given parameter.
+		* @param b - 
+		* @return 
 		*/
-		get size():number;
+		static ofBoolean(b:boolean):FilterValue;
 	}
 
+
 	/**
 	* Event fired when a command is issued from the client.
 	*/
@@ -1472,6 +1150,15 @@ export namespace dh {
 		protected constructor();
 	}
 
+	export class QueryInfo {
+		static readonly EVENT_TABLE_OPENED:string;
+		static readonly EVENT_DISCONNECT:string;
+		static readonly EVENT_RECONNECT:string;
+		static readonly EVENT_CONNECT:string;
+
+		protected constructor();
+	}
+
 	/**
 	* A Widget represents a server side object that sends one or more responses to the client. The client can then
 	* interpret these responses to see what to render, or how to respond.
@@ -1586,69 +1273,366 @@ export namespace dh {
 		*/
 		desc():Sort;
 		/**
-		* Builds a Sort instance which takes the absolute value before applying order.
-		* @return {@link dh.Sort}
+		* Builds a Sort instance which takes the absolute value before applying order.
+		* @return {@link dh.Sort}
+		*/
+		abs():Sort;
+		toString():string;
+		/**
+		* True if the absolute value of the column should be used when sorting; defaults to false.
+		* @return boolean
+		*/
+		get isAbs():boolean;
+		/**
+		* The column which is sorted.
+		* @return {@link dh.Column}
+		*/
+		get column():Column;
+		/**
+		* The direction of this sort, either <b>ASC</b>, <b>DESC</b>, or <b>REVERSE</b>.
+		* @return String
+		*/
+		get direction():string;
+	}
+
+	export class CustomColumn {
+		static readonly TYPE_FORMAT_COLOR:string;
+		static readonly TYPE_FORMAT_NUMBER:string;
+		static readonly TYPE_FORMAT_DATE:string;
+		static readonly TYPE_NEW:string;
+
+		protected constructor();
+
+		valueOf():string;
+		toString():string;
+		/**
+		* The expression to evaluate this custom column.
+		* @return String
+		*/
+		get expression():string;
+		/**
+		* The name of the column to use.
+		* @return String
+		*/
+		get name():string;
+		/**
+		* Type of custom column. One of
+		*
+		* <ul>
+		* <li>FORMAT_COLOR</li>
+		* <li>FORMAT_NUMBER</li>
+		* <li>FORMAT_DATE</li>
+		* <li>NEW</li>
+		* </ul>
+		* @return String
+		*/
+		get type():string;
+	}
+
+	/**
+	* Provides access to data in a table. Note that several methods present their response through Promises. This allows
+	* the client to both avoid actually connecting to the server until necessary, and also will permit some changes not to
+	* inform the UI right away that they have taken place.
+	*/
+	export class Table implements JoinableTable, HasEventHandling {
+		readonly description?:string|null;
+		readonly pluginName?:string|null;
+		readonly layoutHints?:null|LayoutHints;
+		static readonly EVENT_SIZECHANGED:string;
+		static readonly EVENT_UPDATED:string;
+		static readonly EVENT_ROWADDED:string;
+		static readonly EVENT_ROWREMOVED:string;
+		static readonly EVENT_ROWUPDATED:string;
+		static readonly EVENT_SORTCHANGED:string;
+		static readonly EVENT_FILTERCHANGED:string;
+		static readonly EVENT_CUSTOMCOLUMNSCHANGED:string;
+		static readonly EVENT_DISCONNECT:string;
+		static readonly EVENT_RECONNECT:string;
+		static readonly EVENT_RECONNECTFAILED:string;
+		static readonly EVENT_REQUEST_FAILED:string;
+		static readonly EVENT_REQUEST_SUCCEEDED:string;
+		static readonly SIZE_UNCOALESCED:number;
+
+		protected constructor();
+
+		batch(userCode:(arg0:unknown)=>void):Promise<Table>;
+		/**
+		* Retrieve a column by the given name. You should prefer to always retrieve a new Column instance instead of
+		* caching a returned value.
+		* @param key - 
+		* @return {@link dh.Column}
+		*/
+		findColumn(key:string):Column;
+		/**
+		* Retrieve multiple columns specified by the given names.
+		* @param keys - 
+		* @return {@link dh.Column} array
+		*/
+		findColumns(keys:string[]):Column[];
+		isBlinkTable():boolean;
+		/**
+		* If .hasInputTable is true, you may call this method to gain access to an InputTable object which can be used to
+		* mutate the data within the table. If the table is not an Input Table, the promise will be immediately rejected.
+		* @return Promise of dh.InputTable
+		*/
+		inputTable():Promise<InputTable>;
+		/**
+		* Indicates that this Table instance will no longer be used, and its connection to the server can be cleaned up.
+		*/
+		close():void;
+		getAttributes():string[];
+		/**
+		* null if no property exists, a string if it is an easily serializable property, or a ```Promise
+		* &lt;Table&gt;``` that will either resolve with a table or error out if the object can't be passed to JS.
+		* @param attributeName - 
+		* @return Object
+		*/
+		getAttribute(attributeName:string):unknown|undefined|null;
+		/**
+		* Replace the currently set sort on this table. Returns the previously set value. Note that the sort property will
+		* immediately return the new value, but you may receive update events using the old sort before the new sort is
+		* applied, and the <b>sortchanged</b> event fires. Reusing existing, applied sorts may enable this to perform
+		* better on the server. The <b>updated</b> event will also fire, but <b>rowadded</b> and <b>rowremoved</b> will
+		* not.
+		* @param sort - 
+		* @return {@link dh.Sort} array
+		*/
+		applySort(sort:Sort[]):Array<Sort>;
+		/**
+		* Replace the currently set filters on the table. Returns the previously set value. Note that the filter property
+		* will immediately return the new value, but you may receive update events using the old filter before the new one
+		* is applied, and the <b>filterchanged</b> event fires. Reusing existing, applied filters may enable this to
+		* perform better on the server. The <b>updated</b> event will also fire, but <b>rowadded</b> and <b>rowremoved</b>
+		* will not.
+		* @param filter - 
+		* @return {@link dh.FilterCondition} array
+		*/
+		applyFilter(filter:FilterCondition[]):Array<FilterCondition>;
+		/**
+		* used when adding new filter and sort operations to the table, as long as they are present.
+		* @param customColumns - 
+		* @return {@link dh.CustomColumn} array
+		*/
+		applyCustomColumns(customColumns:Array<string|CustomColumn>):Array<CustomColumn>;
+		/**
+		* If the columns parameter is not provided, all columns will be used. If the updateIntervalMs parameter is not
+		* provided, a default of one second will be used. Until this is called, no data will be available. Invoking this
+		* will result in events to be fired once data becomes available, starting with an `updated` event and a
+		* <b>rowadded</b> event per row in that range. The returned object allows the viewport to be closed when no longer
+		* needed.
+		* @param firstRow - 
+		* @param lastRow - 
+		* @param columns - 
+		* @param updateIntervalMs - 
+		* @return {@link dh.TableViewportSubscription}
+		*/
+		setViewport(firstRow:number, lastRow:number, columns?:Array<Column>|undefined|null, updateIntervalMs?:number|undefined|null):TableViewportSubscription;
+		/**
+		* Gets the currently visible viewport. If the current set of operations has not yet resulted in data, it will not
+		* resolve until that data is ready. If this table is closed before the promise resolves, it will be rejected - to
+		* separate the lifespan of this promise from the table itself, call
+		* {@link TableViewportSubscription.getViewportData} on the result from {@link Table.setViewport}.
+		* @return Promise of {@link dh.TableData}
+		*/
+		getViewportData():Promise<TableData>;
+		/**
+		* Creates a subscription to the specified columns, across all rows in the table. The optional parameter
+		* updateIntervalMs may be specified to indicate how often the server should send updates, defaulting to one second
+		* if omitted. Useful for charts or taking a snapshot of the table atomically. The initial snapshot will arrive in a
+		* single event, but later changes will be sent as updates. However, this may still be very expensive to run from a
+		* browser for very large tables. Each call to subscribe creates a new subscription, which must have <b>close()</b>
+		* called on it to stop it, and all events are fired from the TableSubscription instance.
+		* @param columns - 
+		* @param updateIntervalMs - 
+		* @return {@link dh.TableSubscription}
+		*/
+		subscribe(columns:Array<Column>, updateIntervalMs?:number):TableSubscription;
+		/**
+		* a new table containing the distinct tuples of values from the given columns that are present in the original
+		* table. This table can be manipulated as any other table. Sorting is often desired as the default sort is the
+		* order of appearance of values from the original table.
+		* @param columns - 
+		* @return Promise of dh.Table
+		*/
+		selectDistinct(columns:Column[]):Promise<Table>;
+		/**
+		* Creates a new copy of this table, so it can be sorted and filtered separately, and maintain a different viewport.
+		* @return Promise of dh.Table
+		*/
+		copy():Promise<Table>;
+		/**
+		* a promise that will resolve to a Totals Table of this table. This table will obey the configurations provided as
+		* a parameter, or will use the table's default if no parameter is provided, and be updated once per second as
+		* necessary. Note that multiple calls to this method will each produce a new TotalsTable which must have close()
+		* called on it when not in use.
+		* @param config - 
+		* @return Promise of dh.TotalsTable
+		*/
+		getTotalsTable(config?:TotalsTableConfig|undefined|null):Promise<TotalsTable>;
+		/**
+		* a promise that will resolve to a Totals Table of this table, ignoring any filters. See <b>getTotalsTable()</b>
+		* above for more specifics.
+		* @param config - 
+		* @return promise of dh.TotalsTable
+		*/
+		getGrandTotalsTable(config?:TotalsTableConfig|undefined|null):Promise<TotalsTable>;
+		/**
+		* a promise that will resolve to a new roll-up <b>TreeTable</b> of this table. Multiple calls to this method will
+		* each produce a new <b>TreeTable</b> which must have close() called on it when not in use.
+		* @param configObject - 
+		* @return Promise of dh.TreeTable
+		*/
+		rollup(configObject:RollupConfig):Promise<TreeTable>;
+		/**
+		* a promise that will resolve to a new `TreeTable` of this table. Multiple calls to this method will each produce a
+		* new `TreeTable` which must have close() called on it when not in use.
+		* @param configObject - 
+		* @return Promise dh.TreeTable
+		*/
+		treeTable(configObject:TreeTableConfig):Promise<TreeTable>;
+		/**
+		* a "frozen" version of this table (a server-side snapshot of the entire source table). Viewports on the frozen
+		* table will not update. This does not change the original table, and the new table will not have any of the client
+		* side sorts/filters/columns. New client side sorts/filters/columns can be added to the frozen copy.
+		* @return Promise of dh.Table
+		*/
+		freeze():Promise<Table>;
+		snapshot(baseTable:Table, doInitialSnapshot?:boolean, stampColumns?:string[]):Promise<Table>;
+		/**
+		* 
+		* @inheritDoc
+		* @deprecated
+		*/
+		join(joinType:string, rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, asOfMatchRule?:string|undefined|null):Promise<Table>;
+		asOfJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, asOfMatchRule?:string|undefined|null):Promise<Table>;
+		crossJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, reserveBits?:number|undefined|null):Promise<Table>;
+		exactJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>):Promise<Table>;
+		naturalJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>):Promise<Table>;
+		byExternal(keys:object, dropKeys?:boolean):Promise<PartitionedTable>;
+		/**
+		* Creates a new PartitionedTable from the contents of the current table, partitioning data based on the specified
+		* keys.
+		* @param keys - 
+		* @param dropKeys - 
+		* @return Promise dh.PartitionedTable
+		*/
+		partitionBy(keys:object, dropKeys?:boolean):Promise<PartitionedTable>;
+		/**
+		* a promise that will resolve to ColumnStatistics for the column of this table.
+		* @param column - 
+		* @return Promise of dh.ColumnStatistics
+		*/
+		getColumnStatistics(column:Column):Promise<ColumnStatistics>;
+		/**
+		* Seek the row matching the data provided
+		* @param startingRow - Row to start the seek from
+		* @param column - Column to seek for value on
+		* @param valueType - Type of value provided
+		* @param seekValue - Value to seek
+		* @param insensitive - Optional value to flag a search as case-insensitive. Defaults to `false`.
+		* @param contains - Optional value to have the seek value do a contains search instead of exact equality. Defaults to
+		*        `false`.
+		* @param isBackwards - Optional value to seek backwards through the table instead of forwards. Defaults to `false`.
+		* @return A promise that resolves to the row value found.
+		*/
+		seekRow(startingRow:number, column:Column, valueType:ValueTypeType, seekValue:any, insensitive?:boolean|undefined|null, contains?:boolean|undefined|null, isBackwards?:boolean|undefined|null):Promise<number>;
+		toString():string;
+		/**
+		* True if this table represents a user Input Table (created by InputTable.newInputTable). When true, you may call
+		* .inputTable() to add or remove data from the underlying table.
+		* @return boolean
+		*/
+		get hasInputTable():boolean;
+		/**
+		* The columns that are present on this table. This is always all possible columns. If you specify fewer columns in
+		* .setViewport(), you will get only those columns in your ViewportData. <b>Number size</b> The total count of rows
+		* in the table. The size can and will change; see the <b>sizechanged</b> event for details. Size will be negative
+		* in exceptional cases (eg. the table is uncoalesced, see the <b>isUncoalesced</b> property for details).
+		* @return {@link dh.Column} array
+		*/
+		get columns():Array<Column>;
+		/**
+		* The default configuration to be used when building a <b>TotalsTable</b> for this table.
+		* @return dh.TotalsTableConfig
+		*/
+		get totalsTableConfig():TotalsTableConfig;
+		/**
+		* An ordered list of Sorts to apply to the table. To update, call <b>applySort()</b>. Note that this getter will
+		* return the new value immediately, even though it may take a little time to update on the server. You may listen
+		* for the <b>sortchanged</b> event to know when to update the UI.
+		* @return {@link dh.Sort} array
+		*/
+		get sort():Array<Sort>;
+		/**
+		* An ordered list of custom column formulas to add to the table, either adding new columns or replacing existing
+		* ones. To update, call <b>applyCustomColumns()</b>.
+		* @return {@link dh.CustomColumn} array
+		*/
+		get customColumns():Array<CustomColumn>;
+		/**
+		* True if this table may receive updates from the server, including size changed events, updated events after
+		* initial snapshot.
+		* @return boolean
+		*/
+		get isRefreshing():boolean;
+		/**
+		* An ordered list of Filters to apply to the table. To update, call applyFilter(). Note that this getter will
+		* return the new value immediately, even though it may take a little time to update on the server. You may listen
+		* for the <b>filterchanged</b> event to know when to update the UI.
+		* @return {@link dh.FilterCondition} array
+		*/
+		get filter():Array<FilterCondition>;
+		/**
+		* The total count of the rows in the table, excluding any filters. Unlike <b>size</b>, changes to this value will
+		* not result in any event. <b>Sort[] sort</b> an ordered list of Sorts to apply to the table. To update, call
+		* applySort(). Note that this getter will return the new value immediately, even though it may take a little time
+		* to update on the server. You may listen for the <b>sortchanged</b> event to know when to update the UI.
+		* @return double
 		*/
-		abs():Sort;
-		toString():string;
+		get totalSize():number;
 		/**
-		* True if the absolute value of the column should be used when sorting; defaults to false.
-		* @return boolean
+		* The total count of rows in the table. The size can and will change; see the <b>sizechanged</b> event for details.
+		* Size will be negative in exceptional cases (e.g., the table is uncoalesced; see the <b>isUncoalesced</b>
+		* property). for details).
+		* @return double
 		*/
-		get isAbs():boolean;
+		get size():number;
 		/**
-		* The column which is sorted.
-		* @return {@link dh.Column}
+		* True if this table has been closed.
+		* @return boolean
 		*/
-		get column():Column;
+		get isClosed():boolean;
 		/**
-		* The direction of this sort, either <b>ASC</b>, <b>DESC</b>, or <b>REVERSE</b>.
-		* @return String
+		* Read-only. True if this table is uncoalesced. Set a viewport or filter on the partition columns to coalesce the
+		* table. Check the <b>isPartitionColumn</b> property on the table columns to retrieve the partition columns. Size
+		* will be unavailable until table is coalesced.
+		* @return boolean
 		*/
-		get direction():string;
-	}
-
-	export class CustomColumn {
-		static readonly TYPE_FORMAT_COLOR:string;
-		static readonly TYPE_FORMAT_NUMBER:string;
-		static readonly TYPE_FORMAT_DATE:string;
-		static readonly TYPE_NEW:string;
-
-		protected constructor();
-
-		valueOf():string;
-		toString():string;
+		get isUncoalesced():boolean;
 		/**
-		* The expression to evaluate this custom column.
-		* @return String
+		* Listen for events on this object.
+		* @param name - the name of the event to listen for
+		* @param callback - a function to call when the event occurs
+		* @return Returns a cleanup function.
+		* @typeParam T - the type of the data that the event will provide
 		*/
-		get expression():string;
+		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
+		hasListeners(name:string):boolean;
 		/**
-		* The name of the column to use.
-		* @return String
+		* Removes an event listener added to this table.
+		* @param name - 
+		* @param callback - 
+		* @return 
+		* @typeParam T - 
 		*/
-		get name():string;
+		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
 		/**
-		* Type of custom column. One of
-		*
-		* <ul>
-		* <li>FORMAT_COLOR</li>
-		* <li>FORMAT_NUMBER</li>
-		* <li>FORMAT_DATE</li>
-		* <li>NEW</li>
-		* </ul>
-		* @return String
+		* a Sort than can be used to reverse a table. This can be passed into n array in applySort. Note that Tree Tables
+		* do not support reverse.
+		* @return {@link dh.Sort}
 		*/
-		get type():string;
-	}
-
-	export class LongWrapper {
-		protected constructor();
-
-		static ofString(str:string):LongWrapper;
-		asNumber():number;
-		valueOf():string;
-		toString():string;
+		static reverse():Sort;
 	}
 
 	export class Ide {
@@ -1785,6 +1769,14 @@ export namespace dh {
 		static createCustomColumn(name:string, expression:string):CustomColumn;
 	}
 
+	export class LoginCredentials {
+		type?:string|null;
+		username?:string|null;
+		token?:string|null;
+
+		constructor();
+	}
+
 	/**
 	* Describes a grouping and aggregations for a roll-up table. Pass to the <b>Table.rollup</b> function to create a
 	* roll-up table.
@@ -2030,236 +2022,244 @@ export namespace dh {
 	}
 
 	/**
-	* Wrap BigInteger values for use in JS. Provides text formatting for display and access to the underlying value.
+	* Deprecated for use in Deephaven Core.
+	* @deprecated
 	*/
-	export class BigIntegerWrapper {
+	export class Client {
+		static readonly EVENT_REQUEST_FAILED:string;
+		static readonly EVENT_REQUEST_STARTED:string;
+		static readonly EVENT_REQUEST_SUCCEEDED:string;
+
+		constructor();
+	}
+
+	export class LongWrapper {
 		protected constructor();
 
-		static ofString(str:string):BigIntegerWrapper;
+		static ofString(str:string):LongWrapper;
 		asNumber():number;
 		valueOf():string;
 		toString():string;
 	}
 
 	/**
-	* Represents a non-viewport subscription to a table, and all data currently known to be present in the subscribed
-	* columns. This class handles incoming snapshots and deltas, and fires events to consumers to notify of data changes.
-	*
-	* Unlike {@link dh.TableViewportSubscription}, the "original" table does not have a reference to this instance, only the
-	* "private" table instance does, since the original cannot modify the subscription, and the private instance must
-	* forward data to it.
-	*
-	* Represents a subscription to the table on the server. Changes made to the table will not be reflected here - the
-	* subscription must be closed and a new one optioned to see those changes. The event model is slightly different from
-	* viewports to make it less expensive to compute for large tables.
+	* This class allows iteration over non-contiguous indexes. In the future, this will support the EcmaScript 2015
+	* Iteration protocol, but for now has one method which returns an iterator, and also supports querying the size.
+	* Additionally, we may add support for creating RangeSet objects to better serve some use cases.
 	*/
-	export class TableSubscription implements HasEventHandling {
-		/**
-		* Indicates that some new data is available on the client, either an initial snapshot or a delta update. The
-		* <b>detail</b> field of the event will contain a TableSubscriptionEventData detailing what has changed, or
-		* allowing access to the entire range of items currently in the subscribed columns.
-		*/
-		static readonly EVENT_UPDATED:string;
-
+	export class RangeSet {
 		protected constructor();
 
+		static ofRange(first:number, last:number):RangeSet;
+		static ofItems(rows:number[]):RangeSet;
+		static ofRanges(ranges:RangeSet[]):RangeSet;
+		static ofSortedRanges(ranges:RangeSet[]):RangeSet;
 		/**
-		* Stops the subscription on the server.
+		* a new iterator over all indexes in this collection.
+		* @return Iterator of {@link dh.LongWrapper}
 		*/
-		close():void;
-		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
-		hasListeners(name:string):boolean;
-		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
+		iterator():Iterator<LongWrapper>;
 		/**
-		* The columns that were subscribed to when this subscription was created
-		* @return {@link dh.Column}
+		* The total count of items contained in this collection. In some cases this can be expensive to compute, and
+		* generally should not be needed except for debugging purposes, or preallocating space (i.e., do not call this
+		* property each time through a loop).
+		* @return double
 		*/
-		get columns():Array<Column>;
-	}
-
-	/**
-	* Deprecated for use in Deephaven Core.
-	* @deprecated
-	*/
-	export class Client {
-		static readonly EVENT_REQUEST_FAILED:string;
-		static readonly EVENT_REQUEST_STARTED:string;
-		static readonly EVENT_REQUEST_SUCCEEDED:string;
-
-		constructor();
+		get size():number;
 	}
 
 	/**
-	* Describes data that can be filtered, either a column reference or a literal value. Used this way, the type of a value
-	* can be specified so that values which are ambiguous or not well supported in JS will not be confused with Strings or
-	* imprecise numbers (e.g., nanosecond-precision date values). Additionally, once wrapped in this way, methods can be
-	* called on these value literal instances. These instances are immutable - any method called on them returns a new
+	* Describes a filter which can be applied to a table. Replacing these instances may be more expensive than reusing
+	* them. These instances are immutable - all operations that compose them to build bigger expressions return a new
 	* instance.
 	*/
-	export class FilterValue {
+	export class FilterCondition {
 		protected constructor();
 
 		/**
-		* Constructs a number for the filter API from the given parameter. Can also be used on the values returned from
-		* {@link TableData.get} for DateTime values. To create
-		* a filter with a date, use <b>dh.DateWrapper.ofJsDate</b> or
-		* {@link i18n.DateTimeFormat.parse}. To create a filter with a
-		* 64-bit long integer, use {@link LongWrapper.ofString}.
-		* @param input - the number to wrap as a FilterValue
-		* @return an immutable FilterValue that can be built into a filter
+		* the opposite of this condition
+		* @return FilterCondition
 		*/
-		static ofNumber(input:LongWrapper|number):FilterValue;
+		not():FilterCondition;
 		/**
-		* a filter condition checking if the current value is equal to the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* a condition representing the current condition logically ANDed with the other parameters
+		* @param filters - 
+		* @return FilterCondition
 		*/
-		eq(term:FilterValue):FilterCondition;
+		and(...filters:FilterCondition[]):FilterCondition;
 		/**
-		* a filter condition checking if the current value is equal to the given parameter, ignoring differences of upper
-		* vs lower case
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* a condition representing the current condition logically ORed with the other parameters
+		* @param filters - 
+		* @return FilterCondition.
 		*/
-		eqIgnoreCase(term:FilterValue):FilterCondition;
+		or(...filters:FilterCondition[]):FilterCondition;
 		/**
-		* a filter condition checking if the current value is not equal to the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* a string suitable for debugging showing the details of this condition.
+		* @return String.
 		*/
-		notEq(term:FilterValue):FilterCondition;
+		toString():string;
+		get columns():Array<Column>;
+		/**
+		* a filter condition invoking a static function with the given parameters. Currently supported Deephaven static
+		* functions:
+		* <ul>
+		* <li><b>inRange</b>: Given three comparable values, returns true if the first is less than the second but greater
+		* than the third</li>
+		* <li><b>isInf</b>:Returns true if the given number is <i>infinity</i></li>
+		* <li><b>isNaN</b>:Returns true if the given number is <i>not a number</i></li>
+		* <li><b>isNormal</b>:Returns true if the given number <i>is not null</i>, <i>is not infinity</i>, and <i>is not
+		* "not a number"</i></li>
+		* <li><b>startsWith</b>:Returns true if the first string starts with the second string</li>
+		* <li><b>endsWith</b>Returns true if the first string ends with the second string</li>
+		* <li><b>matches</b>:Returns true if the first string argument matches the second string used as a Java regular
+		* expression</li>
+		* <li><b>contains</b>:Returns true if the first string argument contains the second string as a substring</li>
+		* <li><b>in</b>:Returns true if the first string argument can be found in the second array argument.
+		* <p>
+		* Note that the array can only be specified as a column reference at this time - typically the `FilterValue.in`
+		* method should be used in other cases
+		* </p>
+		* </li>
+		* </ul>
+		* @param function - 
+		* @param args - 
+		* @return dh.FilterCondition
+		*/
+		static invoke(func:string, ...args:FilterValue[]):FilterCondition;
+		/**
+		* a filter condition which will check if the given value can be found in any supported column on whatever table
+		* this FilterCondition is passed to. This FilterCondition is somewhat unique in that it need not be given a column
+		* instance, but will adapt to any table. On numeric columns, with a value passed in which can be parsed as a
+		* number, the column will be filtered to numbers which equal, or can be "rounded" effectively to this number. On
+		* String columns, the given value will match any column which contains this string in a case-insensitive search. An
+		* optional second argument can be passed, an array of `FilterValue` from the columns to limit this search to (see
+		* {@link dh.Column.filter}).
+		* @param value - 
+		* @param columns - 
+		* @return dh.FilterCondition
+		*/
+		static search(value:FilterValue, columns?:FilterValue[]):FilterCondition;
+	}
+
+	/**
+	* Represents a non-viewport subscription to a table, and all data currently known to be present in the subscribed
+	* columns. This class handles incoming snapshots and deltas, and fires events to consumers to notify of data changes.
+	*
+	* Unlike {@link dh.TableViewportSubscription}, the "original" table does not have a reference to this instance, only the
+	* "private" table instance does, since the original cannot modify the subscription, and the private instance must
+	* forward data to it.
+	*
+	* Represents a subscription to the table on the server. Changes made to the table will not be reflected here - the
+	* subscription must be closed and a new one optioned to see those changes. The event model is slightly different from
+	* viewports to make it less expensive to compute for large tables.
+	*/
+	export class TableSubscription implements HasEventHandling {
 		/**
-		* a filter condition checking if the current value is not equal to the given parameter, ignoring differences of
-		* upper vs lower case
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* Indicates that some new data is available on the client, either an initial snapshot or a delta update. The
+		* <b>detail</b> field of the event will contain a TableSubscriptionEventData detailing what has changed, or
+		* allowing access to the entire range of items currently in the subscribed columns.
 		*/
-		notEqIgnoreCase(term:FilterValue):FilterCondition;
+		static readonly EVENT_UPDATED:string;
+
+		protected constructor();
+
 		/**
-		* a filter condition checking if the current value is greater than the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* Stops the subscription on the server.
 		*/
-		greaterThan(term:FilterValue):FilterCondition;
+		close():void;
+		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
+		hasListeners(name:string):boolean;
+		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
 		/**
-		* a filter condition checking if the current value is less than the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* The columns that were subscribed to when this subscription was created
+		* @return {@link dh.Column}
 		*/
-		lessThan(term:FilterValue):FilterCondition;
+		get columns():Array<Column>;
+	}
+
+	/**
+	* Describes how a Totals Table will be generated from its parent table. Each table has a default (which may be null)
+	* indicating how that table was configured when it was declared, and each Totals Table has a similar property
+	* describing how it was created. Both the <b>Table.getTotalsTable</b> and <b>Table.getGrandTotalsTable</b> methods take
+	* this config as an optional parameter - without it, the table's default will be used, or if null, a default instance
+	* of <b>TotalsTableConfig</b> will be supplied.
+	*
+	* This class has a no-arg constructor, allowing an instance to be made with the default values provided. However, any
+	* JS object can be passed in to the methods which accept instances of this type, provided their values adhere to the
+	* expected formats.
+	*/
+	export class TotalsTableConfig {
 		/**
-		* a filter condition checking if the current value is greater than or equal to the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		greaterThanOrEqualTo(term:FilterValue):FilterCondition;
+		static readonly COUNT:string;
 		/**
-		* a filter condition checking if the current value is less than or equal to the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		lessThanOrEqualTo(term:FilterValue):FilterCondition;
+		static readonly MIN:string;
 		/**
-		* a filter condition checking if the current value is in the given set of values
-		* @param terms - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		in(terms:FilterValue[]):FilterCondition;
+		static readonly MAX:string;
 		/**
-		* a filter condition checking if the current value is in the given set of values, ignoring differences of upper vs
-		* lower case
-		* @param terms - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		inIgnoreCase(terms:FilterValue[]):FilterCondition;
+		static readonly SUM:string;
 		/**
-		* a filter condition checking that the current value is not in the given set of values
-		* @param terms - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		notIn(terms:FilterValue[]):FilterCondition;
+		static readonly ABS_SUM:string;
 		/**
-		* a filter condition checking that the current value is not in the given set of values, ignoring differences of
-		* upper vs lower case
-		* @param terms - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		notInIgnoreCase(terms:FilterValue[]):FilterCondition;
+		static readonly VAR:string;
 		/**
-		* a filter condition checking if the given value contains the given string value
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		contains(term:FilterValue):FilterCondition;
+		static readonly AVG:string;
 		/**
-		* a filter condition checking if the given value contains the given string value, ignoring differences of upper vs
-		* lower case
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		containsIgnoreCase(term:FilterValue):FilterCondition;
+		static readonly STD:string;
 		/**
-		* a filter condition checking if the given value matches the provided regular expressions string. Regex patterns
-		* use Java regex syntax
-		* @param pattern - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		matches(pattern:FilterValue):FilterCondition;
+		static readonly FIRST:string;
 		/**
-		* a filter condition checking if the given value matches the provided regular expressions string, ignoring
-		* differences of upper vs lower case. Regex patterns use Java regex syntax
-		* @param pattern - 
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		matchesIgnoreCase(pattern:FilterValue):FilterCondition;
+		static readonly LAST:string;
 		/**
-		* a filter condition checking if the current value is a true boolean
-		* @return {@link dh.FilterCondition}
+		* @deprecated
 		*/
-		isTrue():FilterCondition;
+		static readonly SKIP:string;
 		/**
-		* a filter condition checking if the current value is a false boolean
-		* @return {@link dh.FilterCondition}
+		* Specifies if a Totals Table should be expanded by default in the UI. Defaults to false.
 		*/
-		isFalse():FilterCondition;
+		showTotalsByDefault:boolean;
 		/**
-		* a filter condition checking if the current value is a null value
-		* @return {@link dh.FilterCondition}
+		* Specifies if a Grand Totals Table should be expanded by default in the UI. Defaults to false.
 		*/
-		isNull():FilterCondition;
+		showGrandTotalsByDefault:boolean;
 		/**
-		* a filter condition invoking the given method on the current value, with the given parameters. Currently supported
-		* functions that can be invoked on a String:
-		* <ul>
-		* <li><b>startsWith</b>: Returns true if the current string value starts with the supplied string argument</li>
-		* <li><b>endsWith</b>: Returns true if the current string value ends with the supplied string argument</li>
-		* <li><b>matches</b>: Returns true if the current string value matches the supplied string argument used as a Java
-		* regular expression</li>
-		* <li><b>contains</b>: Returns true if the current string value contains the supplied string argument
-		* <p>
-		* When invoking against a constant, this should be avoided in favor of FilterValue.contains
-		* </p>
-		* </li>
-		* </ul>
-		* @param method - 
-		* @param args - 
-		* @return 
+		* Specifies the default operation for columns that do not have a specific operation applied; defaults to "Sum".
 		*/
-		invoke(method:string, ...args:FilterValue[]):FilterCondition;
-		toString():string;
+		defaultOperation:AggregationOperationType;
 		/**
-		* Constructs a string for the filter API from the given parameter.
-		* @param input - 
-		* @return 
+		* Mapping from each column name to the aggregation(s) that should be applied to that column in the resulting Totals
+		* Table. If a column is omitted, the defaultOperation is used.
 		*/
-		static ofString(input:any):FilterValue;
+		operationMap:{ [key: string]: Array<AggregationOperationType>; };
 		/**
-		* Constructs a boolean for the filter API from the given parameter.
-		* @param b - 
-		* @return 
+		* Groupings to use when generating the Totals Table. One row will exist for each unique set of values observed in
+		* these columns. See also `Table.selectDistinct`.
 		*/
-		static ofBoolean(b:boolean):FilterValue;
+		groupBy:Array<string>;
+
+		constructor();
+
+		toString():string;
 	}
 
 	/**
@@ -2357,6 +2357,13 @@ export namespace dh {
 	}
 
 
+	type SearchDisplayModeType = string;
+	export class SearchDisplayMode {
+		static readonly SEARCH_DISPLAY_DEFAULT:SearchDisplayModeType;
+		static readonly SEARCH_DISPLAY_HIDE:SearchDisplayModeType;
+		static readonly SEARCH_DISPLAY_SHOW:SearchDisplayModeType;
+	}
+
 	/**
 	* This enum describes the name of each supported operation/aggregation type when creating a `TreeTable`.
 	*/
@@ -2378,6 +2385,16 @@ export namespace dh {
 		static readonly SKIP:AggregationOperationType;
 	}
 
+	type ValueTypeType = string;
+	export class ValueType {
+		static readonly STRING:ValueTypeType;
+		static readonly NUMBER:ValueTypeType;
+		static readonly DOUBLE:ValueTypeType;
+		static readonly LONG:ValueTypeType;
+		static readonly DATETIME:ValueTypeType;
+		static readonly BOOLEAN:ValueTypeType;
+	}
+
 	/**
 	* A set of string constants that can be used to describe the different objects the JS API can export.
 	*/
@@ -2394,70 +2411,77 @@ export namespace dh {
 		static readonly TREEMAP:VariableTypeType;
 	}
 
-	type SearchDisplayModeType = string;
-	export class SearchDisplayMode {
-		static readonly SEARCH_DISPLAY_DEFAULT:SearchDisplayModeType;
-		static readonly SEARCH_DISPLAY_HIDE:SearchDisplayModeType;
-		static readonly SEARCH_DISPLAY_SHOW:SearchDisplayModeType;
-	}
-
-	type ValueTypeType = string;
-	export class ValueType {
-		static readonly STRING:ValueTypeType;
-		static readonly NUMBER:ValueTypeType;
-		static readonly DOUBLE:ValueTypeType;
-		static readonly LONG:ValueTypeType;
-		static readonly DATETIME:ValueTypeType;
-		static readonly BOOLEAN:ValueTypeType;
-	}
-
 }
 
 export namespace dh.ide {
 
 	/**
-	* Indicates the result of code run on the server.
+	* Specifies a type and either id or name (but not both).
 	*/
-	export interface CommandResult {
+	export interface VariableDescriptor {
+		type:string;
+		id?:string|null;
+		name?:string|null;
+	}
+	/**
+	* Represents a serialized fishlib LogRecord, suitable for display on javascript clients. A log entry sent from the
+	* server.
+	*/
+	export interface LogItem {
 		/**
-		* Describes changes made in the course of this command.
-		* @return {@link dh.ide.VariableChanges}.
+		* The level of the log message, enabling the client to ignore messages.
+		* @return String
 		*/
-		get changes():VariableChanges;
+		get logLevel():string;
 		/**
-		* If the command failed, the error message will be provided here.
+		* Timestamp of the message in microseconds since Jan 1, 1970 UTC.
+		* @return double
+		*/
+		get micros():number;
+		/**
+		* The log message written on the server.
 		* @return String
 		*/
-		get error():string;
+		get message():string;
 	}
 	/**
-	* Specifies a type and either id or name (but not both).
+	* Describes changes in the current set of variables in the script session. Note that variables that changed value
+	* without changing type will be included as <b>updated</b>, but if a new value with one type replaces an old value with
+	* a different type, this will be included as an entry in both <b>removed</b> and <b>created</b> to indicate the old and
+	* new types.
 	*/
-	export interface VariableDescriptor {
-		type:string;
-		id?:string|null;
-		name?:string|null;
+	export interface VariableChanges {
+		/**
+		* 
+		* @return The variables that no longer exist after this operation, or were replaced by some variable with a
+		*         different type.
+		*/
+		get removed():Array<VariableDefinition>;
+		/**
+		* 
+		* @return The variables that were created by this operation, or have a new type.
+		*/
+		get created():Array<VariableDefinition>;
+		/**
+		* 
+		* @return The variables that changed value during this operation.
+		*/
+		get updated():Array<VariableDefinition>;
 	}
 	/**
-	* Represents a serialized fishlib LogRecord, suitable for display on javascript clients. A log entry sent from the
-	* server.
+	* Indicates the result of code run on the server.
 	*/
-	export interface LogItem {
-		/**
-		* The level of the log message, enabling the client to ignore messages.
-		* @return String
-		*/
-		get logLevel():string;
+	export interface CommandResult {
 		/**
-		* Timestamp of the message in microseconds since Jan 1, 1970 UTC.
-		* @return double
+		* Describes changes made in the course of this command.
+		* @return {@link dh.ide.VariableChanges}.
 		*/
-		get micros():number;
+		get changes():VariableChanges;
 		/**
-		* The log message written on the server.
+		* If the command failed, the error message will be provided here.
 		* @return String
 		*/
-		get message():string;
+		get error():string;
 	}
 	/**
 	* A format to describe a variable available to be read from the server. Application fields are optional, and only
@@ -2500,33 +2524,120 @@ export namespace dh.ide {
 		*/
 		get applicationName():string;
 	}
+}
+
+export namespace dh.i18n {
+
 	/**
-	* Describes changes in the current set of variables in the script session. Note that variables that changed value
-	* without changing type will be included as <b>updated</b>, but if a new value with one type replaces an old value with
-	* a different type, this will be included as an entry in both <b>removed</b> and <b>created</b> to indicate the old and
-	* new types.
+	* Represents the timezones supported by Deephaven. Can be used to format dates, taking into account the offset changing
+	* throughout the year (potentially changing each year). These instances mostly are useful at this time to pass to the
+	* <b>DateTimeFormat.format()</b> methods, though also support a few properties at this time to see details about each
+	* instance.
+	*
+	*
+	* The following timezone codes are supported when getting a timezone object - instances appearing in the same line will
+	* return the same details:
+	*
+	* <ul>
+	* <li>GMT/UTC</li>
+	* <li>Asia/Tokyo</li>
+	* <li>Asia/Seoul</li>
+	* <li>Asia/Hong_Kong</li>
+	* <li>Asia/Singapore</li>
+	* <li>Asia/Calcutta/Asia/Kolkata</li>
+	* <li>Europe/Berlin</li>
+	* <li>Europe/London</li>
+	* <li>America/Sao_Paulo</li>
+	* <li>America/St_Johns</li>
+	* <li>America/Halifax</li>
+	* <li>America/New_York</li>
+	* <li>America/Chicago</li>
+	* <li>America/Denver</li>
+	* <li>America/Los_Angeles</li>
+	* <li>America/Anchorage</li>
+	* <li>Pacific/Honolulu</li>
+	* </ul>
+	*
+	* A Timezone object can also be created from an abbreviation. The following abbreviations are supported:
+	*
+	* <ul>
+	* <li>UTC</li>
+	* <li>GMT</li>
+	* <li>Z</li>
+	* <li>NY</li>
+	* <li>ET</li>
+	* <li>EST</li>
+	* <li>EDT</li>
+	* <li>MN</li>
+	* <li>CT</li>
+	* <li>CST</li>
+	* <li>CDT</li>
+	* <li>MT</li>
+	* <li>MST</li>
+	* <li>MDT</li>
+	* <li>PT</li>
+	* <li>PST</li>
+	* <li>PDT</li>
+	* <li>HI</li>
+	* <li>HST</li>
+	* <li>HDT</li>
+	* <li>BT</li>
+	* <li>BRST</li>
+	* <li>BRT</li>
+	* <li>KR</li>
+	* <li>KST</li>
+	* <li>HK</li>
+	* <li>HKT</li>
+	* <li>JP</li>
+	* <li>JST</li>
+	* <li>AT</li>
+	* <li>AST</li>
+	* <li>ADT</li>
+	* <li>NF</li>
+	* <li>NST</li>
+	* <li>NDT</li>
+	* <li>AL</li>
+	* <li>AKST</li>
+	* <li>AKDT</li>
+	* <li>IN</li>
+	* <li>IST</li>
+	* <li>CE</li>
+	* <li>CET</li>
+	* <li>CEST</li>
+	* <li>SG</li>
+	* <li>SGT</li>
+	* <li>LON</li>
+	* <li>BST</li>
+	* <li>MOS</li>
+	* <li>SHG</li>
+	* <li>CH</li>
+	* <li>NL</li>
+	* <li>TW</li>
+	* <li>SYD</li>
+	* <li>AEST</li>
+	* <li>AEDT</li>
+	* </ul>
 	*/
-	export interface VariableChanges {
+	export class TimeZone {
+		protected constructor();
+
 		/**
-		* 
-		* @return The variables that no longer exist after this operation, or were replaced by some variable with a
-		*         different type.
+		* Factory method which creates timezone instances from one of the supported keys.
+		* @param tzCode - 
+		* @return dh.i18n.TimeZone
 		*/
-		get removed():Array<VariableDefinition>;
+		static getTimeZone(tzCode:string):TimeZone;
 		/**
-		* 
-		* @return The variables that were created by this operation, or have a new type.
+		* the standard offset of this timezone, in minutes
+		* @return int
 		*/
-		get created():Array<VariableDefinition>;
+		get standardOffset():number;
 		/**
-		* 
-		* @return The variables that changed value during this operation.
+		* the timezone code that represents this `TimeZone`, usually the same key as was use to create this instance
+		* @return String
 		*/
-		get updated():Array<VariableDefinition>;
+		get id():string;
 	}
-}
-
-export namespace dh.i18n {
 
 	/**
 	* Largely an exported wrapper for the GWT DateFormat, but also includes support for formatting nanoseconds as an
@@ -2680,117 +2791,6 @@ export namespace dh.i18n {
 	}
 
 
-	/**
-	* Represents the timezones supported by Deephaven. Can be used to format dates, taking into account the offset changing
-	* throughout the year (potentially changing each year). These instances mostly are useful at this time to pass to the
-	* <b>DateTimeFormat.format()</b> methods, though also support a few properties at this time to see details about each
-	* instance.
-	*
-	*
-	* The following timezone codes are supported when getting a timezone object - instances appearing in the same line will
-	* return the same details:
-	*
-	* <ul>
-	* <li>GMT/UTC</li>
-	* <li>Asia/Tokyo</li>
-	* <li>Asia/Seoul</li>
-	* <li>Asia/Hong_Kong</li>
-	* <li>Asia/Singapore</li>
-	* <li>Asia/Calcutta/Asia/Kolkata</li>
-	* <li>Europe/Berlin</li>
-	* <li>Europe/London</li>
-	* <li>America/Sao_Paulo</li>
-	* <li>America/St_Johns</li>
-	* <li>America/Halifax</li>
-	* <li>America/New_York</li>
-	* <li>America/Chicago</li>
-	* <li>America/Denver</li>
-	* <li>America/Los_Angeles</li>
-	* <li>America/Anchorage</li>
-	* <li>Pacific/Honolulu</li>
-	* </ul>
-	*
-	* A Timezone object can also be created from an abbreviation. The following abbreviations are supported:
-	*
-	* <ul>
-	* <li>UTC</li>
-	* <li>GMT</li>
-	* <li>Z</li>
-	* <li>NY</li>
-	* <li>ET</li>
-	* <li>EST</li>
-	* <li>EDT</li>
-	* <li>MN</li>
-	* <li>CT</li>
-	* <li>CST</li>
-	* <li>CDT</li>
-	* <li>MT</li>
-	* <li>MST</li>
-	* <li>MDT</li>
-	* <li>PT</li>
-	* <li>PST</li>
-	* <li>PDT</li>
-	* <li>HI</li>
-	* <li>HST</li>
-	* <li>HDT</li>
-	* <li>BT</li>
-	* <li>BRST</li>
-	* <li>BRT</li>
-	* <li>KR</li>
-	* <li>KST</li>
-	* <li>HK</li>
-	* <li>HKT</li>
-	* <li>JP</li>
-	* <li>JST</li>
-	* <li>AT</li>
-	* <li>AST</li>
-	* <li>ADT</li>
-	* <li>NF</li>
-	* <li>NST</li>
-	* <li>NDT</li>
-	* <li>AL</li>
-	* <li>AKST</li>
-	* <li>AKDT</li>
-	* <li>IN</li>
-	* <li>IST</li>
-	* <li>CE</li>
-	* <li>CET</li>
-	* <li>CEST</li>
-	* <li>SG</li>
-	* <li>SGT</li>
-	* <li>LON</li>
-	* <li>BST</li>
-	* <li>MOS</li>
-	* <li>SHG</li>
-	* <li>CH</li>
-	* <li>NL</li>
-	* <li>TW</li>
-	* <li>SYD</li>
-	* <li>AEST</li>
-	* <li>AEDT</li>
-	* </ul>
-	*/
-	export class TimeZone {
-		protected constructor();
-
-		/**
-		* Factory method which creates timezone instances from one of the supported keys.
-		* @param tzCode - 
-		* @return dh.i18n.TimeZone
-		*/
-		static getTimeZone(tzCode:string):TimeZone;
-		/**
-		* the standard offset of this timezone, in minutes
-		* @return int
-		*/
-		get standardOffset():number;
-		/**
-		* the timezone code that represents this `TimeZone`, usually the same key as was use to create this instance
-		* @return String
-		*/
-		get id():string;
-	}
-
 }
 
 export namespace dh.plot {