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

package/dist/index.d.ts

@@ -1,10 +1,6 @@
 // Minimum TypeScript Version: 4.3
 // Generated using com.vertispan.tsdefs.doclet.TsDoclet
 
-export interface IIterableResult<T> {
-	value:T;
-	done:boolean;
-}
 /**
 * This is part of EcmaScript 2015, documented here for completeness. It supports a single method, <b>next()</b>, which
 * returns an object with a <b>boolean</b> named <b>done</b> (true if there are no more items to return; false
@@ -15,23 +11,12 @@ export interface Iterator<T> {
 	hasNext():boolean;
 	next():IIterableResult<T>;
 }
+export interface IIterableResult<T> {
+	value:T;
+	done:boolean;
+}
 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
@@ -106,6 +91,21 @@ 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;
+	}
+
 
 	type ItemTypeType = string;
 	export class ItemType {
@@ -117,325 +117,213 @@ export namespace dh.storage {
 
 export namespace dh {
 
-	export interface ColumnGroup {
-		get name():string|null;
-		get children():string[]|null;
-		get color():string|null;
-	}
-	export interface WorkerHeapInfo {
+	/**
+	* Row implementation that also provides additional read-only properties. represents visible rows in the table,
+	* but with additional properties to reflect the tree structure.
+	*/
+	export interface TreeRow extends ViewportRow {
 		/**
-		* Total heap size available for this worker.
+		* True if this node is currently expanded to show its children; false otherwise. Those children will be the
+		* rows below this one with a greater depth than this one
+		* @return boolean
 		*/
-		get totalHeapSize():number;
-		get freeMemory():number;
-		get maximumHeapSize():number;
+		get isExpanded():boolean;
+		/**
+		* The number of levels above this node; zero for top level nodes. Generally used by the UI to indent the
+		* row and its expand/collapse icon
+		* @return int
+		*/
+		get depth():number;
+		/**
+		* True if this node has children and can be expanded; false otherwise. Note that this value may change when
+		* the table updates, depending on the table's configuration
+		* @return boolean
+		*/
+		get hasChildren():boolean;
+		get index():LongWrapper;
 	}
 	/**
-	* Common interface for various ways of accessing table data and formatting.
+	* 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.
 	*
-	* Java note: this interface contains some extra overloads that aren't available in JS. Implementations are expected to
-	* implement only abstract methods, and default methods present in this interface will dispatch accordingly.
-	*/
-	export interface TableData {
-		get(index:LongWrapper|number):Row;
-		getData(index:LongWrapper|number, column:Column):any;
-		getFormat(index:LongWrapper|number, column:Column):Format;
-		get columns():Array<Column>;
-		get rows():Array<Row>;
-	}
-	export interface LayoutHints {
-		readonly searchDisplayMode?:SearchDisplayModeType|null;
-
-		get hiddenColumns():string[]|null;
-		get frozenColumns():string[]|null;
-		get columnGroups():ColumnGroup[]|null;
-		get areSavedLayoutsAllowed():boolean;
-		get frontColumns():string[]|null;
-		get backColumns():string[]|null;
-	}
-	/**
-	* Encapsulates event handling around table subscriptions by "cheating" and wrapping up a JsTable instance to do the
-	* real dirty work. This allows a viewport to stay open on the old table if desired, while this one remains open.
-	* <p>
-	* As this just wraps a JsTable (and thus a CTS), it holds its own flattened, pUT'd handle to get deltas from the
-	* server. The setViewport method can be used to adjust this table instead of creating a new one.
-	* <p>
-	* Existing methods on JsTable like setViewport and getViewportData are intended to proxy to this, which then will talk
-	* to the underlying handle and accumulated data.
-	* <p>
-	* As long as we keep the existing methods/events on JsTable, close() is not required if no other method is called, with
-	* the idea then that the caller did not actually use this type. This means that for every exported method (which then
-	* will mark the instance of "actually being used, please don't automatically close me"), there must be an internal
-	* version called by those existing JsTable method, which will allow this instance to be cleaned up once the JsTable
-	* deems it no longer in use.
-	* <p>
-	* Note that if the caller does close an instance, this shuts down the JsTable's use of this (while the converse is not
-	* true), providing a way to stop the server from streaming updates to the client.
+	* Additionally, this is automatically subscribed to its one and only row, across all columns.
 	*
-	* This object serves as a "handle" to a subscription, allowing it to be acted on directly or canceled outright. If you
-	* retain an instance of this, you have two choices - either only use it to call `close()` on it to stop the table's
-	* viewport without creating a new one, or listen directly to this object instead of the table for data events, and
-	* always call `close()` when finished. Calling any method on this object other than close() will result in it
-	* continuing to live on after `setViewport` is called on the original table, or after the table is modified.
+	* 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 TableViewportSubscription extends HasEventHandling {
+	export interface TotalsTable extends JoinableTable {
 		/**
-		* Changes the rows and columns set on this viewport. This cannot be used to change the update interval.
+		* 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?:Column[]|undefined|null, updateIntervalMs?:number|undefined|null):void;
-		/**
-		* Stops this viewport from running, stopping all events on itself and on the table that created it.
-		*/
-		close():void;
+		setViewport(firstRow:number, lastRow:number, columns?:Array<Column>, updateIntervalMs?:number):void;
 		/**
-		* Gets the data currently visible in this viewport
-		* @return Promise of {@link dh.TableData}.
+		* 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>;
-		snapshot(rows:RangeSet, columns:Column[]):Promise<TableData>;
-	}
-	/**
-	* 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.
-	*
-	* This class supports two ways of reading the table - checking the changes made since the last update, and reading
-	* all data currently in the table. While it is more expensive to always iterate over every single row in the table,
-	* it may in some cases actually be cheaper than maintaining state separately and updating only the changes, though
-	* both options should be considered.
-	*
-	* The RangeSet objects allow iterating over the LongWrapper indexes in the table. Note that these "indexes" are not
-	* necessarily contiguous and may be negative, and represent some internal state on the server, allowing it to keep
-	* track of data efficiently. Those LongWrapper objects can be passed to the various methods on this instance to
-	* read specific rows or cells out of the table.
-	*/
-	export interface SubscriptionTableData extends TableData {
-		get fullIndex():RangeSet;
-		/**
-		* The ordered set of row indexes removed since the last update
-		* @return dh.RangeSet
-		*/
-		get removed():RangeSet;
 		/**
-		* The ordered set of row indexes added since the last update
-		* @return dh.RangeSet
+		* 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}
 		*/
-		get added():RangeSet;
-		get columns():Array<Column>;
+		findColumn(key:string):Column;
 		/**
-		* The ordered set of row indexes updated since the last update
-		* @return dh.RangeSet
+		* multiple columns specified by the given names.
+		* @param keys - 
+		* @return {@link dh.Column} array
 		*/
-		get modified():RangeSet;
-		get rows():Array<Row>;
-	}
-	export interface HasEventHandling {
+		findColumns(keys:string[]):Column[];
 		/**
-		* 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
+		* 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;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
+		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
+		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 - 
+		* 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 
-		* @typeParam T - 
 		*/
-		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
-	* {@link dh.TotalsTable}.
-	*/
-	export interface JoinableTable {
-		freeze():Promise<Table>;
-		snapshot(baseTable:Table, doInitialSnapshot?:boolean, stampColumns?:string[]):Promise<Table>;
+		applyCustomColumns(customColumns:Array<string|CustomColumn>):Array<CustomColumn>;
 		/**
-		* Joins this table to the provided table, using one of the specified join types:
-		* <ul>
-		* <li><code>AJ</code>, <code>ReverseAJ</code> (or <code>RAJ</code>) - inexact timeseries joins, based on the
-		* provided matching rule.</li>
-		* <li><code>CROSS_JOIN</code> (or <code>Join</code>) - cross join of all rows that have matching values in both
-		* tables.</li>
-		* <li><code>EXACT_JOIN</code> (or <code>ExactJoin</code> - matches values in exactly one row in the right table,
-		* with errors if there is not exactly one.</li>
-		* <li><code>NATURAL_JOIN</code> (or <code>Natural</code> - matches values in at most one row in the right table,
-		* with nulls if there is no match or errors if there are multiple matches.</li>
-		* </ul>
-		*
-		* Note that <code>Left</code> join is not supported here, unlike DHE.
-		* <p>
-		* See the <a href="https://deephaven.io/core/docs/conceptual/choose-joins/">Choose a join method</a> document for
-		* more guidance on picking a join operation.
-		* @deprecated Instead, call the specific method for the join type.
-		* @param joinType - The type of join to perform, see the list above.
-		* @param rightTable - The table to match to values in this table
-		* @param columnsToMatch - Columns that should match
-		* @param columnsToAdd - Columns from the right table to add to the result - empty/null/absent to add all columns
-		* @param asOfMatchRule - If joinType is AJ/RAJ/ReverseAJ, the match rule to use
-		* @return a promise that will resolve to the joined table
+		* 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
 		*/
-		join(joinType:string, rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, asOfMatchRule?:string|undefined|null):Promise<Table>;
+		applyFilter(filter:FilterCondition[]):Array<FilterCondition>;
 		/**
-		* Performs an inexact timeseries join, where rows in this table will have columns added from the closest matching
-		* row from the right table.
-		* <p>
-		* The `asOfMatchRule` value can be one of:
-		* <ul>
-		* <li>LESS_THAN_EQUAL</li>
-		* <li>LESS_THAN</li>
-		* <li>GREATER_THAN_EQUAL</li>
-		* <li>GREATER_THAN</li>
-		* </ul>
-		* @param rightTable - the table to match to values in this table
-		* @param columnsToMatch - the columns that should match, according to the asOfMatchRole
-		* @param columnsToAdd - columns from the right table to add to the resulting table, empty/null/absent to add all
-		*        columns
-		* @param asOfMatchRule - the match rule to use, see above
-		* @return a promise that will resolve to the joined table
-		*/
-		asOfJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, asOfMatchRule?:string|undefined|null):Promise<Table>;
-		/**
-		* a promise that will be resolved with the newly created table holding the results of the specified cross join
-		* operation. The <b>columnsToAdd</b> parameter is optional, not specifying it will result in all columns from the
-		* right table being added to the output. The <b>reserveBits</b> optional parameter lets the client control how the
-		* key space is distributed between the rows in the two tables, see the Java <b>Table</b> class for details.
-		* @param rightTable - the table to match to values in this table
-		* @param columnsToMatch - the columns that should match exactly
-		* @param columnsToAdd - columns from the right table to add to the resulting table, empty/null/absent to add all
-		*        columns
-		* @param reserveBits - the number of bits of key-space to initially reserve per group, null/absent will let the
-		*        server select a value
-		* @return a promise that will resolve to the joined table
-		*/
-		crossJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, reserveBits?:number|undefined|null):Promise<Table>;
-		/**
-		* a promise that will be resolved with the newly created table holding the results of the specified exact join
-		* operation. The `columnsToAdd` parameter is optional, not specifying it will result in all columns from the right
-		* table being added to the output.
-		* @param rightTable - the table to match to values in this table
-		* @param columnsToMatch - the columns that should match exactly
-		* @param columnsToAdd - columns from the right table to add to the resulting table, empty/null/absent to add all
-		*        columns
-		* @return a promise that will resolve to the joined table
-		*/
-		exactJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null):Promise<Table>;
-		/**
-		* a promise that will be resolved with the newly created table holding the results of the specified natural join
-		* operation. The <b>columnsToAdd</b> parameter is optional, not specifying it will result in all columns from the
-		* right table being added to the output.
-		* @param rightTable - the table to match to values in this table
-		* @param columnsToMatch - the columns that should match exactly
-		* @param columnsToAdd - columns from the right table to add to the resulting table, empty/null/absent to add all
-		*        columns
-		* @return a promise that will resolve to the joined table
+		* 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
 		*/
-		naturalJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null):Promise<Table>;
-	}
-	/**
-	* Row implementation that also provides additional read-only properties. represents visible rows in the table,
-	* but with additional properties to reflect the tree structure.
-	*/
-	export interface TreeRow extends ViewportRow {
+		get filter():Array<FilterCondition>;
 		/**
-		* True if this node is currently expanded to show its children; false otherwise. Those children will be the
-		* rows below this one with a greater depth than this one
+		* True if this table has been closed.
 		* @return boolean
 		*/
-		get isExpanded():boolean;
+		get isClosed():boolean;
 		/**
-		* The number of levels above this node; zero for top level nodes. Generally used by the UI to indent the
-		* row and its expand/collapse icon
-		* @return int
+		* The total number of rows in this table. This may change as the base table's configuration, filter, or contents
+		* change.
+		* @return double
 		*/
-		get depth():number;
+		get size():number;
 		/**
-		* True if this node has children and can be expanded; false otherwise. Note that this value may change when
-		* the table updates, depending on the table's configuration
-		* @return boolean
+		* 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 hasChildren():boolean;
-		get index():LongWrapper;
-	}
-	/**
-	* 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 {
+		get columns():Array<Column>;
+		get totalsTableConfig():TotalsTableConfig;
 		/**
-		* The index of the first returned row
-		* @return double
+		* 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 offset():number;
+		get sort():Array<Sort>;
 		/**
-		* A list of columns describing the data types in each row
-		* @return {@link dh.Column} array.
+		* 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 columns():Array<Column>;
+		get customColumns():Array<CustomColumn>;
 		/**
-		* An array of rows of data
-		* @return {@link dh.ViewportRow} array.
+		* True if this table may receive updates from the server, including size changed events, updated events after
+		* initial snapshot.
+		* @return boolean
 		*/
-		get rows():Array<ViewportRow>;
-	}
-	export interface Row {
-		get(column:Column):any;
-		getFormat(column:Column):Format;
-		get index():LongWrapper;
+		get isRefreshing():boolean;
 	}
 	/**
-	* Represents the contents of a single widget data message from the server, with a binary data paylod and exported
-	* objects. Implemented both by Widget itself and by the `event.details` when data is received by the client.
-	*
-	* Terminology note: the name of this type should probably use "Data" instead of "Message", and the methods should use
-	* "payload" rather than "data" to match other platforms and the protobuf itself. These names are instead used for
-	* backwards compatibility and to better follow JS expectations.
+	* Represents a server-side object that may not yet have been fetched by the client. When this object will no longer be
+	* used, if {@link fetch} is not called on this object, then {@link close} must be to ensure server-side resources
+	* are correctly freed.
 	*/
-	export interface WidgetMessageDetails {
+	export interface WidgetExportedObject {
 		/**
-		* Returns the data from this message as a base64-encoded string.
+		* Returns the type of this export, typically one of {@link dh.VariableType}, but may also include plugin types. If
+		* null, this object cannot be fetched, but can be passed to the server, such as via
+		* {@link Widget.sendMessage}.
+		* @return the string type of this server-side object, or null.
 		*/
-		getDataAsBase64():string;
+		readonly type?:string|null;
+
 		/**
-		* Returns the data from this message as a Uint8Array.
+		* Exports another copy of this reference, allowing it to be fetched separately. Results in rejection if the ticket
+		* was already closed (either by calling {@link WidgetExportedObject.close} or closing the object returned from {@link WidgetExportedObject.fetch}).
+		* @return a promise returning a reexported copy of this object, still referencing the same server-side object.
 		*/
-		getDataAsU8():Uint8Array;
+		reexport():Promise<WidgetExportedObject>;
 		/**
-		* Returns the data from this message as a utf-8 string.
+		* Returns a promise that will fetch the object represented by this reference. Multiple calls to this will return
+		* the same instance.
+		* @return a promise that will resolve to a client side object that represents the reference on the server.
 		*/
-		getDataAsString():string;
+		fetch():Promise<any>;
 		/**
-		* Returns an array of exported objects sent from the server. The plugin implementation is now responsible for these
-		* objects, and should close them when no longer needed.
+		* Releases the server-side resources associated with this object, regardless of whether other client-side objects
+		* exist that also use that object. Should not be called after fetch() has been invoked.
 		*/
-		get exportedObjects():WidgetExportedObject[];
+		close():void;
 	}
 	/**
-	* This object may be pooled internally or discarded and not updated. Do not retain references to it. Instead, request
-	* the viewport again.
+	* Common interface for various ways of accessing table data and formatting.
+	*
+	* Java note: this interface contains some extra overloads that aren't available in JS. Implementations are expected to
+	* implement only abstract methods, and default methods present in this interface will dispatch accordingly.
 	*/
-	export interface ViewportRow extends Row {
-		get index():LongWrapper;
+	export interface TableData {
+		get(index:LongWrapper|number):Row;
+		getData(index:LongWrapper|number, column:Column):any;
+		getFormat(index:LongWrapper|number, column:Column):Format;
+		get columns():Array<Column>;
+		get rows():Array<Row>;
 	}
 	/**
-	* Wrap LocalTime values for use in JS. Provides text formatting for display and access to the underlying value.
+	* Wrap LocalDate values for use in JS. Provides text formatting for display and access to the underlying value.
 	*/
-	export interface LocalTimeWrapper {
+	export interface LocalDateWrapper {
 		valueOf():string;
-		getHour():number;
-		getMinute():number;
-		getSecond():number;
-		getNano():number;
+		getYear():number;
+		getMonthValue():number;
+		getDayOfMonth():number;
 		toString():string;
 	}
 	/**
@@ -463,700 +351,1054 @@ export namespace dh {
 		*/
 		readonly numberFormat?:string|null;
 	}
+	export interface WorkerHeapInfo {
+		/**
+		* Total heap size available for this worker.
+		*/
+		get totalHeapSize():number;
+		get freeMemory():number;
+		get maximumHeapSize():number;
+	}
+	export interface TreeViewportData extends TableData {
+		get offset():number;
+		get columns():Array<Column>;
+		get rows():Array<TreeRow>;
+	}
+	export interface LayoutHints {
+		readonly searchDisplayMode?:SearchDisplayModeType|null;
+
+		get hiddenColumns():string[]|null;
+		get frozenColumns():string[]|null;
+		get columnGroups():ColumnGroup[]|null;
+		get areSavedLayoutsAllowed():boolean;
+		get frontColumns():string[]|null;
+		get backColumns():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.
+	* 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.
+	*
+	* This class supports two ways of reading the table - checking the changes made since the last update, and reading
+	* all data currently in the table. While it is more expensive to always iterate over every single row in the table,
+	* it may in some cases actually be cheaper than maintaining state separately and updating only the changes, though
+	* both options should be considered.
+	*
+	* The RangeSet objects allow iterating over the LongWrapper indexes in the table. Note that these "indexes" are not
+	* necessarily contiguous and may be negative, and represent some internal state on the server, allowing it to keep
+	* track of data efficiently. Those LongWrapper objects can be passed to the various methods on this instance to
+	* read specific rows or cells out of the table.
 	*/
-	export interface ColumnStatistics {
+	export interface SubscriptionTableData extends TableData {
+		get fullIndex():RangeSet;
 		/**
-		* Gets the type of formatting that should be used for given statistic.
-		* <p>
-		* the format type for a statistic. A null return value means that the column formatting should be used.
-		* @param name - the display name of the statistic
-		* @return String
+		* The ordered set of row indexes removed since the last update
+		* @return dh.RangeSet
 		*/
-		getType(name:string):string;
+		get removed():RangeSet;
 		/**
-		* Gets a map with the name of each unique value as key and the count as the value. A map of each unique value's
-		* name to the count of how many times it occurred in the column. This map will be empty for tables containing more
-		* than 19 unique values.
-		* @return Map of String double
+		* The ordered set of row indexes added since the last update
+		* @return dh.RangeSet
 		*/
-		get uniqueValues():Map<string, number>;
+		get added():RangeSet;
+		get columns():Array<Column>;
 		/**
-		* Gets a map with the display name of statistics as keys and the numeric stat as a value.
-		* <p>
-		* A map of each statistic's name to its value.
-		* @return Map of String and Object
+		* The ordered set of row indexes updated since the last update
+		* @return dh.RangeSet
 		*/
-		get statisticsMap():Map<string, object>;
+		get modified():RangeSet;
+		get rows():Array<Row>;
 	}
 	/**
-	* Represents a server-side object that may not yet have been fetched by the client. When this object will no longer be
-	* used, if {@link fetch} is not called on this object, then {@link close} must be to ensure server-side resources
-	* are correctly freed.
+	* Wrap LocalTime values for use in JS. Provides text formatting for display and access to the underlying value.
 	*/
-	export interface WidgetExportedObject {
+	export interface LocalTimeWrapper {
+		valueOf():string;
+		getHour():number;
+		getMinute():number;
+		getSecond():number;
+		getNano():number;
+		toString():string;
+	}
+	/**
+	* Encapsulates event handling around table subscriptions by "cheating" and wrapping up a JsTable instance to do the
+	* real dirty work. This allows a viewport to stay open on the old table if desired, while this one remains open.
+	* <p>
+	* As this just wraps a JsTable (and thus a CTS), it holds its own flattened, pUT'd handle to get deltas from the
+	* server. The setViewport method can be used to adjust this table instead of creating a new one.
+	* <p>
+	* Existing methods on JsTable like setViewport and getViewportData are intended to proxy to this, which then will talk
+	* to the underlying handle and accumulated data.
+	* <p>
+	* As long as we keep the existing methods/events on JsTable, close() is not required if no other method is called, with
+	* the idea then that the caller did not actually use this type. This means that for every exported method (which then
+	* will mark the instance of "actually being used, please don't automatically close me"), there must be an internal
+	* version called by those existing JsTable method, which will allow this instance to be cleaned up once the JsTable
+	* deems it no longer in use.
+	* <p>
+	* Note that if the caller does close an instance, this shuts down the JsTable's use of this (while the converse is not
+	* true), providing a way to stop the server from streaming updates to the client.
+	*
+	* This object serves as a "handle" to a subscription, allowing it to be acted on directly or canceled outright. If you
+	* retain an instance of this, you have two choices - either only use it to call `close()` on it to stop the table's
+	* viewport without creating a new one, or listen directly to this object instead of the table for data events, and
+	* always call `close()` when finished. Calling any method on this object other than close() will result in it
+	* continuing to live on after `setViewport` is called on the original table, or after the table is modified.
+	*/
+	export interface TableViewportSubscription extends HasEventHandling {
 		/**
-		* Returns the type of this export, typically one of {@link dh.VariableType}, but may also include plugin types. If
-		* null, this object cannot be fetched, but can be passed to the server, such as via
-		* {@link Widget.sendMessage}.
-		* @return the string type of this server-side object, or null.
+		* Changes the rows and columns set on this viewport. This cannot be used to change the update interval.
+		* @param firstRow - 
+		* @param lastRow - 
+		* @param columns - 
+		* @param updateIntervalMs - 
 		*/
-		readonly type?:string|null;
-
+		setViewport(firstRow:number, lastRow:number, columns?:Column[]|undefined|null, updateIntervalMs?:number|undefined|null):void;
 		/**
-		* Exports another copy of this reference, allowing it to be fetched separately. Results in rejection if the ticket
-		* was already closed (either by calling {@link WidgetExportedObject.close} or closing the object returned from {@link WidgetExportedObject.fetch}).
-		* @return a promise returning a reexported copy of this object, still referencing the same server-side object.
+		* Stops this viewport from running, stopping all events on itself and on the table that created it.
 		*/
-		reexport():Promise<WidgetExportedObject>;
+		close():void;
 		/**
-		* Returns a promise that will fetch the object represented by this reference. Multiple calls to this will return
-		* the same instance.
-		* @return a promise that will resolve to a client side object that represents the reference on the server.
+		* Gets the data currently visible in this viewport
+		* @return Promise of {@link dh.TableData}.
 		*/
-		fetch():Promise<any>;
+		getViewportData():Promise<TableData>;
+		snapshot(rows:RangeSet, columns:Column[]):Promise<TableData>;
+	}
+	export interface HasEventHandling {
 		/**
-		* Releases the server-side resources associated with this object, regardless of whether other client-side objects
-		* exist that also use that object. Should not be called after fetch() has been invoked.
+		* 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
 		*/
-		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;
+		/**
+		* 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;
+	}
+	/**
+	* Represents a table which can be joined to another table. Current implementations are {@link dh.Table} and
+	* {@link dh.TotalsTable}.
+	*/
+	export interface JoinableTable {
+		freeze():Promise<Table>;
+		snapshot(baseTable:Table, doInitialSnapshot?:boolean, stampColumns?:string[]):Promise<Table>;
+		/**
+		* Joins this table to the provided table, using one of the specified join types:
+		* <ul>
+		* <li><code>AJ</code>, <code>ReverseAJ</code> (or <code>RAJ</code>) - inexact timeseries joins, based on the
+		* provided matching rule.</li>
+		* <li><code>CROSS_JOIN</code> (or <code>Join</code>) - cross join of all rows that have matching values in both
+		* tables.</li>
+		* <li><code>EXACT_JOIN</code> (or <code>ExactJoin</code> - matches values in exactly one row in the right table,
+		* with errors if there is not exactly one.</li>
+		* <li><code>NATURAL_JOIN</code> (or <code>Natural</code> - matches values in at most one row in the right table,
+		* with nulls if there is no match or errors if there are multiple matches.</li>
+		* </ul>
+		*
+		* Note that <code>Left</code> join is not supported here, unlike DHE.
+		* <p>
+		* See the <a href="https://deephaven.io/core/docs/conceptual/choose-joins/">Choose a join method</a> document for
+		* more guidance on picking a join operation.
+		* @deprecated Instead, call the specific method for the join type.
+		* @param joinType - The type of join to perform, see the list above.
+		* @param rightTable - The table to match to values in this table
+		* @param columnsToMatch - Columns that should match
+		* @param columnsToAdd - Columns from the right table to add to the result - empty/null/absent to add all columns
+		* @param asOfMatchRule - If joinType is AJ/RAJ/ReverseAJ, the match rule to use
+		* @return a promise that will resolve to the joined table
+		*/
+		join(joinType:string, rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, asOfMatchRule?:string|undefined|null):Promise<Table>;
+		/**
+		* Performs an inexact timeseries join, where rows in this table will have columns added from the closest matching
+		* row from the right table.
+		* <p>
+		* The `asOfMatchRule` value can be one of:
+		* <ul>
+		* <li>LESS_THAN_EQUAL</li>
+		* <li>LESS_THAN</li>
+		* <li>GREATER_THAN_EQUAL</li>
+		* <li>GREATER_THAN</li>
+		* </ul>
+		* @param rightTable - the table to match to values in this table
+		* @param columnsToMatch - the columns that should match, according to the asOfMatchRole
+		* @param columnsToAdd - columns from the right table to add to the resulting table, empty/null/absent to add all
+		*        columns
+		* @param asOfMatchRule - the match rule to use, see above
+		* @return a promise that will resolve to the joined table
+		*/
+		asOfJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, asOfMatchRule?:string|undefined|null):Promise<Table>;
+		/**
+		* a promise that will be resolved with the newly created table holding the results of the specified cross join
+		* operation. The <b>columnsToAdd</b> parameter is optional, not specifying it will result in all columns from the
+		* right table being added to the output. The <b>reserveBits</b> optional parameter lets the client control how the
+		* key space is distributed between the rows in the two tables, see the Java <b>Table</b> class for details.
+		* @param rightTable - the table to match to values in this table
+		* @param columnsToMatch - the columns that should match exactly
+		* @param columnsToAdd - columns from the right table to add to the resulting table, empty/null/absent to add all
+		*        columns
+		* @param reserveBits - the number of bits of key-space to initially reserve per group, null/absent will let the
+		*        server select a value
+		* @return a promise that will resolve to the joined table
+		*/
+		crossJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null, reserveBits?:number|undefined|null):Promise<Table>;
+		/**
+		* a promise that will be resolved with the newly created table holding the results of the specified exact join
+		* operation. The `columnsToAdd` parameter is optional, not specifying it will result in all columns from the right
+		* table being added to the output.
+		* @param rightTable - the table to match to values in this table
+		* @param columnsToMatch - the columns that should match exactly
+		* @param columnsToAdd - columns from the right table to add to the resulting table, empty/null/absent to add all
+		*        columns
+		* @return a promise that will resolve to the joined table
+		*/
+		exactJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null):Promise<Table>;
+		/**
+		* a promise that will be resolved with the newly created table holding the results of the specified natural join
+		* operation. The <b>columnsToAdd</b> parameter is optional, not specifying it will result in all columns from the
+		* right table being added to the output.
+		* @param rightTable - the table to match to values in this table
+		* @param columnsToMatch - the columns that should match exactly
+		* @param columnsToAdd - columns from the right table to add to the resulting table, empty/null/absent to add all
+		*        columns
+		* @return a promise that will resolve to the joined table
+		*/
+		naturalJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null):Promise<Table>;
+	}
+	/**
+	* This object may be pooled internally or discarded and not updated. Do not retain references to it. Instead, request
+	* the viewport again.
+	*/
+	export interface ViewportRow extends Row {
+		get index():LongWrapper;
+	}
+	export interface ColumnGroup {
+		get name():string|null;
+		get children():string[]|null;
+		get color():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.
+	*/
+	export interface ColumnStatistics {
+		/**
+		* Gets the type of formatting that should be used for given statistic.
+		* <p>
+		* the format type for a statistic. A null return value means that the column formatting should be used.
+		* @param name - the display name of the statistic
+		* @return String
+		*/
+		getType(name:string):string;
+		/**
+		* Gets a map with the name of each unique value as key and the count as the value. A map of each unique value's
+		* name to the count of how many times it occurred in the column. This map will be empty for tables containing more
+		* than 19 unique values.
+		* @return Map of String double
+		*/
+		get uniqueValues():Map<string, number>;
+		/**
+		* Gets a map with the display name of statistics as keys and the numeric stat as a value.
+		* <p>
+		* A map of each statistic's name to its value.
+		* @return Map of String and Object
+		*/
+		get statisticsMap():Map<string, object>;
+	}
+	/**
+	* 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
+		*/
+		get offset():number;
+		/**
+		* A list of columns describing the data types in each row
+		* @return {@link dh.Column} array.
+		*/
+		get columns():Array<Column>;
+		/**
+		* An array of rows of data
+		* @return {@link dh.ViewportRow} array.
+		*/
+		get rows():Array<ViewportRow>;
+	}
+	/**
+	* Represents the contents of a single widget data message from the server, with a binary data paylod and exported
+	* objects. Implemented both by Widget itself and by the `event.details` when data is received by the client.
+	*
+	* Terminology note: the name of this type should probably use "Data" instead of "Message", and the methods should use
+	* "payload" rather than "data" to match other platforms and the protobuf itself. These names are instead used for
+	* backwards compatibility and to better follow JS expectations.
+	*/
+	export interface WidgetMessageDetails {
+		/**
+		* Returns the data from this message as a base64-encoded string.
+		*/
+		getDataAsBase64():string;
+		/**
+		* Returns the data from this message as a Uint8Array.
+		*/
+		getDataAsU8():Uint8Array;
+		/**
+		* Returns the data from this message as a utf-8 string.
+		*/
+		getDataAsString():string;
+		/**
+		* Returns an array of exported objects sent from the server. The plugin implementation is now responsible for these
+		* objects, and should close them when no longer needed.
+		*/
+		get exportedObjects():WidgetExportedObject[];
 	}
 	export interface RefreshToken {
 		get bytes():string;
 		get expiry():number;
 	}
+	export interface Row {
+		get(column:Column):any;
+		getFormat(column:Column):Format;
+		get index():LongWrapper;
+	}
+
 	/**
-	* 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.
+	* Represents a set of Tables each corresponding to some key. The keys are available locally, but a call must be made to
+	* the server to get each Table. All tables will have the same structure.
 	*/
-	export interface TotalsTable extends JoinableTable {
+	export class PartitionedTable implements HasEventHandling {
 		/**
-		* 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 - 
+		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
 		*/
-		setViewport(firstRow:number, lastRow:number, columns?:Array<Column>, updateIntervalMs?:number):void;
+		static readonly EVENT_KEYADDED:string;
 		/**
-		* 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}
+		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
 		*/
-		getViewportData():Promise<TableData>;
+		static readonly EVENT_DISCONNECT:string;
 		/**
-		* 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}
+		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
 		*/
-		findColumn(key:string):Column;
+		static readonly EVENT_RECONNECT:string;
 		/**
-		* multiple columns specified by the given names.
-		* @param keys - 
-		* @return {@link dh.Column} array
+		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
 		*/
-		findColumns(keys:string[]):Column[];
+		static readonly EVENT_RECONNECTFAILED:string;
+
+		protected constructor();
+
+		typedTicket():dhinternal.io.deephaven.proto.ticket_pb.TypedTicket;
 		/**
-		* Indicates that the table will no longer be used, and resources used to provide it can be freed up on the server.
+		* Fetch the table with the given key. If the key does not exist, returns `null`.
+		* @param key - The key to fetch. An array of values for each key column, in the same order as the key columns are.
+		* @return Promise of dh.Table, or `null` if the key does not exist.
+		*/
+		getTable(key:object):Promise<Table|undefined|null>;
+		/**
+		* Open a new table that is the result of merging all constituent tables. See
+		* {@link io.deephaven.engine.table.PartitionedTable#merge()} for details.
+		* @return A merged representation of the constituent tables.
+		*/
+		getMergedTable():Promise<Table>;
+		/**
+		* The set of all currently known keys. This is kept up to date, so getting the list after adding an event listener
+		* for <b>keyadded</b> will ensure no keys are missed.
+		* @return Set of Object
+		*/
+		getKeys():Set<object>;
+		/**
+		* Fetch a table containing all the valid keys of the partitioned table.
+		* @return Promise of a Table
+		* @deprecated
+		*/
+		getKeyTable():Promise<Table>;
+		/**
+		* Fetch the underlying base table of the partitioned table.
+		* @return Promise of a Table
+		*/
+		getBaseTable():Promise<Table>;
+		/**
+		* Indicates that this PartitionedTable will no longer be used, removing subcriptions to updated keys, etc. This
+		* will not affect tables in use.
 		*/
 		close():void;
+		/**
+		* The count of known keys.
+		* @return int
+		*/
+		get size():number;
+		/**
+		* An array of the columns in the tables that can be retrieved from this partitioned table, including both key and
+		* non-key columns.
+		* @return Array of Column
+		*/
+		get columns():Column[];
+		/**
+		* An array of all the key columns that the tables are partitioned by.
+		* @return Array of Column
+		*/
+		get keyColumns():Column[];
+		/**
+		* 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;
-		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
-		nextEvent<T>(eventName:string, timeoutInMillis:number):Promise<CustomEvent<T>>;
+		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
+		* Removes an event listener added to this table.
+		* @param name - 
+		* @param callback - 
+		* @return 
+		* @typeParam T - 
 		*/
-		applySort(sort:Sort[]):Array<Sort>;
+		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();
+	}
+
+	/**
+	* 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;
+	}
+
+	/**
+	* A js type for operating on input tables.
+	*
+	* Represents a User Input Table, which can have data added to it from other sources.
+	*
+	* You may add rows using dictionaries of key-value tuples (representing columns by name), add tables containing all the
+	* key/value columns to add, or delete tables containing the keys to delete. Each operation is atomic, and will either
+	* succeed completely or fail completely. To guarantee order of operations, apply an operation and wait for the response
+	* before sending the next operation.
+	*
+	* Each table has one or more key columns, where each unique combination of keys will appear at most once in the table.
+	*
+	* To view the results of the Input Table, you should use standard table operations on the InputTable's source Table
+	* object.
+	*/
+	export class InputTable {
+		protected constructor();
+
 		/**
-		* 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 
+		* Adds a single row to the table. For each key or value column name in the Input Table, we retrieve that javascript
+		* property at that name and validate it can be put into the given column type.
+		* @param row - 
+		* @param userTimeZone - 
+		* @return Promise of dh.InputTable
 		*/
-		applyCustomColumns(customColumns:Array<string|CustomColumn>):Array<CustomColumn>;
+		addRow(row:{ [key: string]: any; }, userTimeZone?:string):Promise<InputTable>;
 		/**
-		* 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
+		* Add multiple rows to a table.
+		* @param rows - 
+		* @param userTimeZone - 
+		* @return Promise of dh.InputTable
 		*/
-		applyFilter(filter:FilterCondition[]):Array<FilterCondition>;
+		addRows(rows:{ [key: string]: any; }[], userTimeZone?:string):Promise<InputTable>;
 		/**
-		* 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
+		* Add an entire table to this Input Table. Only column names that match the definition of the input table will be
+		* copied, and all key columns must have values filled in. This only copies the current state of the source table;
+		* future updates to the source table will not be reflected in the Input Table. The returned promise will be
+		* resolved to the same InputTable instance this method was called upon once the server returns.
+		* @param tableToAdd - 
+		* @return Promise of dh.InputTable
 		*/
-		get filter():Array<FilterCondition>;
+		addTable(tableToAdd:Table):Promise<InputTable>;
 		/**
-		* True if this table has been closed.
-		* @return boolean
+		* Add multiple tables to this Input Table.
+		* @param tablesToAdd - 
+		* @return Promise of dh.InputTable
 		*/
-		get isClosed():boolean;
+		addTables(tablesToAdd:Table[]):Promise<InputTable>;
 		/**
-		* The total number of rows in this table. This may change as the base table's configuration, filter, or contents
-		* change.
-		* @return double
+		* Deletes an entire table from this Input Table. Key columns must match the Input Table.
+		* @param tableToDelete - 
+		* @return Promise of dh.InputTable
 		*/
-		get size():number;
+		deleteTable(tableToDelete:Table):Promise<InputTable>;
 		/**
-		* 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
+		* Delete multiple tables from this Input Table.
+		* @param tablesToDelete - 
+		* @return 
 		*/
-		get columns():Array<Column>;
-		get totalsTableConfig():TotalsTableConfig;
+		deleteTables(tablesToDelete:Table[]):Promise<InputTable>;
 		/**
-		* 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
+		* A list of the key columns, by name
+		* @return String array.
+		*/
+		get keys():string[];
+		/**
+		* A list of the value columns, by name
+		* @return String array.
+		*/
+		get values():string[];
+		/**
+		* A list of the key columns.
+		* @return Column array.
 		*/
-		get sort():Array<Sort>;
+		get keyColumns():Column[];
 		/**
-		* 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
+		* A list of the value Column objects
+		* @return {@link dh.Column} array.
 		*/
-		get customColumns():Array<CustomColumn>;
+		get valueColumns():Column[];
 		/**
-		* True if this table may receive updates from the server, including size changed events, updated events after
-		* initial snapshot.
-		* @return boolean
+		* The source table for this Input Table
+		* @return dh.table
 		*/
-		get isRefreshing():boolean;
-	}
-	export interface TreeViewportData extends TableData {
-		get offset():number;
-		get columns():Array<Column>;
-		get rows():Array<TreeRow>;
+		get table():Table;
 	}
+
 	/**
-	* Wrap LocalDate values for use in JS. Provides text formatting for display and access to the underlying value.
+	* Deprecated for use in Deephaven Core.
+	* @deprecated
 	*/
-	export interface LocalDateWrapper {
-		valueOf():string;
-		getYear():number;
-		getMonthValue():number;
-		getDayOfMonth():number;
-		toString():string;
+	export class Client {
+		static readonly EVENT_REQUEST_FAILED:string;
+		static readonly EVENT_REQUEST_STARTED:string;
+		static readonly EVENT_REQUEST_SUCCEEDED:string;
+
+		constructor();
 	}
 
 	/**
-	* Represents a set of Tables each corresponding to some key. The keys are available locally, but a call must be made to
-	* the server to get each Table. All tables will have the same structure.
+	* 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 PartitionedTable implements HasEventHandling {
-		/**
-		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
-		*/
-		static readonly EVENT_KEYADDED:string;
-		/**
-		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
-		*/
+	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;
-		/**
-		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
-		*/
 		static readonly EVENT_RECONNECT:string;
-		/**
-		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
-		*/
 		static readonly EVENT_RECONNECTFAILED:string;
+		static readonly EVENT_REQUEST_FAILED:string;
+		static readonly EVENT_REQUEST_SUCCEEDED:string;
+		static readonly SIZE_UNCOALESCED:number;
 
 		protected constructor();
 
-		typedTicket():dhinternal.io.deephaven.proto.ticket_pb.TypedTicket;
+		batch(userCode:(arg0:unknown)=>void):Promise<Table>;
 		/**
-		* Fetch the table with the given key. If the key does not exist, returns `null`.
-		* @param key - The key to fetch. An array of values for each key column, in the same order as the key columns are.
-		* @return Promise of dh.Table, or `null` if the key does not exist.
+		* 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}
 		*/
-		getTable(key:object):Promise<Table|undefined|null>;
+		findColumn(key:string):Column;
 		/**
-		* Open a new table that is the result of merging all constituent tables. See
-		* {@link io.deephaven.engine.table.PartitionedTable#merge()} for details.
-		* @return A merged representation of the constituent tables.
+		* Retrieve multiple columns specified by the given names.
+		* @param keys - 
+		* @return {@link dh.Column} array
 		*/
-		getMergedTable():Promise<Table>;
+		findColumns(keys:string[]):Column[];
+		isBlinkTable():boolean;
 		/**
-		* The set of all currently known keys. This is kept up to date, so getting the list after adding an event listener
-		* for <b>keyadded</b> will ensure no keys are missed.
-		* @return Set of Object
+		* 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
 		*/
-		getKeys():Set<object>;
+		inputTable():Promise<InputTable>;
 		/**
-		* Fetch a table containing all the valid keys of the partitioned table.
-		* @return Promise of a Table
-		* @deprecated
+		* Indicates that this Table instance will no longer be used, and its connection to the server can be cleaned up.
 		*/
-		getKeyTable():Promise<Table>;
+		close():void;
+		getAttributes():string[];
 		/**
-		* Fetch the underlying base table of the partitioned table.
-		* @return Promise of a Table
+		* 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
 		*/
-		getBaseTable():Promise<Table>;
+		getAttribute(attributeName:string):unknown|undefined|null;
 		/**
-		* Indicates that this PartitionedTable will no longer be used, removing subcriptions to updated keys, etc. This
-		* will not affect tables in use.
+		* 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
 		*/
-		close():void;
+		applySort(sort:Sort[]):Array<Sort>;
 		/**
-		* The count of known keys.
-		* @return int
+		* 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
 		*/
-		get size():number;
+		applyFilter(filter:FilterCondition[]):Array<FilterCondition>;
 		/**
-		* An array of the columns in the tables that can be retrieved from this partitioned table, including both key and
-		* non-key columns.
-		* @return Array of Column
+		* used when adding new filter and sort operations to the table, as long as they are present.
+		* @param customColumns - 
+		* @return {@link dh.CustomColumn} array
 		*/
-		get columns():Column[];
+		applyCustomColumns(customColumns:Array<string|CustomColumn>):Array<CustomColumn>;
 		/**
-		* An array of all the key columns that the tables are partitioned by.
-		* @return Array of Column
+		* 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}
 		*/
-		get keyColumns():Column[];
+		setViewport(firstRow:number, lastRow:number, columns?:Array<Column>|undefined|null, updateIntervalMs?:number|undefined|null):TableViewportSubscription;
 		/**
-		* 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
+		* 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}
 		*/
-		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
-		hasListeners(name:string):boolean;
+		getViewportData():Promise<TableData>;
 		/**
-		* Removes an event listener added to this table.
-		* @param name - 
-		* @param callback - 
-		* @return 
-		* @typeParam T - 
+		* 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}
 		*/
-		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
-	}
-
-	/**
-	* Wrap BigDecimal values for use in JS. Provides text formatting for display and access to the underlying value.
-	*/
-	export class BigDecimalWrapper {
-		protected constructor();
-
-		static ofString(value:string):BigDecimalWrapper;
-		asNumber():number;
-		valueOf():string;
-		toString():string;
-	}
-
-	/**
-	* Presently, this is the entrypoint into the Deephaven JS API. By creating an instance of this with the server URL and
-	* some options, JS applications can run code on the server, and interact with available exportable objects.
-	*/
-	export class IdeConnection implements HasEventHandling {
+		subscribe(columns:Array<Column>, updateIntervalMs?:number):TableSubscription;
 		/**
-		* @deprecated
+		* 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
 		*/
-		static readonly HACK_CONNECTION_FAILURE:string;
-		static readonly EVENT_DISCONNECT:string;
-		static readonly EVENT_RECONNECT:string;
-		static readonly EVENT_SHUTDOWN:string;
-
+		selectDistinct(columns:Column[]):Promise<Table>;
 		/**
-		* creates a new instance, from which console sessions can be made. <b>options</b> are optional.
-		* @param serverUrl - The url used when connecting to the server. Read-only.
-		* @param connectOptions - Optional Object
-		* @param fromJava - Optional boolean
-		* @deprecated
+		* 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
 		*/
-		constructor(serverUrl:string, connectOptions?:ConnectOptions, fromJava?:boolean);
-
+		copy():Promise<Table>;
 		/**
-		* closes the current connection, releasing any resources on the server or client.
+		* 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
 		*/
-		close():void;
-		running():Promise<IdeConnection>;
-		getObject(definitionObject:dh.ide.VariableDescriptor):Promise<any>;
-		subscribeToFieldUpdates(callback:(arg0:dh.ide.VariableChanges)=>void):()=>void;
+		getTotalsTable(config?:TotalsTableConfig|undefined|null):Promise<TotalsTable>;
 		/**
-		* Register a callback function to handle any log messages that are emitted on the server. Returns a function ,
-		* which can be invoked to remove this log handler. Any log handler registered in this way will receive as many old
-		* log messages as are presently available.
-		* @param callback - 
-		* @return {@link io.deephaven.web.shared.fu.JsRunnable}
+		* 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
 		*/
-		onLogMessage(callback:(arg0:dh.ide.LogItem)=>void):()=>void;
-		startSession(type:string):Promise<IdeSession>;
-		getConsoleTypes():Promise<Array<string>>;
-		getWorkerHeapInfo():Promise<WorkerHeapInfo>;
+		getGrandTotalsTable(config?:TotalsTableConfig|undefined|null):Promise<TotalsTable>;
 		/**
-		* 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
+		* 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
 		*/
-		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
-		hasListeners(name:string):boolean;
+		rollup(configObject:RollupConfig):Promise<TreeTable>;
 		/**
-		* Removes an event listener added to this table.
-		* @param name - 
-		* @param callback - 
-		* @return 
-		* @typeParam T - 
+		* 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
 		*/
-		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
-	}
-
-	export class IdeSession implements HasEventHandling {
-		static readonly EVENT_COMMANDSTARTED:string;
-		static readonly EVENT_REQUEST_FAILED:string;
-
-		protected constructor();
-
+		treeTable(configObject:TreeTableConfig):Promise<TreeTable>;
 		/**
-		* Load the named table, with columns and size information already fully populated.
-		* @param name - 
-		* @param applyPreviewColumns - optional boolean
-		* @return {@link Promise} of {@link dh.Table}
+		* 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
 		*/
-		getTable(name:string, applyPreviewColumns?:boolean):Promise<Table>;
+		freeze():Promise<Table>;
+		snapshot(baseTable:Table, doInitialSnapshot?:boolean, stampColumns?:string[]):Promise<Table>;
 		/**
-		* Load the named Figure, including its tables and tablemaps as needed.
-		* @param name - 
-		* @return promise of dh.plot.Figure
+		* 
+		* @inheritDoc
+		* @deprecated
 		*/
-		getFigure(name:string):Promise<dh.plot.Figure>;
+		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>;
 		/**
-		* Loads the named tree table or roll-up table, with column data populated. All nodes are collapsed by default, and
-		* size is presently not available until the viewport is first set.
-		* @param name - 
-		* @return {@link Promise} of {@link dh.TreeTable}
+		* 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
 		*/
-		getTreeTable(name:string):Promise<TreeTable>;
-		getHierarchicalTable(name:string):Promise<TreeTable>;
-		getPartitionedTable(name:string):Promise<PartitionedTable>;
-		getObject(definitionObject:dh.ide.VariableDescriptor):Promise<any>;
-		newTable(columnNames:string[], types:string[], data:string[][], userTimeZone:string):Promise<Table>;
+		partitionBy(keys:object, dropKeys?:boolean):Promise<PartitionedTable>;
 		/**
-		* Merges the given tables into a single table. Assumes all tables have the same structure.
-		* @param tables - 
-		* @return {@link Promise} of {@link dh.Table}
+		* a promise that will resolve to ColumnStatistics for the column of this table.
+		* @param column - 
+		* @return Promise of dh.ColumnStatistics
 		*/
-		mergeTables(tables:Table[]):Promise<Table>;
-		bindTableToVariable(table:Table, name:string):Promise<void>;
-		subscribeToFieldUpdates(callback:(arg0:dh.ide.VariableChanges)=>void):()=>void;
-		close():void;
-		runCode(code:string):Promise<dh.ide.CommandResult>;
-		onLogMessage(callback:(arg0:dh.ide.LogItem)=>void):()=>void;
-		openDocument(params:object):void;
-		changeDocument(params:object):void;
-		getCompletionItems(params:object):Promise<Array<dh.lsp.CompletionItem>>;
-		getSignatureHelp(params:object):Promise<Array<dh.lsp.SignatureInformation>>;
-		getHover(params:object):Promise<dh.lsp.Hover>;
-		closeDocument(params:object):void;
+		getColumnStatistics(column:Column):Promise<ColumnStatistics>;
 		/**
-		* Creates an empty table with the specified number of rows. Optionally columns and types may be specified, but all
-		* values will be null.
-		* @param size - 
-		* @return {@link Promise} of {@link dh.Table}
+		* 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.
 		*/
-		emptyTable(size:number):Promise<Table>;
+		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;
 		/**
-		* Creates a new table that ticks automatically every "periodNanos" nanoseconds. A start time may be provided; if so
-		* the table will be populated with the interval from the specified date until now.
-		* @param periodNanos - 
-		* @param startTime - 
-		* @return {@link Promise} of {@link dh.Table}
+		* 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
 		*/
-		timeTable(periodNanos:number, startTime?:DateWrapper):Promise<Table>;
-		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;
-	}
-
-	/**
-	* Configuration object for running Table.treeTable to produce a hierarchical view of a given "flat" table.
-	*
-	* Like TotalsTableConfig, `TreeTableConfig` supports an operation map indicating how to aggregate the data, as well as
-	* an array of column names which will be the layers in the roll-up tree, grouped at each level. An additional optional
-	* value can be provided describing the strategy the engine should use when grouping the rows.
-	*/
-	export class TreeTableConfig {
+		get hasInputTable():boolean;
 		/**
-		* The column representing the unique ID for each item
+		* 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
 		*/
-		idColumn:string;
+		get columns():Array<Column>;
 		/**
-		* The column representing the parent ID for each item
+		* The default configuration to be used when building a <b>TotalsTable</b> for this table.
+		* @return dh.TotalsTableConfig
 		*/
-		parentColumn:string;
+		get totalsTableConfig():TotalsTableConfig;
 		/**
-		* Optional parameter indicating if items with an invalid parent ID should be promoted to root. Defaults to false.
+		* 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
 		*/
-		promoteOrphansToRoot:boolean;
-
-		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.
-	*/
-	export class ConnectOptions {
-		headers:{ [key: string]: string; };
-
-		constructor();
-	}
-
-	/**
-	* 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 FilterValue {
-		protected constructor();
-
+		get sort():Array<Sort>;
 		/**
-		* 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
+		* 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
 		*/
-		static ofNumber(input:LongWrapper|number):FilterValue;
+		get customColumns():Array<CustomColumn>;
 		/**
-		* a filter condition checking if the current value is equal to the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* True if this table may receive updates from the server, including size changed events, updated events after
+		* initial snapshot.
+		* @return boolean
 		*/
-		eq(term:FilterValue):FilterCondition;
+		get isRefreshing():boolean;
 		/**
-		* 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}
+		* 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
 		*/
-		eqIgnoreCase(term:FilterValue):FilterCondition;
+		get filter():Array<FilterCondition>;
 		/**
-		* a filter condition checking if the current value is not equal to the given parameter
-		* @param term - 
-		* @return {@link dh.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
 		*/
-		notEq(term:FilterValue):FilterCondition;
+		get totalSize():number;
 		/**
-		* 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}
+		* 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
 		*/
-		notEqIgnoreCase(term:FilterValue):FilterCondition;
+		get size():number;
 		/**
-		* a filter condition checking if the current value is greater than the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* True if this table has been closed.
+		* @return boolean
 		*/
-		greaterThan(term:FilterValue):FilterCondition;
+		get isClosed():boolean;
 		/**
-		* a filter condition checking if the current value is less than the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* 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
 		*/
-		lessThan(term:FilterValue):FilterCondition;
+		get isUncoalesced():boolean;
 		/**
-		* a filter condition checking if the current value is greater than or equal to the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* 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
 		*/
-		greaterThanOrEqualTo(term:FilterValue):FilterCondition;
+		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
+		hasListeners(name:string):boolean;
 		/**
-		* a filter condition checking if the current value is less than or equal to the given parameter
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* Removes an event listener added to this table.
+		* @param name - 
+		* @param callback - 
+		* @return 
+		* @typeParam T - 
 		*/
-		lessThanOrEqualTo(term:FilterValue):FilterCondition;
+		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
 		/**
-		* a filter condition checking if the current value is in the given set of values
-		* @param terms - 
-		* @return {@link dh.FilterCondition}
+		* 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}
 		*/
-		in(terms:FilterValue[]):FilterCondition;
+		static reverse():Sort;
+	}
+
+
+	/**
+	* Describes the structure of the column, and if desired can be used to get access to the data to be rendered in this
+	* column.
+	*/
+	export class Column {
 		/**
-		* 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}
+		* If this column is part of a roll-up tree table, represents the type of the row data that can be found in this
+		* column for leaf nodes if includeConstituents is enabled. Otherwise, it is <b>null</b>.
+		* @return String
 		*/
-		inIgnoreCase(terms:FilterValue[]):FilterCondition;
+		readonly constituentType?:string|null;
+		readonly description?:string|null;
+
+		protected constructor();
+
 		/**
-		* a filter condition checking that the current value is not in the given set of values
-		* @param terms - 
-		* @return {@link dh.FilterCondition}
+		* the value for this column in the given row. Type will be consistent with the type of the Column.
+		* @param row - 
+		* @return Any
 		*/
-		notIn(terms:FilterValue[]):FilterCondition;
+		get(row:Row):any;
+		getFormat(row:Row):Format;
 		/**
-		* 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}
+		* Creates a sort builder object, to be used when sorting by this column.
+		* @return {@link dh.Sort}
 		*/
-		notInIgnoreCase(terms:FilterValue[]):FilterCondition;
+		sort():Sort;
 		/**
-		* a filter condition checking if the given value contains the given string value
-		* @param term - 
-		* @return {@link dh.FilterCondition}
+		* Creates a new value for use in filters based on this column. Used either as a parameter to another filter
+		* operation, or as a builder to create a filter operation.
+		* @return {@link dh.FilterValue}
 		*/
-		contains(term:FilterValue):FilterCondition;
+		filter():FilterValue;
 		/**
-		* 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}
+		* a <b>CustomColumn</b> object to apply using `applyCustomColumns` with the expression specified.
+		* @param expression - 
+		* @return {@link dh.CustomColumn}
 		*/
-		containsIgnoreCase(term:FilterValue):FilterCondition;
+		formatColor(expression:string):CustomColumn;
 		/**
-		* 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}
+		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
+		* @param expression - 
+		* @return {@link dh.CustomColumn}
 		*/
-		matches(pattern:FilterValue):FilterCondition;
+		formatNumber(expression:string):CustomColumn;
 		/**
-		* 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}
+		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
+		* @param expression - 
+		* @return {@link dh.CustomColumn}
 		*/
-		matchesIgnoreCase(pattern:FilterValue):FilterCondition;
+		formatDate(expression:string):CustomColumn;
+		toString():string;
 		/**
-		* a filter condition checking if the current value is a true boolean
-		* @return {@link dh.FilterCondition}
+		* Label for this column.
+		* @return String
 		*/
-		isTrue():FilterCondition;
+		get name():string;
 		/**
-		* a filter condition checking if the current value is a false boolean
-		* @return {@link dh.FilterCondition}
+		* True if this column is a partition column. Partition columns are used for filtering uncoalesced tables (see
+		* <b>isUncoalesced</b> property on <b>Table</b>)
+		* @return boolean
 		*/
-		isFalse():FilterCondition;
+		get isPartitionColumn():boolean;
 		/**
-		* a filter condition checking if the current value is a null value
-		* @return {@link dh.FilterCondition}
+		* 
+		* @deprecated do not use. Internal index of the column in the table, to be used as a key on the Row.
+		* @return int
 		*/
-		isNull():FilterCondition;
+		get index():number;
+		get isSortable():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 
+		* Type of the row data that can be found in this column.
+		* @return String
 		*/
-		invoke(method:string, ...args:FilterValue[]):FilterCondition;
-		toString():string;
+		get type():string;
 		/**
-		* Constructs a string for the filter API from the given parameter.
-		* @param input - 
-		* @return 
+		* Format entire rows colors using the expression specified. Returns a <b>CustomColumn</b> object to apply to a
+		* table using <b>applyCustomColumns</b> with the parameters specified.
+		* @param expression - 
+		* @return {@link dh.CustomColumn}
 		*/
-		static ofString(input:any):FilterValue;
+		static formatRowColor(expression:string):CustomColumn;
 		/**
-		* Constructs a boolean for the filter API from the given parameter.
-		* @param b - 
-		* @return 
+		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
+		* @param name - 
+		* @param expression - 
+		* @return {@link dh.CustomColumn}
 		*/
-		static ofBoolean(b:boolean):FilterValue;
+		static createCustomColumn(name:string, expression:string):CustomColumn;
 	}
 
+	export class CoreClient implements HasEventHandling {
+		static readonly EVENT_CONNECT:string;
+		static readonly EVENT_DISCONNECT:string;
+		static readonly EVENT_RECONNECT:string;
+		static readonly EVENT_RECONNECT_AUTH_FAILED:string;
+		static readonly EVENT_REFRESH_TOKEN_UPDATED:string;
+		static readonly EVENT_REQUEST_FAILED:string;
+		static readonly EVENT_REQUEST_STARTED:string;
+		static readonly EVENT_REQUEST_SUCCEEDED:string;
+		static readonly LOGIN_TYPE_PASSWORD:string;
+		static readonly LOGIN_TYPE_ANONYMOUS:string;
 
-	/**
-	* Event fired when a command is issued from the client.
-	*/
-	export class CommandInfo {
-		constructor(code:string, result:Promise<dh.ide.CommandResult>);
+		constructor(serverUrl:string, connectOptions?:ConnectOptions);
 
-		get result():Promise<dh.ide.CommandResult>;
-		get code():string;
+		running():Promise<CoreClient>;
+		getServerUrl():string;
+		getAuthConfigValues():Promise<string[][]>;
+		login(credentials:LoginCredentials):Promise<void>;
+		relogin(token:RefreshToken):Promise<void>;
+		onConnected(timeoutInMillis?:number):Promise<void>;
+		getServerConfigValues():Promise<string[][]>;
+		getStorageService():dh.storage.StorageService;
+		getAsIdeConnection():Promise<IdeConnection>;
+		disconnect():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;
 	}
 
 	/**
-	* Exists to keep the dh.TableMap namespace so that the web UI can remain compatible with the DHE API, which still calls
-	* this type TableMap.
-	* @deprecated
+	* 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 TableMap {
-		static readonly EVENT_KEYADDED:string;
-		static readonly EVENT_DISCONNECT:string;
-		static readonly EVENT_RECONNECT:string;
-		static readonly EVENT_RECONNECTFAILED: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;
+		/**
+		* a new iterator over all indexes in this collection.
+		* @return Iterator of {@link dh.LongWrapper}
+		*/
+		iterator():Iterator<LongWrapper>;
+		/**
+		* 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 size():number;
 	}
 
-	export class QueryInfo {
-		static readonly EVENT_TABLE_OPENED:string;
+	/**
+	* Presently, this is the entrypoint into the Deephaven JS API. By creating an instance of this with the server URL and
+	* some options, JS applications can run code on the server, and interact with available exportable objects.
+	*/
+	export class IdeConnection implements HasEventHandling {
+		/**
+		* @deprecated
+		*/
+		static readonly HACK_CONNECTION_FAILURE:string;
 		static readonly EVENT_DISCONNECT:string;
 		static readonly EVENT_RECONNECT:string;
-		static readonly EVENT_CONNECT:string;
+		static readonly EVENT_SHUTDOWN:string;
 
-		protected constructor();
+		/**
+		* creates a new instance, from which console sessions can be made. <b>options</b> are optional.
+		* @param serverUrl - The url used when connecting to the server. Read-only.
+		* @param connectOptions - Optional Object
+		* @param fromJava - Optional boolean
+		* @deprecated
+		*/
+		constructor(serverUrl:string, connectOptions?:ConnectOptions, fromJava?:boolean);
+
+		/**
+		* closes the current connection, releasing any resources on the server or client.
+		*/
+		close():void;
+		running():Promise<IdeConnection>;
+		getObject(definitionObject:dh.ide.VariableDescriptor):Promise<any>;
+		subscribeToFieldUpdates(callback:(arg0:dh.ide.VariableChanges)=>void):()=>void;
+		/**
+		* Register a callback function to handle any log messages that are emitted on the server. Returns a function ,
+		* which can be invoked to remove this log handler. Any log handler registered in this way will receive as many old
+		* log messages as are presently available.
+		* @param callback - 
+		* @return {@link io.deephaven.web.shared.fu.JsRunnable}
+		*/
+		onLogMessage(callback:(arg0:dh.ide.LogItem)=>void):()=>void;
+		startSession(type:string):Promise<IdeSession>;
+		getConsoleTypes():Promise<Array<string>>;
+		getWorkerHeapInfo():Promise<WorkerHeapInfo>;
+		/**
+		* 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;
 	}
 
 	/**
@@ -1251,530 +1493,367 @@ export namespace dh {
 	}
 
 	/**
-	* Describes a Sort present on the table. No visible constructor, created through the use of Column.sort(), will be tied
-	* to that particular column data. Sort instances are immutable, and use a builder pattern to make modifications. All
-	* methods return a new Sort instance.
+	* 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 Sort {
-		static readonly ASCENDING:string;
-		static readonly DESCENDING:string;
-		static readonly REVERSE:string;
+	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;
 
 		protected constructor();
 
 		/**
-		* Builds a Sort instance to sort values in ascending order.
-		* @return {@link dh.Sort}
-		*/
-		asc():Sort;
-		/**
-		* Builds a Sort instance to sort values in descending order.
-		* @return {@link dh.Sort}
-		*/
-		desc():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
+		* Stops the subscription on the server.
 		*/
-		get isAbs():boolean;
+		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;
 		/**
-		* The column which is sorted.
+		* The columns that were subscribed to when this subscription was created
 		* @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;
+		get columns():Array<Column>;
 	}
 
-	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;
+	/**
+	* Event fired when a command is issued from the client.
+	*/
+	export class CommandInfo {
+		constructor(code:string, result:Promise<dh.ide.CommandResult>);
 
-		protected constructor();
+		get result():Promise<dh.ide.CommandResult>;
+		get code():string;
+	}
 
-		valueOf():string;
-		toString():string;
+	/**
+	* Configuration object for running Table.treeTable to produce a hierarchical view of a given "flat" table.
+	*
+	* Like TotalsTableConfig, `TreeTableConfig` supports an operation map indicating how to aggregate the data, as well as
+	* an array of column names which will be the layers in the roll-up tree, grouped at each level. An additional optional
+	* value can be provided describing the strategy the engine should use when grouping the rows.
+	*/
+	export class TreeTableConfig {
 		/**
-		* The expression to evaluate this custom column.
-		* @return String
+		* The column representing the unique ID for each item
 		*/
-		get expression():string;
+		idColumn:string;
 		/**
-		* The name of the column to use.
-		* @return String
+		* The column representing the parent ID for each item
 		*/
-		get name():string;
+		parentColumn: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
+		* Optional parameter indicating if items with an invalid parent ID should be promoted to root. Defaults to false.
 		*/
-		get type():string;
+		promoteOrphansToRoot:boolean;
+
+		constructor();
 	}
 
-	/**
-	* 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;
+	export class LoginCredentials {
+		type?:string|null;
+		username?:string|null;
+		token?:string|null;
 
+		constructor();
+	}
+
+	export class LongWrapper {
 		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;
+		static ofString(str:string):LongWrapper;
+		asNumber():number;
+		valueOf():string;
+		toString():string;
+	}
+
+	export class Ide {
+		constructor();
+
 		/**
-		* 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
+		* @deprecated
 		*/
-		selectDistinct(columns:Column[]):Promise<Table>;
+		getExistingSession(websocketUrl:string, authToken:string, serviceId:string, language:string):Promise<IdeSession>;
 		/**
-		* 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
+		* @deprecated
 		*/
-		copy():Promise<Table>;
+		static getExistingSession(websocketUrl:string, authToken:string, serviceId:string, language:string):Promise<IdeSession>;
+	}
+
+	/**
+	* 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 FilterValue {
+		protected constructor();
+
 		/**
-		* 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
+		* 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
 		*/
-		getTotalsTable(config?:TotalsTableConfig|undefined|null):Promise<TotalsTable>;
+		static ofNumber(input:LongWrapper|number):FilterValue;
 		/**
-		* 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
+		* a filter condition checking if the current value is equal to the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		getGrandTotalsTable(config?:TotalsTableConfig|undefined|null):Promise<TotalsTable>;
+		eq(term:FilterValue):FilterCondition;
 		/**
-		* 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
+		* 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}
 		*/
-		rollup(configObject:RollupConfig):Promise<TreeTable>;
+		eqIgnoreCase(term:FilterValue):FilterCondition;
 		/**
-		* 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
+		* a filter condition checking if the current value is not equal to the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		treeTable(configObject:TreeTableConfig):Promise<TreeTable>;
+		notEq(term:FilterValue):FilterCondition;
 		/**
-		* 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
+		* 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}
 		*/
-		freeze():Promise<Table>;
-		snapshot(baseTable:Table, doInitialSnapshot?:boolean, stampColumns?:string[]):Promise<Table>;
+		notEqIgnoreCase(term:FilterValue):FilterCondition;
 		/**
-		* 
-		* @inheritDoc
-		* @deprecated
+		* a filter condition checking if the current value is greater than the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		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>;
+		greaterThan(term:FilterValue):FilterCondition;
 		/**
-		* 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
+		* a filter condition checking if the current value is less than the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		partitionBy(keys:object, dropKeys?:boolean):Promise<PartitionedTable>;
+		lessThan(term:FilterValue):FilterCondition;
 		/**
-		* a promise that will resolve to ColumnStatistics for the column of this table.
-		* @param column - 
-		* @return Promise of dh.ColumnStatistics
+		* a filter condition checking if the current value is greater than or equal to the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		getColumnStatistics(column:Column):Promise<ColumnStatistics>;
+		greaterThanOrEqualTo(term:FilterValue):FilterCondition;
 		/**
-		* 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.
+		* a filter condition checking if the current value is less than or equal to the given parameter
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		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;
+		lessThanOrEqualTo(term:FilterValue):FilterCondition;
 		/**
-		* 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
+		* a filter condition checking if the current value is in the given set of values
+		* @param terms - 
+		* @return {@link dh.FilterCondition}
 		*/
-		get hasInputTable():boolean;
+		in(terms:FilterValue[]):FilterCondition;
 		/**
-		* 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
+		* 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}
 		*/
-		get columns():Array<Column>;
+		inIgnoreCase(terms:FilterValue[]):FilterCondition;
 		/**
-		* The default configuration to be used when building a <b>TotalsTable</b> for this table.
-		* @return dh.TotalsTableConfig
+		* a filter condition checking that the current value is not in the given set of values
+		* @param terms - 
+		* @return {@link dh.FilterCondition}
 		*/
-		get totalsTableConfig():TotalsTableConfig;
+		notIn(terms:FilterValue[]):FilterCondition;
 		/**
-		* 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
+		* 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}
 		*/
-		get sort():Array<Sort>;
+		notInIgnoreCase(terms:FilterValue[]):FilterCondition;
 		/**
-		* 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
+		* a filter condition checking if the given value contains the given string value
+		* @param term - 
+		* @return {@link dh.FilterCondition}
 		*/
-		get customColumns():Array<CustomColumn>;
+		contains(term:FilterValue):FilterCondition;
 		/**
-		* True if this table may receive updates from the server, including size changed events, updated events after
-		* initial snapshot.
-		* @return boolean
+		* 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}
 		*/
-		get isRefreshing():boolean;
+		containsIgnoreCase(term:FilterValue):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
+		* 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}
 		*/
-		get filter():Array<FilterCondition>;
+		matches(pattern:FilterValue):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
+		* 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}
 		*/
-		get totalSize():number;
+		matchesIgnoreCase(pattern:FilterValue):FilterCondition;
 		/**
-		* 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
+		* a filter condition checking if the current value is a true boolean
+		* @return {@link dh.FilterCondition}
 		*/
-		get size():number;
+		isTrue():FilterCondition;
 		/**
-		* True if this table has been closed.
-		* @return boolean
+		* a filter condition checking if the current value is a false boolean
+		* @return {@link dh.FilterCondition}
 		*/
-		get isClosed():boolean;
+		isFalse():FilterCondition;
 		/**
-		* 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
+		* a filter condition checking if the current value is a null value
+		* @return {@link dh.FilterCondition}
 		*/
-		get isUncoalesced():boolean;
+		isNull():FilterCondition;
 		/**
-		* 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
+		* 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 
 		*/
-		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
-		hasListeners(name:string):boolean;
+		invoke(method:string, ...args:FilterValue[]):FilterCondition;
+		toString():string;
 		/**
-		* Removes an event listener added to this table.
-		* @param name - 
-		* @param callback - 
+		* Constructs a string for the filter API from the given parameter.
+		* @param input - 
 		* @return 
-		* @typeParam T - 
 		*/
-		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
+		static ofString(input:any):FilterValue;
 		/**
-		* 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}
+		* Constructs a boolean for the filter API from the given parameter.
+		* @param b - 
+		* @return 
 		*/
-		static reverse():Sort;
+		static ofBoolean(b:boolean):FilterValue;
 	}
 
-	export class Ide {
-		constructor();
+	export class DateWrapper extends LongWrapper {
+		protected constructor();
+
+		static ofJsDate(date:Date):DateWrapper;
+		asDate():Date;
+	}
 
+	/**
+	* 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 {
 		/**
 		* @deprecated
 		*/
-		getExistingSession(websocketUrl:string, authToken:string, serviceId:string, language:string):Promise<IdeSession>;
+		static readonly COUNT:string;
 		/**
 		* @deprecated
 		*/
-		static getExistingSession(websocketUrl:string, authToken:string, serviceId:string, language:string):Promise<IdeSession>;
-	}
-
-	export class CoreClient implements HasEventHandling {
-		static readonly EVENT_CONNECT:string;
-		static readonly EVENT_DISCONNECT:string;
-		static readonly EVENT_RECONNECT:string;
-		static readonly EVENT_RECONNECT_AUTH_FAILED:string;
-		static readonly EVENT_REFRESH_TOKEN_UPDATED:string;
-		static readonly EVENT_REQUEST_FAILED:string;
-		static readonly EVENT_REQUEST_STARTED:string;
-		static readonly EVENT_REQUEST_SUCCEEDED:string;
-		static readonly LOGIN_TYPE_PASSWORD:string;
-		static readonly LOGIN_TYPE_ANONYMOUS:string;
-
-		constructor(serverUrl:string, connectOptions?:ConnectOptions);
-
-		running():Promise<CoreClient>;
-		getServerUrl():string;
-		getAuthConfigValues():Promise<string[][]>;
-		login(credentials:LoginCredentials):Promise<void>;
-		relogin(token:RefreshToken):Promise<void>;
-		onConnected(timeoutInMillis?:number):Promise<void>;
-		getServerConfigValues():Promise<string[][]>;
-		getStorageService():dh.storage.StorageService;
-		getAsIdeConnection():Promise<IdeConnection>;
-		disconnect():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;
-	}
-
-	/**
-	* Describes the structure of the column, and if desired can be used to get access to the data to be rendered in this
-	* column.
-	*/
-	export class Column {
+		static readonly MIN:string;
 		/**
-		* If this column is part of a roll-up tree table, represents the type of the row data that can be found in this
-		* column for leaf nodes if includeConstituents is enabled. Otherwise, it is <b>null</b>.
-		* @return String
+		* @deprecated
 		*/
-		readonly constituentType?:string|null;
-		readonly description?:string|null;
-
-		protected constructor();
-
+		static readonly MAX:string;
 		/**
-		* the value for this column in the given row. Type will be consistent with the type of the Column.
-		* @param row - 
-		* @return Any
+		* @deprecated
 		*/
-		get(row:Row):any;
-		getFormat(row:Row):Format;
+		static readonly SUM:string;
 		/**
-		* Creates a sort builder object, to be used when sorting by this column.
-		* @return {@link dh.Sort}
+		* @deprecated
 		*/
-		sort():Sort;
+		static readonly ABS_SUM:string;
 		/**
-		* Creates a new value for use in filters based on this column. Used either as a parameter to another filter
-		* operation, or as a builder to create a filter operation.
-		* @return {@link dh.FilterValue}
+		* @deprecated
 		*/
-		filter():FilterValue;
+		static readonly VAR:string;
 		/**
-		* a <b>CustomColumn</b> object to apply using `applyCustomColumns` with the expression specified.
-		* @param expression - 
-		* @return {@link dh.CustomColumn}
+		* @deprecated
 		*/
-		formatColor(expression:string):CustomColumn;
+		static readonly AVG:string;
 		/**
-		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
-		* @param expression - 
-		* @return {@link dh.CustomColumn}
+		* @deprecated
 		*/
-		formatNumber(expression:string):CustomColumn;
+		static readonly STD:string;
 		/**
-		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
-		* @param expression - 
-		* @return {@link dh.CustomColumn}
+		* @deprecated
 		*/
-		formatDate(expression:string):CustomColumn;
-		toString():string;
+		static readonly FIRST:string;
 		/**
-		* Label for this column.
-		* @return String
+		* @deprecated
 		*/
-		get name():string;
+		static readonly LAST:string;
 		/**
-		* True if this column is a partition column. Partition columns are used for filtering uncoalesced tables (see
-		* <b>isUncoalesced</b> property on <b>Table</b>)
-		* @return boolean
+		* @deprecated
 		*/
-		get isPartitionColumn():boolean;
+		static readonly SKIP:string;
 		/**
-		* 
-		* @deprecated do not use. Internal index of the column in the table, to be used as a key on the Row.
-		* @return int
+		* Specifies if a Totals Table should be expanded by default in the UI. Defaults to false.
 		*/
-		get index():number;
-		get isSortable():boolean;
+		showTotalsByDefault:boolean;
 		/**
-		* Type of the row data that can be found in this column.
-		* @return String
+		* Specifies if a Grand Totals Table should be expanded by default in the UI. Defaults to false.
 		*/
-		get type():string;
+		showGrandTotalsByDefault:boolean;
 		/**
-		* Format entire rows colors using the expression specified. Returns a <b>CustomColumn</b> object to apply to a
-		* table using <b>applyCustomColumns</b> with the parameters specified.
-		* @param expression - 
-		* @return {@link dh.CustomColumn}
+		* Specifies the default operation for columns that do not have a specific operation applied; defaults to "Sum".
 		*/
-		static formatRowColor(expression:string):CustomColumn;
+		defaultOperation:AggregationOperationType;
 		/**
-		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
-		* @param name - 
-		* @param expression - 
-		* @return {@link dh.CustomColumn}
+		* 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 createCustomColumn(name:string, expression:string):CustomColumn;
-	}
-
-	export class LoginCredentials {
-		type?:string|null;
-		username?:string|null;
-		token?:string|null;
+		operationMap:{ [key: string]: Array<AggregationOperationType>; };
+		/**
+		* 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`.
+		*/
+		groupBy:Array<string>;
 
 		constructor();
+
+		toString():string;
 	}
 
 	/**
@@ -1807,6 +1886,89 @@ export namespace dh {
 		constructor();
 	}
 
+	/**
+	* 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.
+	*/
+	export class ConnectOptions {
+		headers:{ [key: string]: string; };
+
+		constructor();
+	}
+
+	/**
+	* 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 FilterCondition {
+		protected constructor();
+
+		/**
+		* the opposite of this condition
+		* @return FilterCondition
+		*/
+		not():FilterCondition;
+		/**
+		* a condition representing the current condition logically ANDed with the other parameters
+		* @param filters - 
+		* @return FilterCondition
+		*/
+		and(...filters:FilterCondition[]):FilterCondition;
+		/**
+		* a condition representing the current condition logically ORed with the other parameters
+		* @param filters - 
+		* @return FilterCondition.
+		*/
+		or(...filters:FilterCondition[]):FilterCondition;
+		/**
+		* a string suitable for debugging showing the details of this condition.
+		* @return String.
+		*/
+		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;
+	}
+
 	/**
 	* Behaves like a {@link dh.Table} externally, but data, state, and viewports are managed by an entirely different
 	* mechanism, and so reimplemented here.
@@ -1974,394 +2136,241 @@ export namespace dh {
 		get includeConstituents():boolean;
 		get groupedColumns():Array<Column>;
 		/**
-		* True if this table has been closed.
-		* @return boolean
-		*/
-		get isClosed():boolean;
-		/**
-		* The current number of rows given the table's contents and the various expand/collapse states of each node. (No
-		* totalSize is provided at this time; its definition becomes unclear between roll-up and tree tables, especially
-		* when considering collapse/expand states).
-		* @return double
-		*/
-		get size():number;
-		/**
-		* The columns that can be shown in this Tree Table.
-		* @return {@link dh.Column} array
-		*/
-		get columns():Array<Column>;
-		/**
-		* The current sort configuration of this Tree Table
-		* @return {@link dh.Sort} array.
-		*/
-		get sort():Array<Sort>;
-		/**
-		* True if this table may receive updates from the server, including size changed events, updated events after
-		* initial snapshot.
-		* @return boolean
-		*/
-		get isRefreshing():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;
-	}
-
-	/**
-	* 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();
-	}
-
-	export class LongWrapper {
-		protected constructor();
-
-		static ofString(str:string):LongWrapper;
-		asNumber():number;
-		valueOf():string;
-		toString():string;
-	}
-
-	/**
-	* 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;
-		/**
-		* a new iterator over all indexes in this collection.
-		* @return Iterator of {@link dh.LongWrapper}
-		*/
-		iterator():Iterator<LongWrapper>;
-		/**
-		* 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 size():number;
-	}
-
-	/**
-	* 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 FilterCondition {
-		protected constructor();
-
-		/**
-		* the opposite of this condition
-		* @return FilterCondition
-		*/
-		not():FilterCondition;
-		/**
-		* a condition representing the current condition logically ANDed with the other parameters
-		* @param filters - 
-		* @return FilterCondition
-		*/
-		and(...filters:FilterCondition[]):FilterCondition;
-		/**
-		* a condition representing the current condition logically ORed with the other parameters
-		* @param filters - 
-		* @return FilterCondition.
-		*/
-		or(...filters:FilterCondition[]):FilterCondition;
-		/**
-		* a string suitable for debugging showing the details of this condition.
-		* @return String.
-		*/
-		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 {
-		/**
-		* 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;
-
-		protected constructor();
-
-		/**
-		* Stops the subscription on the server.
-		*/
-		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;
-		/**
-		* The columns that were subscribed to when this subscription was created
-		* @return {@link dh.Column}
-		*/
-		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 {
-		/**
-		* @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
+		* True if this table has been closed.
+		* @return boolean
 		*/
-		static readonly LAST:string;
+		get isClosed():boolean;
 		/**
-		* @deprecated
+		* The current number of rows given the table's contents and the various expand/collapse states of each node. (No
+		* totalSize is provided at this time; its definition becomes unclear between roll-up and tree tables, especially
+		* when considering collapse/expand states).
+		* @return double
 		*/
-		static readonly SKIP:string;
+		get size():number;
 		/**
-		* Specifies if a Totals Table should be expanded by default in the UI. Defaults to false.
+		* The columns that can be shown in this Tree Table.
+		* @return {@link dh.Column} array
 		*/
-		showTotalsByDefault:boolean;
+		get columns():Array<Column>;
 		/**
-		* Specifies if a Grand Totals Table should be expanded by default in the UI. Defaults to false.
+		* The current sort configuration of this Tree Table
+		* @return {@link dh.Sort} array.
 		*/
-		showGrandTotalsByDefault:boolean;
+		get sort():Array<Sort>;
 		/**
-		* Specifies the default operation for columns that do not have a specific operation applied; defaults to "Sum".
+		* True if this table may receive updates from the server, including size changed events, updated events after
+		* initial snapshot.
+		* @return boolean
 		*/
-		defaultOperation:AggregationOperationType;
+		get isRefreshing():boolean;
 		/**
-		* 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.
+		* 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
 		*/
-		operationMap:{ [key: string]: Array<AggregationOperationType>; };
+		addEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<CustomEvent<T>>;
+		hasListeners(name:string):boolean;
 		/**
-		* 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`.
+		* Removes an event listener added to this table.
+		* @param name - 
+		* @param callback - 
+		* @return 
+		* @typeParam T - 
 		*/
-		groupBy:Array<string>;
+		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
+	}
 
-		constructor();
+	/**
+	* Wrap BigDecimal values for use in JS. Provides text formatting for display and access to the underlying value.
+	*/
+	export class BigDecimalWrapper {
+		protected constructor();
 
+		static ofString(value:string):BigDecimalWrapper;
+		asNumber():number;
+		valueOf():string;
 		toString():string;
 	}
 
 	/**
-	* A js type for operating on input tables.
-	*
-	* Represents a User Input Table, which can have data added to it from other sources.
-	*
-	* You may add rows using dictionaries of key-value tuples (representing columns by name), add tables containing all the
-	* key/value columns to add, or delete tables containing the keys to delete. Each operation is atomic, and will either
-	* succeed completely or fail completely. To guarantee order of operations, apply an operation and wait for the response
-	* before sending the next operation.
-	*
-	* Each table has one or more key columns, where each unique combination of keys will appear at most once in the table.
-	*
-	* To view the results of the Input Table, you should use standard table operations on the InputTable's source Table
-	* object.
+	* Exists to keep the dh.TableMap namespace so that the web UI can remain compatible with the DHE API, which still calls
+	* this type TableMap.
+	* @deprecated
 	*/
-	export class InputTable {
+	export class TableMap {
+		static readonly EVENT_KEYADDED:string;
+		static readonly EVENT_DISCONNECT:string;
+		static readonly EVENT_RECONNECT:string;
+		static readonly EVENT_RECONNECTFAILED:string;
+
+		protected constructor();
+	}
+
+	/**
+	* Describes a Sort present on the table. No visible constructor, created through the use of Column.sort(), will be tied
+	* to that particular column data. Sort instances are immutable, and use a builder pattern to make modifications. All
+	* methods return a new Sort instance.
+	*/
+	export class Sort {
+		static readonly ASCENDING:string;
+		static readonly DESCENDING:string;
+		static readonly REVERSE:string;
+
 		protected constructor();
 
 		/**
-		* Adds a single row to the table. For each key or value column name in the Input Table, we retrieve that javascript
-		* property at that name and validate it can be put into the given column type.
-		* @param row - 
-		* @param userTimeZone - 
-		* @return Promise of dh.InputTable
-		*/
-		addRow(row:{ [key: string]: any; }, userTimeZone?:string):Promise<InputTable>;
-		/**
-		* Add multiple rows to a table.
-		* @param rows - 
-		* @param userTimeZone - 
-		* @return Promise of dh.InputTable
-		*/
-		addRows(rows:{ [key: string]: any; }[], userTimeZone?:string):Promise<InputTable>;
-		/**
-		* Add an entire table to this Input Table. Only column names that match the definition of the input table will be
-		* copied, and all key columns must have values filled in. This only copies the current state of the source table;
-		* future updates to the source table will not be reflected in the Input Table. The returned promise will be
-		* resolved to the same InputTable instance this method was called upon once the server returns.
-		* @param tableToAdd - 
-		* @return Promise of dh.InputTable
+		* Builds a Sort instance to sort values in ascending order.
+		* @return {@link dh.Sort}
 		*/
-		addTable(tableToAdd:Table):Promise<InputTable>;
+		asc():Sort;
 		/**
-		* Add multiple tables to this Input Table.
-		* @param tablesToAdd - 
-		* @return Promise of dh.InputTable
+		* Builds a Sort instance to sort values in descending order.
+		* @return {@link dh.Sort}
 		*/
-		addTables(tablesToAdd:Table[]):Promise<InputTable>;
+		desc():Sort;
 		/**
-		* Deletes an entire table from this Input Table. Key columns must match the Input Table.
-		* @param tableToDelete - 
-		* @return Promise of dh.InputTable
+		* Builds a Sort instance which takes the absolute value before applying order.
+		* @return {@link dh.Sort}
 		*/
-		deleteTable(tableToDelete:Table):Promise<InputTable>;
+		abs():Sort;
+		toString():string;
 		/**
-		* Delete multiple tables from this Input Table.
-		* @param tablesToDelete - 
-		* @return 
+		* True if the absolute value of the column should be used when sorting; defaults to false.
+		* @return boolean
 		*/
-		deleteTables(tablesToDelete:Table[]):Promise<InputTable>;
+		get isAbs():boolean;
 		/**
-		* A list of the key columns, by name
-		* @return String array.
+		* The column which is sorted.
+		* @return {@link dh.Column}
 		*/
-		get keys():string[];
+		get column():Column;
 		/**
-		* A list of the value columns, by name
-		* @return String array.
+		* The direction of this sort, either <b>ASC</b>, <b>DESC</b>, or <b>REVERSE</b>.
+		* @return String
 		*/
-		get values():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;
 		/**
-		* A list of the key columns.
-		* @return Column array.
+		* The expression to evaluate this custom column.
+		* @return String
 		*/
-		get keyColumns():Column[];
+		get expression():string;
 		/**
-		* A list of the value Column objects
-		* @return {@link dh.Column} array.
+		* The name of the column to use.
+		* @return String
 		*/
-		get valueColumns():Column[];
+		get name():string;
 		/**
-		* The source table for this Input Table
-		* @return dh.table
+		* 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 table():Table;
+		get type():string;
 	}
 
-	export class DateWrapper extends LongWrapper {
+	export class IdeSession implements HasEventHandling {
+		static readonly EVENT_COMMANDSTARTED:string;
+		static readonly EVENT_REQUEST_FAILED:string;
+
 		protected constructor();
 
-		static ofJsDate(date:Date):DateWrapper;
-		asDate():Date;
+		/**
+		* Load the named table, with columns and size information already fully populated.
+		* @param name - 
+		* @param applyPreviewColumns - optional boolean
+		* @return {@link Promise} of {@link dh.Table}
+		*/
+		getTable(name:string, applyPreviewColumns?:boolean):Promise<Table>;
+		/**
+		* Load the named Figure, including its tables and tablemaps as needed.
+		* @param name - 
+		* @return promise of dh.plot.Figure
+		*/
+		getFigure(name:string):Promise<dh.plot.Figure>;
+		/**
+		* Loads the named tree table or roll-up table, with column data populated. All nodes are collapsed by default, and
+		* size is presently not available until the viewport is first set.
+		* @param name - 
+		* @return {@link Promise} of {@link dh.TreeTable}
+		*/
+		getTreeTable(name:string):Promise<TreeTable>;
+		getHierarchicalTable(name:string):Promise<TreeTable>;
+		getPartitionedTable(name:string):Promise<PartitionedTable>;
+		getObject(definitionObject:dh.ide.VariableDescriptor):Promise<any>;
+		newTable(columnNames:string[], types:string[], data:string[][], userTimeZone:string):Promise<Table>;
+		/**
+		* Merges the given tables into a single table. Assumes all tables have the same structure.
+		* @param tables - 
+		* @return {@link Promise} of {@link dh.Table}
+		*/
+		mergeTables(tables:Table[]):Promise<Table>;
+		bindTableToVariable(table:Table, name:string):Promise<void>;
+		subscribeToFieldUpdates(callback:(arg0:dh.ide.VariableChanges)=>void):()=>void;
+		close():void;
+		runCode(code:string):Promise<dh.ide.CommandResult>;
+		onLogMessage(callback:(arg0:dh.ide.LogItem)=>void):()=>void;
+		openDocument(params:object):void;
+		changeDocument(params:object):void;
+		getCompletionItems(params:object):Promise<Array<dh.lsp.CompletionItem>>;
+		getSignatureHelp(params:object):Promise<Array<dh.lsp.SignatureInformation>>;
+		getHover(params:object):Promise<dh.lsp.Hover>;
+		closeDocument(params:object):void;
+		/**
+		* Creates an empty table with the specified number of rows. Optionally columns and types may be specified, but all
+		* values will be null.
+		* @param size - 
+		* @return {@link Promise} of {@link dh.Table}
+		*/
+		emptyTable(size:number):Promise<Table>;
+		/**
+		* Creates a new table that ticks automatically every "periodNanos" nanoseconds. A start time may be provided; if so
+		* the table will be populated with the interval from the specified date until now.
+		* @param periodNanos - 
+		* @param startTime - 
+		* @return {@link Promise} of {@link dh.Table}
+		*/
+		timeTable(periodNanos:number, startTime?:DateWrapper):Promise<Table>;
+		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;
 	}
 
 
-	type SearchDisplayModeType = string;
-	export class SearchDisplayMode {
-		static readonly SEARCH_DISPLAY_DEFAULT:SearchDisplayModeType;
-		static readonly SEARCH_DISPLAY_HIDE:SearchDisplayModeType;
-		static readonly SEARCH_DISPLAY_SHOW:SearchDisplayModeType;
+	/**
+	* A set of string constants that can be used to describe the different objects the JS API can export.
+	*/
+	type VariableTypeType = string;
+	export class VariableType {
+		static readonly TABLE:VariableTypeType;
+		static readonly TREETABLE:VariableTypeType;
+		static readonly HIERARCHICALTABLE:VariableTypeType;
+		static readonly TABLEMAP:VariableTypeType;
+		static readonly PARTITIONEDTABLE:VariableTypeType;
+		static readonly FIGURE:VariableTypeType;
+		static readonly OTHERWIDGET:VariableTypeType;
+		static readonly PANDAS:VariableTypeType;
+		static readonly TREEMAP:VariableTypeType;
 	}
 
 	/**
@@ -2385,6 +2394,13 @@ export namespace dh {
 		static readonly SKIP:AggregationOperationType;
 	}
 
+	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;
@@ -2395,34 +2411,10 @@ export namespace dh {
 		static readonly BOOLEAN:ValueTypeType;
 	}
 
-	/**
-	* A set of string constants that can be used to describe the different objects the JS API can export.
-	*/
-	type VariableTypeType = string;
-	export class VariableType {
-		static readonly TABLE:VariableTypeType;
-		static readonly TREETABLE:VariableTypeType;
-		static readonly HIERARCHICALTABLE:VariableTypeType;
-		static readonly TABLEMAP:VariableTypeType;
-		static readonly PARTITIONEDTABLE:VariableTypeType;
-		static readonly FIGURE:VariableTypeType;
-		static readonly OTHERWIDGET:VariableTypeType;
-		static readonly PANDAS:VariableTypeType;
-		static readonly TREEMAP:VariableTypeType;
-	}
-
 }
 
 export namespace dh.ide {
 
-	/**
-	* Specifies a type and either id or name (but not both).
-	*/
-	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.
@@ -2445,30 +2437,6 @@ export namespace dh.ide {
 		get message():string;
 	}
 	/**
-	* 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 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>;
-	}
-	/**
 	* Indicates the result of code run on the server.
 	*/
 	export interface CommandResult {
@@ -2511,22 +2479,206 @@ export namespace dh.ide {
 		* The name of the variable, to be used when rendering it to a user
 		* @return String
 		*/
-		get title():string;
+		get title():string;
+		/**
+		* Optional description for the variable's contents, typically used to provide more detail that wouldn't be
+		* reasonable to put in the title
+		* @return String
+		*/
+		get applicationId():string;
+		/**
+		* The name of the application which provided this variable
+		* @return String
+		*/
+		get applicationName():string;
+	}
+	/**
+	* 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 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>;
+	}
+	/**
+	* Specifies a type and either id or name (but not both).
+	*/
+	export interface VariableDescriptor {
+		type:string;
+		id?:string|null;
+		name?:string|null;
+	}
+}
+
+export namespace dh.i18n {
+
+	/**
+	* Exported wrapper of the GWT NumberFormat, plus LongWrapper support
+	*
+	* Utility class to parse and format numbers, using the same format patterns as are supported by the standard Java
+	* implementation used in the Deephaven server and swing client. Works for numeric types including BigInteger and
+	* BigDecimal.
+	*/
+	export class NumberFormat {
+		/**
+		* Creates a new number format instance. This generally should be avoided in favor of the static `getFormat`
+		* function, which will create and cache an instance so that later calls share the same instance.
+		* @param pattern - 
+		*/
+		constructor(pattern:string);
+
+		/**
+		* a number format instance matching the specified format. If this format has not been specified before, a new
+		* instance will be created and cached for later reuse. Prefer this method to calling the constructor directly to
+		* take advantage of caching
+		* @param pattern - 
+		* @return dh.i18n.NumberFormat
+		*/
+		static getFormat(pattern:string):NumberFormat;
+		/**
+		* Parses the given text using the cached format matching the given pattern.
+		* @param pattern - 
+		* @param text - 
+		* @return double
+		*/
+		static parse(pattern:string, text:string):number;
+		/**
+		* Formats the specified number (or Java <b>long</b>, <b>BigInteger</b> or <b>BigDecimal</b> value) using the cached
+		* format matching the given pattern string.
+		* @param pattern - 
+		* @param number - 
+		* @return String
+		*/
+		static format(pattern:string, number:number|dh.BigIntegerWrapper|dh.BigDecimalWrapper|dh.LongWrapper):string;
+		/**
+		* Parses the given text using this instance's pattern into a JS Number.
+		* @param text - 
+		* @return double
+		*/
+		parse(text:string):number;
+		/**
+		* Formats the specified number (or Java `long`, `BigInteger` or `BigDecimal` value) using this instance's pattern.
+		* @param number - 
+		* @return String
+		*/
+		format(number:number|dh.BigIntegerWrapper|dh.BigDecimalWrapper|dh.LongWrapper):string;
+		toString():string;
+	}
+
+
+	/**
+	* Largely an exported wrapper for the GWT DateFormat, but also includes support for formatting nanoseconds as an
+	* additional 6 decimal places after the rest of the number.
+	*
+	* Other concerns that this handles includes accepting a js Date and ignoring the lack of nanos, accepting a js Number
+	* and assuming it to be a lossy nano value, and parsing into a js Date.
+	*
+	*
+	* Utility class to parse and format various date/time values, using the same format patterns as are supported by the
+	* standard Java implementation used in the Deephaven server and swing client.
+	*
+	* As Deephaven internally uses nanosecond precision to record dates, this API expects nanoseconds in most use cases,
+	* with the one exception of the JS `Date` type, which is not capable of more precision than milliseconds. Note,
+	* however, that when passing nanoseconds as a JS `Number` there is likely to be some loss of precision, though this is
+	* still supported for easier interoperability with other JS code. The values returned by `parse()` will be an opaque
+	* object wrapping the full precision of the specified date, However, this object supports `toString()` and `valueOf()`
+	* to return a string representation of that value, as well as a `asNumber()` to return a JS `Number` value and a
+	* `asDate()` to return a JS `Date` value.
+	*
+	*
+	* Caveats:
+	*
+	*
+	* - The `D` format (for "day of year") is not supported by this implementation at this time. - The `%t` format for
+	* short timezone code is not supported by this implementation at this time, though `z` will work as expected in the
+	* browser to emit the user's own timezone.
+	*/
+	export class DateTimeFormat {
+		static readonly NANOS_PER_MILLI:number;
+
+		/**
+		* Creates a new date/time format instance. This generally should be avoided in favor of the static `getFormat`
+		* function, which will create and cache an instance so that later calls share the same instance.
+		* @param pattern - 
+		*/
+		constructor(pattern:string);
+
+		/**
+		* 
+		* @param pattern - 
+		* @return a date format instance matching the specified format. If this format has not been specified before, a new
+		*         instance will be created and stored for later reuse.
+		*/
+		static getFormat(pattern:string):DateTimeFormat;
+		/**
+		* Accepts a variety of input objects to interpret as a date, and formats them using the specified pattern. A
+		* `TimeZone` object can optionally be provided to format this date as the current date/time in that timezone.See
+		* the instance method for more details on input objects.
+		* @param pattern - 
+		* @param date - 
+		* @param timeZone - 
+		* @return 
+		*/
+		static format(pattern:string, date:any, timeZone?:TimeZone):string;
+		/**
+		* Parses the given input string using the provided pattern, and returns a JS `Date` object in milliseconds.
+		* @param pattern - 
+		* @param text - 
+		* @return 
+		*/
+		static parseAsDate(pattern:string, text:string):Date;
+		/**
+		* Parses the given input string using the provided pattern, and returns a wrapped Java `long` value in nanoseconds.
+		* A `TimeZone` object can optionally be provided to parse to a desired timezone.
+		* @param pattern - 
+		* @param text - 
+		* @param tz - 
+		* @return 
+		*/
+		static parse(pattern:string, text:string, tz?:TimeZone):dh.DateWrapper;
+		/**
+		* Takes a variety of objects to interpret as a date, and formats them using this instance's pattern. Inputs can
+		* include a <b>String</b> value of a number expressed in nanoseconds, a <b>Number</b> value expressed in
+		* nanoseconds, a JS <b>Date</b> object (necessarily in milliseconds), or a wrapped Java <b>long</b> value,
+		* expressed in nanoseconds. A <b>TimeZone</b> object can optionally be provided to format this date as the current
+		* date/time in that timezone.
+		* @param date - 
+		* @param timeZone - 
+		* @return String
+		*/
+		format(date:any, timeZone?:TimeZone):string;
 		/**
-		* Optional description for the variable's contents, typically used to provide more detail that wouldn't be
-		* reasonable to put in the title
-		* @return String
+		* Parses the given string using this instance's pattern, and returns a wrapped Java <b>long</b> value in
+		* nanoseconds. A <b>TimeZone</b> object can optionally be provided to parse to a desired timezone.
+		* @param text - 
+		* @param tz - 
+		* @return 
 		*/
-		get applicationId():string;
+		parse(text:string, tz?:TimeZone):dh.DateWrapper;
 		/**
-		* The name of the application which provided this variable
-		* @return String
+		* Parses the given string using this instance's pattern, and returns a JS <b>Date</b> object in milliseconds.
+		* @param text - 
+		* @return 
 		*/
-		get applicationName():string;
+		parseAsDate(text:string):Date;
+		toString():string;
 	}
-}
-
-export namespace dh.i18n {
 
 	/**
 	* Represents the timezones supported by Deephaven. Can be used to format dates, taking into account the offset changing
@@ -2639,176 +2791,59 @@ export namespace dh.i18n {
 		get id():string;
 	}
 
-	/**
-	* Largely an exported wrapper for the GWT DateFormat, but also includes support for formatting nanoseconds as an
-	* additional 6 decimal places after the rest of the number.
-	*
-	* Other concerns that this handles includes accepting a js Date and ignoring the lack of nanos, accepting a js Number
-	* and assuming it to be a lossy nano value, and parsing into a js Date.
-	*
-	*
-	* Utility class to parse and format various date/time values, using the same format patterns as are supported by the
-	* standard Java implementation used in the Deephaven server and swing client.
-	*
-	* As Deephaven internally uses nanosecond precision to record dates, this API expects nanoseconds in most use cases,
-	* with the one exception of the JS `Date` type, which is not capable of more precision than milliseconds. Note,
-	* however, that when passing nanoseconds as a JS `Number` there is likely to be some loss of precision, though this is
-	* still supported for easier interoperability with other JS code. The values returned by `parse()` will be an opaque
-	* object wrapping the full precision of the specified date, However, this object supports `toString()` and `valueOf()`
-	* to return a string representation of that value, as well as a `asNumber()` to return a JS `Number` value and a
-	* `asDate()` to return a JS `Date` value.
-	*
-	*
-	* Caveats:
-	*
-	*
-	* - The `D` format (for "day of year") is not supported by this implementation at this time. - The `%t` format for
-	* short timezone code is not supported by this implementation at this time, though `z` will work as expected in the
-	* browser to emit the user's own timezone.
-	*/
-	export class DateTimeFormat {
-		static readonly NANOS_PER_MILLI:number;
+}
 
-		/**
-		* Creates a new date/time format instance. This generally should be avoided in favor of the static `getFormat`
-		* function, which will create and cache an instance so that later calls share the same instance.
-		* @param pattern - 
-		*/
-		constructor(pattern:string);
+export namespace dh.plot {
 
-		/**
-		* 
-		* @param pattern - 
-		* @return a date format instance matching the specified format. If this format has not been specified before, a new
-		*         instance will be created and stored for later reuse.
-		*/
-		static getFormat(pattern:string):DateTimeFormat;
-		/**
-		* Accepts a variety of input objects to interpret as a date, and formats them using the specified pattern. A
-		* `TimeZone` object can optionally be provided to format this date as the current date/time in that timezone.See
-		* the instance method for more details on input objects.
-		* @param pattern - 
-		* @param date - 
-		* @param timeZone - 
-		* @return 
-		*/
-		static format(pattern:string, date:any, timeZone?:TimeZone):string;
-		/**
-		* Parses the given input string using the provided pattern, and returns a JS `Date` object in milliseconds.
-		* @param pattern - 
-		* @param text - 
-		* @return 
-		*/
-		static parseAsDate(pattern:string, text:string):Date;
-		/**
-		* Parses the given input string using the provided pattern, and returns a wrapped Java `long` value in nanoseconds.
-		* A `TimeZone` object can optionally be provided to parse to a desired timezone.
-		* @param pattern - 
-		* @param text - 
-		* @param tz - 
-		* @return 
-		*/
-		static parse(pattern:string, text:string, tz?:TimeZone):dh.DateWrapper;
-		/**
-		* Takes a variety of objects to interpret as a date, and formats them using this instance's pattern. Inputs can
-		* include a <b>String</b> value of a number expressed in nanoseconds, a <b>Number</b> value expressed in
-		* nanoseconds, a JS <b>Date</b> object (necessarily in milliseconds), or a wrapped Java <b>long</b> value,
-		* expressed in nanoseconds. A <b>TimeZone</b> object can optionally be provided to format this date as the current
-		* date/time in that timezone.
-		* @param date - 
-		* @param timeZone - 
-		* @return String
-		*/
-		format(date:any, timeZone?:TimeZone):string;
-		/**
-		* Parses the given string using this instance's pattern, and returns a wrapped Java <b>long</b> value in
-		* nanoseconds. A <b>TimeZone</b> object can optionally be provided to parse to a desired timezone.
-		* @param text - 
-		* @param tz - 
-		* @return 
-		*/
-		parse(text:string, tz?:TimeZone):dh.DateWrapper;
-		/**
-		* Parses the given string using this instance's pattern, and returns a JS <b>Date</b> object in milliseconds.
-		* @param text - 
-		* @return 
-		*/
-		parseAsDate(text:string):Date;
-		toString():string;
+	export interface OneClick {
+		setValueForColumn(columnName:string, value:any):void;
+		getValueForColumn(columName:string):any;
+		get requireAllFiltersToDisplay():boolean;
+		get columns():dh.Column[];
 	}
-
 	/**
-	* Exported wrapper of the GWT NumberFormat, plus LongWrapper support
-	*
-	* Utility class to parse and format numbers, using the same format patterns as are supported by the standard Java
-	* implementation used in the Deephaven server and swing client. Works for numeric types including BigInteger and
-	* BigDecimal.
+	* Provides access to the data for displaying in a figure.
 	*/
-	export class NumberFormat {
-		/**
-		* Creates a new number format instance. This generally should be avoided in favor of the static `getFormat`
-		* function, which will create and cache an instance so that later calls share the same instance.
-		* @param pattern - 
-		*/
-		constructor(pattern:string);
+	export interface Series {
+		readonly isLinesVisible?:boolean|null;
+		readonly pointLabelFormat?:string|null;
+		readonly yToolTipPattern?:string|null;
+		readonly shapeSize?:number|null;
+		readonly xToolTipPattern?:string|null;
+		readonly isShapesVisible?:boolean|null;
 
+		subscribe(forceDisableDownsample?:DownsampleOptions):void;
 		/**
-		* a number format instance matching the specified format. If this format has not been specified before, a new
-		* instance will be created and cached for later reuse. Prefer this method to calling the constructor directly to
-		* take advantage of caching
-		* @param pattern - 
-		* @return dh.i18n.NumberFormat
-		*/
-		static getFormat(pattern:string):NumberFormat;
-		/**
-		* Parses the given text using the cached format matching the given pattern.
-		* @param pattern - 
-		* @param text - 
-		* @return double
-		*/
-		static parse(pattern:string, text:string):number;
-		/**
-		* Formats the specified number (or Java <b>long</b>, <b>BigInteger</b> or <b>BigDecimal</b> value) using the cached
-		* format matching the given pattern string.
-		* @param pattern - 
-		* @param number - 
-		* @return String
+		* Disable updates for this Series.
 		*/
-		static format(pattern:string, number:number|dh.BigIntegerWrapper|dh.BigDecimalWrapper|dh.LongWrapper):string;
+		unsubscribe():void;
+		get shape():string;
 		/**
-		* Parses the given text using this instance's pattern into a JS Number.
-		* @param text - 
-		* @return double
+		* Contains details on how to access data within the chart for this series. keyed with the way that this series uses
+		* the axis.
+		* @return {@link dh.plot.SeriesDataSource}
 		*/
-		parse(text:string):number;
+		get sources():SeriesDataSource[];
+		get lineColor():string;
 		/**
-		* Formats the specified number (or Java `long`, `BigInteger` or `BigDecimal` value) using this instance's pattern.
-		* @param number - 
-		* @return String
+		* The plotting style to use for this series. See <b>SeriesPlotStyle</b> enum for more details.
+		* @return int
 		*/
-		format(number:number|dh.BigIntegerWrapper|dh.BigDecimalWrapper|dh.LongWrapper):string;
-		toString():string;
-	}
-
-
-}
-
-export namespace dh.plot {
-
-	/**
-	* Describes a template that will be used to make new series instances when a new table added to a plotBy.
-	*/
-	export interface MultiSeries {
+		get plotStyle():SeriesPlotStyleType;
+		get oneClick():OneClick;
+		get gradientVisible():boolean;
+		get shapeColor():string;
 		/**
-		* The name for this multi-series.
+		* The name for this series.
 		* @return String
 		*/
 		get name():string;
 		/**
-		* The plotting style to use for the series that will be created. See <b>SeriesPlotStyle</b> enum for more details.
-		* @return int
+		* indicates that this series belongs to a MultiSeries, null otherwise
+		* @return dh.plot.MultiSeries
 		*/
-		get plotStyle():SeriesPlotStyleType;
+		get multiSeries():MultiSeries;
+		get shapeLabel():string;
 	}
 	/**
 	* Defines one axis used with by series. These instances will be found both on the Chart and the Series instances, and
@@ -2856,81 +2891,46 @@ export namespace dh.plot {
 		get majorTicksVisible():boolean;
 		get ticksFont():string;
 		/**
-		* The unique id for this axis.
-		* @return String
-		*/
-		get id():string;
-		/**
-		* The position for this axis. See <b>AxisPosition</b> enum for more details.
-		* @return int
-		*/
-		get position():AxisPositionType;
-		/**
-		* The calendar with the business hours and holidays to transform plot data against. Defaults to null, or no
-		* transform.
-		* @return dh.calendar.BusinessCalendar
-		*/
-		get businessCalendar():dh.calendar.BusinessCalendar;
-		/**
-		* The type for this axis. See <b>AxisFormatType</b> enum for more details.
-		* @return int
-		*/
-		get formatType():AxisFormatTypeType;
-		get minRange():number;
-	}
-	export interface FigureDataUpdatedEvent {
-		getArray(series:Series, sourceType:number, mappingFunc?:(arg0:any)=>any):Array<any>;
-		get series():Series[];
-	}
-	export interface OneClick {
-		setValueForColumn(columnName:string, value:any):void;
-		getValueForColumn(columName:string):any;
-		get requireAllFiltersToDisplay():boolean;
-		get columns():dh.Column[];
-	}
-	/**
-	* Provides access to the data for displaying in a figure.
-	*/
-	export interface Series {
-		readonly isLinesVisible?:boolean|null;
-		readonly pointLabelFormat?:string|null;
-		readonly yToolTipPattern?:string|null;
-		readonly shapeSize?:number|null;
-		readonly xToolTipPattern?:string|null;
-		readonly isShapesVisible?:boolean|null;
-
-		subscribe(forceDisableDownsample?:DownsampleOptions):void;
+		* The unique id for this axis.
+		* @return String
+		*/
+		get id():string;
 		/**
-		* Disable updates for this Series.
+		* The position for this axis. See <b>AxisPosition</b> enum for more details.
+		* @return int
 		*/
-		unsubscribe():void;
-		get shape():string;
+		get position():AxisPositionType;
 		/**
-		* Contains details on how to access data within the chart for this series. keyed with the way that this series uses
-		* the axis.
-		* @return {@link dh.plot.SeriesDataSource}
+		* The calendar with the business hours and holidays to transform plot data against. Defaults to null, or no
+		* transform.
+		* @return dh.calendar.BusinessCalendar
 		*/
-		get sources():SeriesDataSource[];
-		get lineColor():string;
+		get businessCalendar():dh.calendar.BusinessCalendar;
 		/**
-		* The plotting style to use for this series. See <b>SeriesPlotStyle</b> enum for more details.
+		* The type for this axis. See <b>AxisFormatType</b> enum for more details.
 		* @return int
 		*/
-		get plotStyle():SeriesPlotStyleType;
-		get oneClick():OneClick;
-		get gradientVisible():boolean;
-		get shapeColor():string;
+		get formatType():AxisFormatTypeType;
+		get minRange():number;
+	}
+	export interface FigureDataUpdatedEvent {
+		getArray(series:Series, sourceType:number, mappingFunc?:(arg0:any)=>any):Array<any>;
+		get series():Series[];
+	}
+	/**
+	* Describes a template that will be used to make new series instances when a new table added to a plotBy.
+	*/
+	export interface MultiSeries {
 		/**
-		* The name for this series.
+		* The name for this multi-series.
 		* @return String
 		*/
 		get name():string;
 		/**
-		* indicates that this series belongs to a MultiSeries, null otherwise
-		* @return dh.plot.MultiSeries
+		* The plotting style to use for the series that will be created. See <b>SeriesPlotStyle</b> enum for more details.
+		* @return int
 		*/
-		get multiSeries():MultiSeries;
-		get shapeLabel():string;
+		get plotStyle():SeriesPlotStyleType;
 	}
 	/**
 	* Describes how to access and display data required within a series.
@@ -2954,92 +2954,39 @@ export namespace dh.plot {
 	}
 
 	/**
-	* Provide the details for a chart.
-	*/
-	export class Chart implements dh.HasEventHandling {
-		/**
-		* a new series was added to this chart as part of a multi-series. The series instance is the detail for this event.
-		*/
-		static readonly EVENT_SERIES_ADDED:string;
-		/**
-		* The title of the chart.
-		* @return String
-		*/
-		readonly title?:string|null;
-
-		protected constructor();
-
-		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;
-		get column():number;
-		get showLegend():boolean;
-		/**
-		* The axes used in this chart.
-		* @return dh.plot.Axis
-		*/
-		get axes():Axis[];
-		get is3d():boolean;
-		get titleFont():string;
-		get colspan():number;
-		get titleColor():string;
-		get series():Series[];
-		get rowspan():number;
-		/**
-		* The type of this chart, see <b>ChartType</b> enum for more details.
-		* @return int
-		*/
-		get chartType():ChartTypeType;
-		get row():number;
-		get legendColor():string;
-		get legendFont():string;
-		get multiSeries():MultiSeries[];
-	}
-
-	export class DownsampleOptions {
-		/**
-		* Max number of items in the series before DEFAULT will not attempt to load the series without downsampling. Above
-		* this size if downsample fails or is not applicable, the series won't be loaded unless DISABLE is passed to
-		* series.subscribe().
-		*/
-		static MAX_SERIES_SIZE:number;
-		/**
-		* Max number of items in the series where the subscription will be allowed at all. Above this limit, even with
-		* downsampling disabled, the series will not load data.
-		*/
-		static MAX_SUBSCRIPTION_SIZE:number;
-		/**
-		* Flag to let the API decide what data will be available, based on the nature of the data, the series, and how the
-		* axes are configured.
-		*/
-		static readonly DEFAULT:DownsampleOptions;
-		/**
-		* Flat to entirely disable downsampling, and force all data to load, no matter how many items that would be, up to
-		* the limit of MAX_SUBSCRIPTION_SIZE.
-		*/
-		static readonly DISABLE:DownsampleOptions;
-
-		protected constructor();
-	}
-
-	/**
-	* Helper class to manage snapshots and deltas and keep not only a contiguous JS array of data per column in the
-	* underlying table, but also support a mapping function to let client code translate data in some way for display and
-	* keep that cached as well.
+	* Provides the details for a figure.
+	*
+	* The Deephaven JS API supports automatic lossless downsampling of time-series data, when that data is plotted in one
+	* or more line series. Using a scatter plot or a X-axis of some type other than DateTime will prevent this feature from
+	* being applied to a series. To enable this feature, invoke <b>Axis.range(...)</b> to specify the length in pixels of
+	* the axis on the screen, and the range of values that are visible, and the server will use that width (and range, if
+	* any) to reduce the number of points sent to the client.
+	*
+	* Downsampling can also be controlled when calling either <b>Figure.subscribe()</b> or <b>Series.subscribe()</b> - both
+	* can be given an optional <b>dh.plot.DownsampleOptions</b> argument. Presently only two valid values exist,
+	* <b>DEFAULT</b>, and <b>DISABLE</b>, and if no argument is specified, <b>DEFAULT</b> is assumed. If there are more
+	* than 30,000 rows in a table, downsampling will be encouraged - data will not load without calling
+	* <b>subscribe(DISABLE)</b> or enabling downsampling via <b>Axis.range(...)</b>. If there are more than 200,000 rows,
+	* data will refuse to load without downsampling and <b>subscribe(DISABLE)</b> would have no effect.
+	*
+	* Downsampled data looks like normal data, except that select items have been removed if they would be redundant in the
+	* UI given the current configuration. Individual rows are intact, so that a tooltip or some other UI item is sure to be
+	* accurate and consistent, and at least the highest and lowest value for each axis will be retained as well, to ensure
+	* that the "important" values are visible.
+	*
+	* Four events exist to help with interacting with downsampled data, all fired from the <b>Figure</b> instance itself.
+	* First, <b>downsampleneeded</b> indicates that more than 30,000 rows would be fetched, and so specifying downsampling
+	* is no longer optional - it must either be enabled (calling <b>axis.range(...)</b>), or disabled. If the figure is
+	* configured for downsampling, when a change takes place that requires that the server perform some downsampling work,
+	* the <b>downsamplestarted</b> event will first be fired, which can be used to present a brief loading message,
+	* indicating to the user why data is not ready yet - when the server side process is complete,
+	* <b>downsamplefinished</b> will be fired. These events will repeat when the range changes, such as when zooming,
+	* panning, or resizing the figure. Finally, <b>downsamplefailed</b> indicates that something when wrong when
+	* downsampling, or possibly that downsampling cannot be disabled due to the number of rows in the table.
+	*
+	* At this time, not marked as a ServerObject, due to internal implementation issues which leave the door open to
+	* client-created figures.
 	*/
-	export class ChartData {
-		constructor(table:dh.Table);
-
-		update(tableData:dh.SubscriptionTableData):void;
-		getColumn(columnName:string, mappingFunc:(arg0:any)=>any, currentUpdate:dh.TableData):Array<any>;
-		/**
-		* Removes some column from the cache, avoiding extra computation on incoming events, and possibly freeing some
-		* memory. If this pair of column name and map function are requested again, it will be recomputed from scratch.
-		*/
-		removeColumn(columnName:string, mappingFunc:(arg0:any)=>any):void;
-	}
-
 	export class Figure implements dh.HasEventHandling {
 		/**
 		* The title of the figure.
@@ -3083,7 +3030,8 @@ export namespace dh.plot {
 		*/
 		static readonly EVENT_DOWNSAMPLENEEDED:string;
 
-		static create(config:FigureDescriptor):Promise<Figure>;
+		protected constructor();
+
 		subscribe(forceDisableDownsample?:DownsampleOptions):void;
 		/**
 		* Disable updates for all series in this figure.
@@ -3122,6 +3070,7 @@ export namespace dh.plot {
 		* @typeParam T - 
 		*/
 		removeEventListener<T>(name:string, callback:(e:CustomEvent<T>)=>void):boolean;
+		static create(config:FigureDescriptor):Promise<Figure>;
 	}
 
 	/**
@@ -3141,6 +3090,82 @@ export namespace dh.plot {
 		constructor();
 	}
 
+	/**
+	* Helper class for plot downsampling methods.
+	*/
+	export class Downsample {
+		protected constructor();
+
+		/**
+		* Downsamples a table so that the data can be used for a time-series line plot. The downsampled table should have
+		* the same visual fidelity as the original table, but with fewer rows.
+		* @param table - The table to downsample.
+		* @param xCol - The name of the X column to downsample. Must be an Instant or long.
+		* @param yCols - The names of the Y columns to downsample.
+		* @param width - The width of the visible area in pixels.
+		* @param xRange - The visible range as `[start, end]` or null to always use all data.
+		* @return A promise that resolves to the downsampled table.
+		*/
+		static runChartDownsample(table:dh.Table, xCol:string, yCols:string[], width:number, xRange?:dh.LongWrapper[]|undefined|null):Promise<dh.Table>;
+	}
+
+	export class FigureSourceException {
+		table:dh.Table;
+		source:SeriesDataSource;
+
+		protected constructor();
+	}
+
+	export class FigureFetchError {
+		error:object;
+		errors:Array<string>;
+
+		protected constructor();
+	}
+
+	export class SeriesDescriptor {
+		plotStyle:string;
+		name?:string|null;
+		linesVisible?:boolean|null;
+		shapesVisible?:boolean|null;
+		gradientVisible?:boolean|null;
+		lineColor?:string|null;
+		pointLabelFormat?:string|null;
+		xToolTipPattern?:string|null;
+		yToolTipPattern?:string|null;
+		shapeLabel?:string|null;
+		shapeSize?:number|null;
+		shapeColor?:string|null;
+		shape?:string|null;
+		dataSources:Array<SourceDescriptor>;
+
+		constructor();
+	}
+
+	export class AxisDescriptor {
+		formatType:string;
+		type:string;
+		position:string;
+		log?:boolean|null;
+		label?:string|null;
+		labelFont?:string|null;
+		ticksFont?:string|null;
+		formatPattern?:string|null;
+		color?:string|null;
+		minRange?:number|null;
+		maxRange?:number|null;
+		minorTicksVisible?:boolean|null;
+		majorTicksVisible?:boolean|null;
+		minorTickCount?:number|null;
+		gapBetweenMajorTicks?:number|null;
+		majorTickLocations?:Array<number>|null;
+		tickLabelAngle?:number|null;
+		invert?:boolean|null;
+		isTimeAxis?:boolean|null;
+
+		constructor();
+	}
+
 	export class ChartDescriptor {
 		colspan?:number|null;
 		rowspan?:number|null;
@@ -3159,29 +3184,56 @@ export namespace dh.plot {
 	}
 
 	/**
-	* Helper class for plot downsampling methods.
+	* Provide the details for a chart.
 	*/
-	export class Downsample {
+	export class Chart implements dh.HasEventHandling {
+		/**
+		* a new series was added to this chart as part of a multi-series. The series instance is the detail for this event.
+		*/
+		static readonly EVENT_SERIES_ADDED:string;
+		/**
+		* The title of the chart.
+		* @return String
+		*/
+		readonly title?:string|null;
+
 		protected constructor();
 
+		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;
+		get column():number;
+		get showLegend():boolean;
 		/**
-		* Downsamples a table so that the data can be used for a time-series line plot. The downsampled table should have
-		* the same visual fidelity as the original table, but with fewer rows.
-		* @param table - The table to downsample.
-		* @param xCol - The name of the X column to downsample. Must be an Instant or long.
-		* @param yCols - The names of the Y columns to downsample.
-		* @param width - The width of the visible area in pixels.
-		* @param xRange - The visible range as `[start, end]` or null to always use all data.
-		* @return A promise that resolves to the downsampled table.
+		* The axes used in this chart.
+		* @return dh.plot.Axis
+		*/
+		get axes():Axis[];
+		get is3d():boolean;
+		get titleFont():string;
+		get colspan():number;
+		get titleColor():string;
+		get series():Series[];
+		get rowspan():number;
+		/**
+		* The type of this chart, see <b>ChartType</b> enum for more details.
+		* @return int
 		*/
-		static runChartDownsample(table:dh.Table, xCol:string, yCols:string[], width:number, xRange?:dh.LongWrapper[]|undefined|null):Promise<dh.Table>;
+		get chartType():ChartTypeType;
+		get row():number;
+		get legendColor():string;
+		get legendFont():string;
+		get multiSeries():MultiSeries[];
 	}
 
-	export class FigureFetchError {
-		error:object;
-		errors:Array<string>;
+	export class SourceDescriptor {
+		axis:AxisDescriptor;
+		table:dh.Table;
+		columnName:string;
+		type:string;
 
-		protected constructor();
+		constructor();
 	}
 
 	export class SeriesDataSourceException {
@@ -3191,65 +3243,74 @@ export namespace dh.plot {
 		get message():string;
 	}
 
-	export class AxisDescriptor {
-		formatType:string;
-		type:string;
-		position:string;
-		log?:boolean|null;
-		label?:string|null;
-		labelFont?:string|null;
-		ticksFont?:string|null;
-		formatPattern?:string|null;
-		color?:string|null;
-		minRange?:number|null;
-		maxRange?:number|null;
-		minorTicksVisible?:boolean|null;
-		majorTicksVisible?:boolean|null;
-		minorTickCount?:number|null;
-		gapBetweenMajorTicks?:number|null;
-		majorTickLocations?:Array<number>|null;
-		tickLabelAngle?:number|null;
-		invert?:boolean|null;
-		isTimeAxis?:boolean|null;
-
-		constructor();
-	}
-
-	export class SourceDescriptor {
-		axis:AxisDescriptor;
-		table:dh.Table;
-		columnName:string;
-		type:string;
+	/**
+	* Helper class to manage snapshots and deltas and keep not only a contiguous JS array of data per column in the
+	* underlying table, but also support a mapping function to let client code translate data in some way for display and
+	* keep that cached as well.
+	*/
+	export class ChartData {
+		constructor(table:dh.Table);
 
-		constructor();
+		update(tableData:dh.SubscriptionTableData):void;
+		getColumn(columnName:string, mappingFunc:(arg0:any)=>any, currentUpdate:dh.TableData):Array<any>;
+		/**
+		* Removes some column from the cache, avoiding extra computation on incoming events, and possibly freeing some
+		* memory. If this pair of column name and map function are requested again, it will be recomputed from scratch.
+		*/
+		removeColumn(columnName:string, mappingFunc:(arg0:any)=>any):void;
 	}
 
-	export class FigureSourceException {
-		table:dh.Table;
-		source:SeriesDataSource;
+	export class DownsampleOptions {
+		/**
+		* Max number of items in the series before DEFAULT will not attempt to load the series without downsampling. Above
+		* this size if downsample fails or is not applicable, the series won't be loaded unless DISABLE is passed to
+		* series.subscribe().
+		*/
+		static MAX_SERIES_SIZE:number;
+		/**
+		* Max number of items in the series where the subscription will be allowed at all. Above this limit, even with
+		* downsampling disabled, the series will not load data.
+		*/
+		static MAX_SUBSCRIPTION_SIZE:number;
+		/**
+		* Flag to let the API decide what data will be available, based on the nature of the data, the series, and how the
+		* axes are configured.
+		*/
+		static readonly DEFAULT:DownsampleOptions;
+		/**
+		* Flat to entirely disable downsampling, and force all data to load, no matter how many items that would be, up to
+		* the limit of MAX_SUBSCRIPTION_SIZE.
+		*/
+		static readonly DISABLE:DownsampleOptions;
 
 		protected constructor();
 	}
 
-	export class SeriesDescriptor {
-		plotStyle:string;
-		name?:string|null;
-		linesVisible?:boolean|null;
-		shapesVisible?:boolean|null;
-		gradientVisible?:boolean|null;
-		lineColor?:string|null;
-		pointLabelFormat?:string|null;
-		xToolTipPattern?:string|null;
-		yToolTipPattern?:string|null;
-		shapeLabel?:string|null;
-		shapeSize?:number|null;
-		shapeColor?:string|null;
-		shape?:string|null;
-		dataSources:Array<SourceDescriptor>;
 
-		constructor();
+	type AxisTypeType = number;
+	export class AxisType {
+		static readonly X:AxisTypeType;
+		static readonly Y:AxisTypeType;
+		static readonly SHAPE:AxisTypeType;
+		static readonly SIZE:AxisTypeType;
+		static readonly LABEL:AxisTypeType;
+		static readonly COLOR:AxisTypeType;
 	}
 
+	/**
+	* This enum describes what kind of chart is being drawn. This may limit what kinds of series can be found on it, or how
+	* those series should be rendered.
+	*/
+	type ChartTypeType = number;
+	export class ChartType {
+		static readonly XY:ChartTypeType;
+		static readonly PIE:ChartTypeType;
+		static readonly OHLC:ChartTypeType;
+		static readonly CATEGORY:ChartTypeType;
+		static readonly XYZ:ChartTypeType;
+		static readonly CATEGORY_3D:ChartTypeType;
+		static readonly TREEMAP:ChartTypeType;
+	}
 
 	type SeriesPlotStyleType = number;
 	export class SeriesPlotStyle {
@@ -3267,12 +3328,6 @@ export namespace dh.plot {
 		static readonly TREEMAP:SeriesPlotStyleType;
 	}
 
-	type AxisFormatTypeType = number;
-	export class AxisFormatType {
-		static readonly CATEGORY:AxisFormatTypeType;
-		static readonly NUMBER:AxisFormatTypeType;
-	}
-
 	type AxisPositionType = number;
 	export class AxisPosition {
 		static readonly TOP:AxisPositionType;
@@ -3282,31 +3337,6 @@ export namespace dh.plot {
 		static readonly NONE:AxisPositionType;
 	}
 
-	type AxisTypeType = number;
-	export class AxisType {
-		static readonly X:AxisTypeType;
-		static readonly Y:AxisTypeType;
-		static readonly SHAPE:AxisTypeType;
-		static readonly SIZE:AxisTypeType;
-		static readonly LABEL:AxisTypeType;
-		static readonly COLOR:AxisTypeType;
-	}
-
-	/**
-	* This enum describes what kind of chart is being drawn. This may limit what kinds of series can be found on it, or how
-	* those series should be rendered.
-	*/
-	type ChartTypeType = number;
-	export class ChartType {
-		static readonly XY:ChartTypeType;
-		static readonly PIE:ChartTypeType;
-		static readonly OHLC:ChartTypeType;
-		static readonly CATEGORY:ChartTypeType;
-		static readonly XYZ:ChartTypeType;
-		static readonly CATEGORY_3D:ChartTypeType;
-		static readonly TREEMAP:ChartTypeType;
-	}
-
 	/**
 	* This enum describes the source it is in, and how this aspect of the data in the series should be used to render the
 	* item. For example, a point in a error-bar plot might have a X value, three Y values (Y, Y_LOW, Y_HIGH), and some
@@ -3336,42 +3366,48 @@ export namespace dh.plot {
 		static readonly HOVER_TEXT:SourceTypeType;
 	}
 
+	type AxisFormatTypeType = number;
+	export class AxisFormatType {
+		static readonly CATEGORY:AxisFormatTypeType;
+		static readonly NUMBER:AxisFormatTypeType;
+	}
+
 }
 
 export namespace dh.lsp {
 
-	export class MarkupContent {
-		kind:string;
-		value:string;
-
-		constructor();
-	}
-
-	export class ParameterInformation {
+	export class SignatureInformation {
 		label:string;
 		documentation:MarkupContent;
+		parameters:Array<ParameterInformation>;
+		activeParameter:number;
 
 		constructor();
 	}
 
-	export class TextDocumentContentChangeEvent {
-		range:Range;
-		rangeLength:number;
-		text:string;
+	export class Position {
+		line:number;
+		character:number;
 
 		constructor();
+
+		lessThan(start:Position):boolean;
+		lessOrEqual(start:Position):boolean;
+		greaterThan(end:Position):boolean;
+		greaterOrEqual(end:Position):boolean;
+		copy():Position;
 	}
 
-	export class Hover {
-		contents:MarkupContent;
+	export class TextEdit {
 		range:Range;
+		text:string;
 
 		constructor();
 	}
 
-	export class TextEdit {
-		range:Range;
-		text:string;
+	export class MarkupContent {
+		kind:string;
+		value:string;
 
 		constructor();
 	}
@@ -3385,24 +3421,17 @@ export namespace dh.lsp {
 		isInside(innerStart:Position, innerEnd:Position):boolean;
 	}
 
-	export class Position {
-		line:number;
-		character:number;
+	export class ParameterInformation {
+		label:string;
+		documentation:MarkupContent;
 
 		constructor();
-
-		lessThan(start:Position):boolean;
-		lessOrEqual(start:Position):boolean;
-		greaterThan(end:Position):boolean;
-		greaterOrEqual(end:Position):boolean;
-		copy():Position;
 	}
 
-	export class SignatureInformation {
-		label:string;
-		documentation:MarkupContent;
-		parameters:Array<ParameterInformation>;
-		activeParameter:number;
+	export class TextDocumentContentChangeEvent {
+		range:Range;
+		rangeLength:number;
+		text:string;
 
 		constructor();
 	}
@@ -3424,27 +3453,17 @@ export namespace dh.lsp {
 		constructor();
 	}
 
-}
+	export class Hover {
+		contents:MarkupContent;
+		range:Range;
+
+		constructor();
+	}
 
+}
 
 export namespace dh.calendar {
 
-	export interface Holiday {
-		/**
-		* The date of the Holiday.
-		* @return {@link dh.LocalDateWrapper}
-		*/
-		get date():dh.LocalDateWrapper;
-		/**
-		* The business periods that are open on the holiday.
-		* @return dh.calendar.BusinessPeriod
-		*/
-		get businessPeriods():Array<BusinessPeriod>;
-	}
-	export interface BusinessPeriod {
-		get close():string;
-		get open():string;
-	}
 	/**
 	* Defines a calendar with business hours and holidays.
 	*/
@@ -3475,6 +3494,22 @@ export namespace dh.calendar {
 		*/
 		get businessPeriods():Array<BusinessPeriod>;
 	}
+	export interface BusinessPeriod {
+		get close():string;
+		get open():string;
+	}
+	export interface Holiday {
+		/**
+		* The date of the Holiday.
+		* @return {@link dh.LocalDateWrapper}
+		*/
+		get date():dh.LocalDateWrapper;
+		/**
+		* The business periods that are open on the holiday.
+		* @return dh.calendar.BusinessPeriod
+		*/
+		get businessPeriods():Array<BusinessPeriod>;
+	}
 
 	type DayOfWeekType = string;
 	export class DayOfWeek {
@@ -3490,3 +3525,4 @@ export namespace dh.calendar {
 	}
 
 }
+