@deephaven/jsapi-types 41.6.0 → 41.8.0

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 // 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
@@ -11,10 +15,6 @@ export interface Iterator<T> {
 	hasNext():boolean;
 	next():IIterableResult<T>;
 }
-export interface IIterableResult<T> {
-	value:T;
-	done:boolean;
-}
 export namespace dh.storage {
 
 	/**
@@ -32,22 +32,6 @@ export namespace dh.storage {
 		get dirname():string;
 	}
 
-	/**
-	* Represents a file's contents loaded from the server. If an etag was specified when loading, client should first test
-	* if the etag of this instance matches - if so, the contents will be empty, and the client's existing contents should
-	* be used.
-	*/
-	export class FileContents {
-		protected constructor();
-
-		static blob(blob:Blob):FileContents;
-		static text(...text:string[]):FileContents;
-		static arrayBuffers(...buffers:ArrayBuffer[]):FileContents;
-		text():Promise<string>;
-		arrayBuffer():Promise<ArrayBuffer>;
-		get etag():string;
-	}
-
 	/**
 	* Remote service to read and write files on the server. Paths use "/" as a separator, and should not start with "/".
 	*/
@@ -106,6 +90,22 @@ export namespace dh.storage {
 		createDirectory(path:string):Promise<void>;
 	}
 
+	/**
+	* Represents a file's contents loaded from the server. If an etag was specified when loading, client should first test
+	* if the etag of this instance matches - if so, the contents will be empty, and the client's existing contents should
+	* be used.
+	*/
+	export class FileContents {
+		protected constructor();
+
+		static blob(blob:Blob):FileContents;
+		static text(...text:string[]):FileContents;
+		static arrayBuffers(...buffers:ArrayBuffer[]):FileContents;
+		text():Promise<string>;
+		arrayBuffer():Promise<ArrayBuffer>;
+		get etag():string;
+	}
+
 
 	type ItemTypeType = string;
 	export class ItemType {
@@ -117,6 +117,179 @@ export namespace dh.storage {
 
 export namespace dh {
 
+	/**
+	* Wrap LocalTime values for use in JS. Provides text formatting for display and access to the underlying value.
+	*/
+	export interface LocalTimeWrapper {
+		valueOf():string;
+		getHour():number;
+		getMinute():number;
+		getSecond():number;
+		getNano():number;
+		toString():string;
+	}
+	/**
+	* Similar to {@link dh.ViewportData}, but with additional properties to reflect
+	* the tree structure.
+	*/
+	export interface TreeViewportData extends TableData {
+		get(index:LongWrapper|number):TreeRow;
+		getData(index:LongWrapper|number, column:Column):any;
+		getFormat(index:LongWrapper|number, column:Column):Format;
+		get treeSize():number;
+		/**
+		* The position of the first returned row within the tree.
+		*/
+		get offset():number;
+		get columns():Array<Column>;
+		get rows():Array<TreeRow>;
+	}
+	export interface HasEventHandling {
+		/**
+		* 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:dh.Event<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<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:dh.Event<T>)=>void):boolean;
+	}
+	/**
+	* Options for requesting table data, either as a snapshot or a subscription. See subtypes for more specific options:
+	* <ul>
+	* <li>{@link dh.SnapshotOptions} for snapshot-specific options</li>
+	* <li>{@link dh.SubscriptionOptions} for full-table subscription-specific options</li>
+	* <li>{@link dh.ViewportSubscriptionOptions} for viewport subscription-specific options</li>
+	* </ul>
+	*/
+	export interface DataOptions {
+		/**
+		* Optional preview instructions for columns in the table data.
+		*/
+		previewOptions?:PreviewOptions|null;
+		/**
+		* Required property to indicate which columns should be included in the table data.
+		*/
+		columns:Array<Column>;
+	}
+	/**
+	* 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[];
+	}
+	/**
+	* Wrap LocalDate values for use in JS. Provides text formatting for display and access to the underlying value.
+	*/
+	export interface LocalDateWrapper {
+		valueOf():string;
+		getYear():number;
+		getMonthValue():number;
+		getDayOfMonth():number;
+		toString():string;
+	}
+	/**
+	* Options for requesting a viewport subscription to a table.
+	*/
+	export interface ViewportSubscriptionOptions extends SubscriptionOptions {
+		/**
+		* If true, the viewport will be filled starting from the end of the table, where 0 is the last row of the
+		* table. Default is false.
+		*/
+		isReverseViewport?:boolean|null;
+		/**
+		* The rows to include in the viewport. This can be either a {@link dh.RangeSet} or a single range with
+		* `first` and `last` properties.
+		*/
+		rows:RangeSet|SimpleRange;
+	}
+	/**
+	* Similar to the browser `CustomEvent` type, this class holds only the type of the event, and optionally some
+	* details about the event.
+	* @typeParam T - the type of the event detail
+	*/
+	export interface Event<T> {
+		get detail():T;
+		get type():string;
+	}
+	/**
+	* 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 WidgetExportedObject {
+		/**
+		* 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.
+		*/
+		readonly type?:string|null;
+
+		/**
+		* 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.
+		*/
+		reexport():Promise<WidgetExportedObject>;
+		/**
+		* 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.
+		*/
+		fetch():Promise<any>;
+		/**
+		* 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.
+		*/
+		close():void;
+	}
+	/**
+	* Options for requesting a snapshot of a table.
+	*/
+	export interface SnapshotOptions extends DataOptions {
+		/**
+		* If true, the snapshot will be filled starting from the end of the table, where 0 is the last row of the
+		* table. Default is false.
+		*/
+		isReverseViewport?:boolean|null;
+		/**
+		* The rows to include in the snapshot. This can be either a {@link dh.RangeSet} or a single range with
+		* `first` and `last` properties.
+		*/
+		rows:RangeSet|SimpleRange;
+	}
 	/**
 	* 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.
@@ -271,13 +444,10 @@ export namespace dh {
 		*/
 		get isRefreshing():boolean;
 	}
-	/**
-	* Simple range consisting only of start and end numbers. Will be migrated to deephaven-core in the near future, and
-	* subsequently removed from this the coreplus namespace.
-	*/
-	export interface SimpleRange {
-		first:number;
-		last:number;
+	export interface ColumnGroup {
+		get name():string|null;
+		get children():string[]|null;
+		get color():string|null;
 	}
 	/**
 	* This object may be pooled internally or discarded and not updated. Do not retain references to it. Instead,
@@ -289,272 +459,58 @@ export namespace dh {
 		get index():LongWrapper;
 	}
 	/**
-	* Wrap LocalDate values for use in JS. Provides text formatting for display and access to the underlying value.
-	*/
-	export interface LocalDateWrapper {
-		valueOf():string;
-		getYear():number;
-		getMonthValue():number;
-		getDayOfMonth():number;
-		toString():string;
-	}
-	/**
-	* Options for requesting a preview of columns when requesting table data. The two properties
-	* {@link dh.convertArrayToString} and {@link dh.array} are mutually exclusive.
+	* Represents statistics for a given table column.
 	*/
-	export interface PreviewOptions {
+	export interface ColumnStatistics {
 		/**
-		* If true, any array columns will be converted to strings for preview purposes. This is the legacy behavior.
+		* 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
 		*/
-		convertArrayToString?:boolean|null;
+		getType(name:string):string;
 		/**
-		* Specifies the length of the array to serialize. If the array is longer than this length, one extra element
-		* will be included - the client is expected to truncate the array and append "..." to indicate that there are
-		* additional elements. Negative values indicate that the values should be counted from the end of the array
-		* rather than the beginning. Zero or null indicate that the entire array should be serialized. The default is
-		* null.
+		* 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
 		*/
-		array?:number|null;
-	}
-	/**
-	* Similar to {@link dh.ViewportData}, but with additional properties to reflect
-	* the tree structure.
-	*/
-	export interface TreeViewportData extends TableData {
-		get(index:LongWrapper|number):TreeRow;
-		getData(index:LongWrapper|number, column:Column):any;
-		getFormat(index:LongWrapper|number, column:Column):Format;
-		get treeSize():number;
-		/**
-		* The position of the first returned row within the tree.
-		*/
-		get offset():number;
-		get columns():Array<Column>;
-		get rows():Array<TreeRow>;
-	}
-	export interface ColumnGroup {
-		get name():string|null;
-		get children():string[]|null;
-		get color():string|null;
-	}
-	/**
-	* Common interface for various ways of accessing table data and formatting for viewport or non-viewport subscriptions
-	* on tables, data in trees, and snapshots.
-	* <p>
-	* Generally speaking, it is more efficient to access data in column-major order, rather than iterating through each Row
-	* and accessing all columns that it holds. The {@link rows} accessor can be useful to read row data, but may
-	* incur other costs - it is likely faster to access data by columns using {@link getData}.
-	*/
-	export interface TableData {
-		/**
-		* Reads a row object from the table, from which any subscribed column can be read.
-		* @param index - the position or key to access
-		* @return the row at the given location
-		*/
-		get(index:LongWrapper|number):Row;
-		/**
-		* Reads a specific cell from the table, by row key and column.
-		* @param index - the row in the table to get data from
-		* @param column - the column to read
-		* @return the value in the table
-		*/
-		getData(index:LongWrapper|number, column:Column):any;
-		/**
-		* The server-specified Format to use for the cell at the given position.
-		* @param index - the row to read
-		* @param column - the column to read
-		* @return a Format instance with any server-specified details
-		*/
-		getFormat(index:LongWrapper|number, column:Column):Format;
-		get columns():Array<Column>;
-		/**
-		* A lazily computed array of all rows available on the client.
-		*/
-		get rows():Array<Row>;
-	}
-	export interface WorkerHeapInfo {
-		/**
-		* Total heap size available for this worker.
-		*/
-		get totalHeapSize():number;
-		get freeMemory():number;
-		get maximumHeapSize():number;
-	}
-	export interface HasEventHandling {
-		/**
-		* 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:dh.Event<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<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:dh.Event<T>)=>void):boolean;
-	}
-	/**
-	* Options for requesting a full-table subscription to a table.
-	*/
-	export interface SubscriptionOptions extends DataOptions {
+		get uniqueValues():Map<string, number>;
 		/**
-		* Minimum interval between updates, in milliseconds. If not specified, the server default will be used,
-		* typically 1000ms.
+		* Gets a map with the display name of statistics as keys and the numeric stat as a value.
 		* <p>
-		* Note that setting this to smaller values will not necessarily result in more frequent updates - the server
-		* may not propagate updates that frequently, or there may be no updates to propagate.
-		*/
-		updateIntervalMs?:number|null;
-	}
-	/**
-	* Represents a row available in a subscription/snapshot on the client. Do not retain references to rows - they will
-	* not function properly when the event isn't actively going off (or promise resolving). Instead, wait for the next
-	* event, or re-request the viewport data.
-	*/
-	export interface Row {
-		get(column:Column):any;
-		getFormat(column:Column):Format;
-		get index():LongWrapper;
-	}
-	/**
-	* Options for requesting table data, either as a snapshot or a subscription. See subtypes for more specific options:
-	* <ul>
-	* <li>{@link dh.SnapshotOptions} for snapshot-specific options</li>
-	* <li>{@link dh.SubscriptionOptions} for full-table subscription-specific options</li>
-	* <li>{@link dh.ViewportSubscriptionOptions} for viewport subscription-specific options</li>
-	* </ul>
-	*/
-	export interface DataOptions {
-		/**
-		* Optional preview instructions for columns in the table data.
-		*/
-		previewOptions?:PreviewOptions|null;
-		/**
-		* Required property to indicate which columns should be included in the table data.
+		* A map of each statistic's name to its value.
+		* @return Map of String and Object
 		*/
-		columns:Array<Column>;
+		get statisticsMap():Map<string, object>;
 	}
 	/**
-	* 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.
+	* Extends {@link dh.TableData}, but only contains data in the current viewport. The only API change from TableData is that
+	* ViewportData also contains the offset to this data, so that the actual row number may be determined.
 	* <p>
-	* 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.
+	* For viewport subscriptions, it is not necessary to read with the key, only with the position.
 	* <p>
-	* 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.
+	* 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 SubscriptionTableData extends TableData {
-		get fullIndex():RangeSet;
+	export interface ViewportData extends TableData {
 		/**
-		* The ordered set of row indexes removed since the last update
-		* @return the rangeset of removed rows
+		* Reads a row object from the viewport, based on its position in the table.
 		*/
-		get removed():RangeSet;
+		get(index:LongWrapper|number):ViewportRow;
+		getData(index:LongWrapper|number, column:Column):any;
+		getFormat(index:LongWrapper|number, column:Column):Format;
 		/**
-		* The ordered set of row indexes added since the last update.
-		* @return the rangeset of rows added
+		* The position of the first returned row within the table.
 		*/
-		get added():RangeSet;
+		get offset():number;
 		get columns():Array<Column>;
-		/**
-		* The ordered set of row indexes updated since the last update
-		* @return the rnageset of modified rows
-		*/
-		get modified():RangeSet;
-		/**
-		* A lazily computed array of all rows available on the client.
-		*/
-		get rows():Array<Row>;
-	}
-	/**
-	* Wrap LocalTime values for use in JS. Provides text formatting for display and access to the underlying value.
-	*/
-	export interface LocalTimeWrapper {
-		valueOf():string;
-		getHour():number;
-		getMinute():number;
-		getSecond():number;
-		getNano():number;
-		toString():string;
-	}
-	/**
-	* This object may be pooled internally or discarded and not updated. Do not retain references to it.
-	*/
-	export interface Format {
-		/**
-		* The format string to apply to the value of this cell.
-		* @return String
-		*/
-		readonly formatString?:string|null;
-		/**
-		* Color to apply to the cell's background, in <b>#rrggbb</b> format.
-		* @return String
-		*/
-		readonly backgroundColor?:string|null;
-		/**
-		* Color to apply to the text, in <b>#rrggbb</b> format.
-		* @return String
-		*/
-		readonly color?:string|null;
-		/**
-		* 
-		* @deprecated Prefer formatString. Number format string to apply to the value in this cell.
-		*/
-		readonly numberFormat?:string|null;
-	}
-	/**
-	* 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[];
+		get rows():Array<ViewportRow>;
 	}
-	/**
-	* Options for requesting a snapshot of a table.
-	*/
-	export interface SnapshotOptions extends DataOptions {
-		/**
-		* If true, the snapshot will be filled starting from the end of the table, where 0 is the last row of the
-		* table. Default is false.
-		*/
-		isReverseViewport?:boolean|null;
-		/**
-		* The rows to include in the snapshot. This can be either a {@link dh.RangeSet} or a single range with
-		* `first` and `last` properties.
-		*/
-		rows:RangeSet|SimpleRange;
+	export interface RefreshToken {
+		get bytes():string;
+		get expiry():number;
 	}
 	/**
 	* Represents a table which can be joined to another table. Current implementations are {@link dh.Table} and
@@ -646,13 +602,49 @@ export namespace dh {
 		naturalJoin(rightTable:JoinableTable, columnsToMatch:Array<string>, columnsToAdd?:Array<string>|undefined|null):Promise<Table>;
 	}
 	/**
-	* Similar to the browser `CustomEvent` type, this class holds only the type of the event, and optionally some
-	* details about the event.
-	* @typeParam T - the type of the event detail
+	* 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 Event<T> {
-		get detail():T;
-		get type():string;
+	export interface TreeRow extends Row {
+		get(column:Column):any;
+		getFormat(column:Column):Format;
+		/**
+		* 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 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;
+	}
+	export interface WorkerHeapInfo {
+		/**
+		* Total heap size available for this worker.
+		*/
+		get totalHeapSize():number;
+		get freeMemory():number;
+		get maximumHeapSize():number;
+	}
+	/**
+	* Represents a row available in a subscription/snapshot on the client. Do not retain references to rows - they will
+	* not function properly when the event isn't actively going off (or promise resolving). Instead, wait for the next
+	* event, or re-request the viewport data.
+	*/
+	export interface Row {
+		get(column:Column):any;
+		getFormat(column:Column):Format;
+		get index():LongWrapper;
 	}
 	export interface LayoutHints {
 		readonly searchDisplayMode?:SearchDisplayModeType|null;
@@ -665,324 +657,565 @@ export namespace dh {
 		get backColumns():string[]|null;
 	}
 	/**
-	* Extends {@link dh.TableData}, but only contains data in the current viewport. The only API change from TableData is that
-	* ViewportData also contains the offset to this data, so that the actual row number may be determined.
-	* <p>
-	* For viewport subscriptions, it is not necessary to read with the key, only with the position.
-	* <p>
-	* 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.
+	* This object may be pooled internally or discarded and not updated. Do not retain references to it.
 	*/
-	export interface ViewportData extends TableData {
+	export interface Format {
 		/**
-		* Reads a row object from the viewport, based on its position in the table.
+		* The format string to apply to the value of this cell.
+		* @return String
 		*/
-		get(index:LongWrapper|number):ViewportRow;
-		getData(index:LongWrapper|number, column:Column):any;
-		getFormat(index:LongWrapper|number, column:Column):Format;
+		readonly formatString?:string|null;
 		/**
-		* The position of the first returned row within the table.
+		* Color to apply to the cell's background, in <b>#rrggbb</b> format.
+		* @return String
 		*/
-		get offset():number;
-		get columns():Array<Column>;
-		get rows():Array<ViewportRow>;
-	}
-	/**
-	* Represents statistics for a given table column.
-	*/
-	export interface ColumnStatistics {
+		readonly backgroundColor?:string|null;
 		/**
-		* 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
+		* Color to apply to the text, in <b>#rrggbb</b> format.
 		* @return String
 		*/
-		getType(name:string):string;
+		readonly color?:string|null;
 		/**
-		* 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
+		* 
+		* @deprecated Prefer formatString. Number format string to apply to the value in this cell.
 		*/
-		get uniqueValues():Map<string, number>;
+		readonly numberFormat?:string|null;
+	}
+	/**
+	* Options for requesting a full-table subscription to a table.
+	*/
+	export interface SubscriptionOptions extends DataOptions {
 		/**
-		* Gets a map with the display name of statistics as keys and the numeric stat as a value.
+		* Minimum interval between updates, in milliseconds. If not specified, the server default will be used,
+		* typically 1000ms.
 		* <p>
-		* A map of each statistic's name to its value.
-		* @return Map of String and Object
+		* Note that setting this to smaller values will not necessarily result in more frequent updates - the server
+		* may not propagate updates that frequently, or there may be no updates to propagate.
 		*/
-		get statisticsMap():Map<string, object>;
+		updateIntervalMs?:number|null;
 	}
 	/**
-	* Options for requesting a viewport subscription to a table.
+	* Options for requesting a preview of columns when requesting table data. The two properties
+	* {@link dh.convertArrayToString} and {@link dh.array} are mutually exclusive.
 	*/
-	export interface ViewportSubscriptionOptions extends SubscriptionOptions {
+	export interface PreviewOptions {
 		/**
-		* If true, the viewport will be filled starting from the end of the table, where 0 is the last row of the
-		* table. Default is false.
+		* If true, any array columns will be converted to strings for preview purposes. This is the legacy behavior.
 		*/
-		isReverseViewport?:boolean|null;
+		convertArrayToString?:boolean|null;
 		/**
-		* The rows to include in the viewport. This can be either a {@link dh.RangeSet} or a single range with
-		* `first` and `last` properties.
+		* Specifies the length of the array to serialize. If the array is longer than this length, one extra element
+		* will be included - the client is expected to truncate the array and append "..." to indicate that there are
+		* additional elements. Negative values indicate that the values should be counted from the end of the array
+		* rather than the beginning. Zero or null indicate that the entire array should be serialized. The default is
+		* null.
 		*/
-		rows:RangeSet|SimpleRange;
+		array?:number|null;
 	}
 	/**
-	* 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.
+	* Common interface for various ways of accessing table data and formatting for viewport or non-viewport subscriptions
+	* on tables, data in trees, and snapshots.
+	* <p>
+	* Generally speaking, it is more efficient to access data in column-major order, rather than iterating through each Row
+	* and accessing all columns that it holds. The {@link rows} accessor can be useful to read row data, but may
+	* incur other costs - it is likely faster to access data by columns using {@link getData}.
 	*/
-	export interface WidgetExportedObject {
+	export interface TableData {
 		/**
-		* 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.
+		* Reads a row object from the table, from which any subscribed column can be read.
+		* @param index - the position or key to access
+		* @return the row at the given location
 		*/
-		readonly type?:string|null;
-
+		get(index:LongWrapper|number):Row;
 		/**
-		* 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.
+		* Reads a specific cell from the table, by row key and column.
+		* @param index - the row in the table to get data from
+		* @param column - the column to read
+		* @return the value in the table
 		*/
-		reexport():Promise<WidgetExportedObject>;
+		getData(index:LongWrapper|number, column:Column):any;
 		/**
-		* 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.
+		* The server-specified Format to use for the cell at the given position.
+		* @param index - the row to read
+		* @param column - the column to read
+		* @return a Format instance with any server-specified details
 		*/
-		fetch():Promise<any>;
+		getFormat(index:LongWrapper|number, column:Column):Format;
+		get columns():Array<Column>;
 		/**
-		* 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.
+		* A lazily computed array of all rows available on the client.
 		*/
-		close():void;
+		get rows():Array<Row>;
 	}
 	/**
-	* Row implementation that also provides additional read-only properties. represents visible rows in the table, but
-	* with additional properties to reflect the tree structure.
+	* 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.
+	* <p>
+	* 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.
+	* <p>
+	* 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 TreeRow extends Row {
-		get(column:Column):any;
-		getFormat(column:Column):Format;
+	export interface SubscriptionTableData extends TableData {
+		get fullIndex():RangeSet;
 		/**
-		* 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
+		* The ordered set of row indexes removed since the last update
+		* @return the rangeset of removed rows
 		*/
-		get isExpanded():boolean;
+		get removed():RangeSet;
 		/**
-		* 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 ordered set of row indexes added since the last update.
+		* @return the rangeset of rows added
 		*/
-		get depth():number;
+		get added():RangeSet;
+		get columns():Array<Column>;
 		/**
-		* 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 ordered set of row indexes updated since the last update
+		* @return the rnageset of modified rows
 		*/
-		get hasChildren():boolean;
-		get index():LongWrapper;
+		get modified():RangeSet;
+		/**
+		* A lazily computed array of all rows available on the client.
+		*/
+		get rows():Array<Row>;
 	}
-	export interface RefreshToken {
-		get bytes():string;
-		get expiry():number;
+	/**
+	* Simple range consisting only of start and end numbers. Will be migrated to deephaven-core in the near future, and
+	* subsequently removed from this the coreplus namespace.
+	*/
+	export interface SimpleRange {
+		first:number;
+		last:number;
 	}
 
-	export class IdeSession implements HasEventHandling {
-		static readonly EVENT_COMMANDSTARTED:string;
-		static readonly EVENT_REQUEST_FAILED:string;
+	export class DateWrapper extends LongWrapper {
+		protected constructor();
+
+		static ofJsDate(date:Date):DateWrapper;
+		asDate():Date;
+	}
 
+	export class LongWrapper {
 		protected constructor();
 
+		static ofString(str:string):LongWrapper;
+		asNumber():number;
+		valueOf():string;
+		toString():string;
+	}
+
+	/**
+	* Describes a grouping and aggregations for a roll-up table. Pass to the <b>Table.rollup</b> function to create a
+	* roll-up table.
+	*/
+	export class RollupConfig {
 		/**
-		* Load the named table, with columns and size information already fully populated.
-		* @param name - the name of the table to fetch
-		* @param applyPreviewColumns - false to disable previews, defaults to true
-		* @return a {@link Promise} that will resolve to the table, or reject with an error if it cannot be loaded.
-		* @deprecated Added to resolve a specific issue, in the future preview will be applied as part of the subscription.
+		* Ordered list of columns to group by to form the hierarchy of the resulting roll-up table.
 		*/
-		getTable(name:string, applyPreviewColumns?:boolean):Promise<Table>;
+		groupingColumns:Array<String>;
 		/**
-		* Load the named Figure, including its tables and tablemaps as needed.
-		* @param name - 
-		* @return promise of dh.plot.Figure
+		* Mapping from each aggregation name to the ordered list of columns it should be applied to in the resulting
+		* roll-up table.
 		*/
-		getFigure(name:string):Promise<dh.plot.Figure>;
+		aggregations:{ [key: string]: Array<string>; };
 		/**
-		* 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}
+		* Optional parameter indicating if an extra leaf node should be added at the bottom of the hierarchy, showing the
+		* rows in the underlying table which make up that grouping. Since these values might be a different type from the
+		* rest of the column, any client code must check if TreeRow.hasChildren = false, and if so, interpret those values
+		* as if they were Column.constituentType instead of Column.type. Defaults to false.
 		*/
-		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>;
+		includeConstituents:boolean;
+		includeOriginalColumns?:boolean|null;
 		/**
-		* Merges the given tables into a single table. Assumes all tables have the same structure.
-		* @param tables - 
-		* @return {@link Promise} of {@link dh.Table}
+		* Optional parameter indicating if original column descriptions should be included. Defaults to true.
 		*/
-		mergeTables(tables:Table[]):Promise<Table>;
-		bindTableToVariable(table:Table, name:string):Promise<void>;
+		includeDescriptions: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;
+		equals(o:object):boolean;
+		hashCode():number;
+	}
+
+	/**
+	* Describes how a Totals Table will be generated from its parent table. Each table has a default (which may be null)
+	* indicating how that table was configured when it was declared, and each Totals Table has a similar property
+	* describing how it was created. Both the <b>Table.getTotalsTable</b> and <b>Table.getGrandTotalsTable</b> methods take
+	* this config as an optional parameter - without it, the table's default will be used, or if null, a default instance
+	* of <b>TotalsTableConfig</b> will be supplied.
+	*
+	* 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 {
 		/**
-		* Makes the `object` available to another user or another client on this same server which knows the value of
-		* the `sharedTicketBytes`. Use that sharedTicketBytes value like a one-time use password - any other client
-		* which knows this value can read the same object.
-		* <p>
-		* Shared objects will remain available using the sharedTicketBytes until the client that first shared them
-		* releases/closes their copy of the object. Whatever side-channel is used to share the bytes, be sure to wait until
-		* the remote end has signaled that it has successfully fetched the object before releasing it from this client.
-		* <p>
-		* Be sure to use an unpredictable value for the shared ticket bytes, like a UUID or other large, random value to
-		* prevent access by unauthorized clients.
-		* @param object - the object to share with another client/user
-		* @param sharedTicketBytes - the value which another client/user must know to obtain the object. It may be a unicode
-		*        string (will be encoded as utf8 bytes), or a {@link Uint8Array} value.
-		* @return A promise that will resolve to the value passed as sharedTicketBytes when the object is ready to be read
-		*         by another client, or will reject if an error occurs.
+		* @deprecated
 		*/
-		shareObject(object:Table|Widget|WidgetExportedObject|PartitionedTable|TotalsTable|TreeTable, sharedTicketBytes:string|Uint8Array):Promise<string|Uint8Array>;
+		static readonly COUNT:string;
 		/**
-		* Reads an object shared by another client to this server with the `sharedTicketBytes`. Until the other
-		* client releases this object (or their session ends), the object will be available on the server.
-		* <p>
-		* The type of the object must be passed so that the object can be read from the server correct - the other client
-		* should provide this information.
-		* @param sharedTicketBytes - the value provided by another client/user to obtain the object. It may be a unicode
-		*        string (will be encoded as utf8 bytes), or a {@link Uint8Array} value.
-		* @param type - The type of the object, so it can be correctly read from the server
-		* @return A promise that will resolve to the shared object, or will reject with an error if it cannot be read.
+		* @deprecated
 		*/
-		getSharedObject(sharedTicketBytes:string|Uint8Array, type:string):Promise<any>;
-		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;
+		static readonly MIN:string;
 		/**
-		* 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}
+		* @deprecated
 		*/
-		emptyTable(size:number):Promise<Table>;
+		static readonly MAX: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}
+		* @deprecated
 		*/
-		timeTable(periodNanos:number, startTime?:DateWrapper):Promise<Table>;
-		addEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<T>>;
-		hasListeners(name:string):boolean;
-		removeEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):boolean;
+		static readonly SUM:string;
+		/**
+		* @deprecated
+		*/
+		static readonly ABS_SUM:string;
+		/**
+		* @deprecated
+		*/
+		static readonly VAR:string;
+		/**
+		* @deprecated
+		*/
+		static readonly AVG:string;
+		/**
+		* @deprecated
+		*/
+		static readonly STD:string;
+		/**
+		* @deprecated
+		*/
+		static readonly FIRST:string;
+		/**
+		* @deprecated
+		*/
+		static readonly LAST:string;
+		/**
+		* @deprecated
+		*/
+		static readonly SKIP:string;
+		/**
+		* Specifies if a Totals Table should be expanded by default in the UI. Defaults to false.
+		*/
+		showTotalsByDefault:boolean;
+		/**
+		* Specifies if a Grand Totals Table should be expanded by default in the UI. Defaults to false.
+		*/
+		showGrandTotalsByDefault:boolean;
+		/**
+		* Specifies the default operation for columns that do not have a specific operation applied; defaults to "Sum".
+		*/
+		defaultOperation:AggregationOperationType;
+		/**
+		* 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.
+		*/
+		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;
+	}
+
+	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();
 	}
 
 	/**
-	* Describes the structure of the column, and if desired can be used to get access to the data to be rendered in this
-	* column.
+	* 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 Column {
-		/**
-		* 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
-		*/
-		readonly constituentType?:string|null;
-		readonly description?:string|null;
-
+	export class InputTable {
 		protected constructor();
 
 		/**
-		* the value for this column in the given row. Type will be consistent with the type of the Column.
+		* 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 - 
-		* @return Any
+		* @param userTimeZone - 
+		* @return Promise of dh.InputTable
 		*/
-		get(row:Row):any;
-		getFormat(row:Row):Format;
+		addRow(row:{ [key: string]: any; }, userTimeZone?:string):Promise<InputTable>;
 		/**
-		* Creates a sort builder object, to be used when sorting by this column.
-		* @return {@link dh.Sort}
+		* Add multiple rows to a table.
+		* @param rows - 
+		* @param userTimeZone - 
+		* @return Promise of dh.InputTable
 		*/
-		sort():Sort;
+		addRows(rows:{ [key: string]: any; }[], userTimeZone?:string):Promise<InputTable>;
 		/**
-		* 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}
+		* 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
 		*/
-		filter():FilterValue;
+		addTable(tableToAdd:Table):Promise<InputTable>;
 		/**
-		* a <b>CustomColumn</b> object to apply using `applyCustomColumns` with the expression specified.
-		* @param expression - 
-		* @return {@link dh.CustomColumn}
+		* Add multiple tables to this Input Table.
+		* @param tablesToAdd - 
+		* @return Promise of dh.InputTable
 		*/
-		formatColor(expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		addTables(tablesToAdd:Table[]):Promise<InputTable>;
 		/**
-		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
-		* @param expression - 
-		* @return {@link dh.CustomColumn}
+		* Deletes an entire table from this Input Table. Key columns must match the Input Table.
+		* @param tableToDelete - 
+		* @return Promise of dh.InputTable
 		*/
-		formatNumber(expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		deleteTable(tableToDelete:Table):Promise<InputTable>;
 		/**
-		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
-		* @param expression - 
-		* @return {@link dh.CustomColumn}
+		* Delete multiple tables from this Input Table.
+		* @param tablesToDelete - 
+		* @return 
 		*/
-		formatDate(expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		deleteTables(tablesToDelete:Table[]):Promise<InputTable>;
+		/**
+		* 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 keyColumns():Column[];
+		/**
+		* A list of the value Column objects
+		* @return {@link dh.Column} array.
+		*/
+		get valueColumns():Column[];
+		/**
+		* The source table for this Input Table
+		* @return dh.table
+		*/
+		get table():Table;
+	}
+
+	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;
+		static from(columnInfo:string):CustomColumn;
 		/**
-		* Label for this column.
+		* The expression to evaluate this custom column.
 		* @return String
 		*/
-		get name():string;
+		get expression():string;
 		/**
-		* True if this column is a partition column. Partition columns are used for filtering uncoalesced tables - see
-		* {@link Table.uncoalesced}.
-		* @return true if the column is a partition column
+		* The name of the column to use.
+		* @return String
 		*/
-		get isPartitionColumn():boolean;
+		get name():string;
 		/**
-		* 
-		* @deprecated do not use. Internal index of the column in the table, to be used as a key on the Row.
-		* @return int
+		* The options for this custom column.
+		* @return CustomColumOptions
 		*/
-		get index():number;
-		get isSortable():boolean;
+		get options():CustomColumnOptions;
 		/**
-		* Type of the row data that can be found in this column.
+		* Type of custom column. One of
+		*
+		* <ul>
+		* <li>FORMAT_COLOR</li>
+		* <li>FORMAT_NUMBER</li>
+		* <li>FORMAT_DATE</li>
+		* <li>NEW</li>
+		* </ul>
 		* @return String
 		*/
 		get type():string;
+	}
+
+	/**
+	* 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();
+
 		/**
-		* 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 - 
-		* @param options - 
-		* @return {@link dh.CustomColumn}
+		* the opposite of this condition
+		* @return FilterCondition
 		*/
-		static formatRowColor(expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		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;
+	}
+
+	/**
+	* 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();
+
+		/**
+		* 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
+		*/
+		get isAbs():boolean;
+		/**
+		* The column which is sorted.
+		* @return {@link dh.Column}
+		*/
+		get column():Column;
+		/**
+		* The direction of this sort, either <b>ASC</b>, <b>DESC</b>, or <b>REVERSE</b>.
+		* @return String
+		*/
+		get direction():string;
+	}
+
+	/**
+	* Options for custom columns.
+	*/
+	export class CustomColumnOptions {
 		/**
-		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
-		* @param name - 
-		* @param expression - 
-		* @param options - 
-		* @return {@link dh.CustomColumn}
+		* When specified for custom columns on a rollup table, specifies if the formula apply to rollup or constituent
+		* nodes.
 		*/
-		static createCustomColumn(name:string, expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		rollupNodeType?:RollupNodeTypeType|null;
+
+		constructor();
+	}
+
+	/**
+	* 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 TableMap {
+		static readonly EVENT_KEYADDED:string;
+		static readonly EVENT_DISCONNECT:string;
+		static readonly EVENT_RECONNECT:string;
+		static readonly EVENT_RECONNECTFAILED:string;
+
+		protected constructor();
 	}
 
 	/**
@@ -1364,482 +1597,88 @@ export namespace dh {
 		*/
 		removeEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):boolean;
 		/**
-		* a Sort than can be used to reverse a table. This can be passed into n array in applySort. Note that Tree Tables
-		* do not support reverse.
-		* @return {@link dh.Sort}
-		*/
-		static reverse():Sort;
-	}
-
-
-	export class DateWrapper extends LongWrapper {
-		protected constructor();
-
-		static ofJsDate(date:Date):DateWrapper;
-		asDate():Date;
-	}
-
-	export class LoginCredentials {
-		type?:string|null;
-		username?:string|null;
-		token?:string|null;
-
-		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;
-	}
-
-	/**
-	* 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
-		*/
-		static readonly LAST:string;
-		/**
-		* @deprecated
-		*/
-		static readonly SKIP:string;
-		/**
-		* Specifies if a Totals Table should be expanded by default in the UI. Defaults to false.
-		*/
-		showTotalsByDefault:boolean;
-		/**
-		* Specifies if a Grand Totals Table should be expanded by default in the UI. Defaults to false.
-		*/
-		showGrandTotalsByDefault:boolean;
-		/**
-		* Specifies the default operation for columns that do not have a specific operation applied; defaults to "Sum".
-		*/
-		defaultOperation:AggregationOperationType;
-		/**
-		* 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.
-		*/
-		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;
-	}
-
-	/**
-	* 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.
-	* <p>
-	* 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.
-	* <p>
-	* 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 {
-		protected constructor();
-
-		static createTableSubscription(options:SubscriptionOptions, existingTable:Table):TableSubscription;
-		/**
-		* Updates the subscription to use the given columns and update interval.
-		* @param columns - the new columns to subscribe to
-		* @param updateIntervalMs - the new update interval, or null/omit to use the default of one second
-		*/
-		changeSubscription(columns:Array<Column>, updateIntervalMs:number|undefined|null):void;
-		/**
-		* Update the options for this viewport subscription. This cannot alter the update interval or preview options.
-		* @param options - the subscription options
-		*/
-		update(options:SubscriptionOptions):void;
-		get columns():Array<Column>;
-		/**
-		* Stops the subscription on the server.
-		*/
-		close():void;
-		/**
-		* 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:dh.Event<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<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:dh.Event<T>)=>void):boolean;
-	}
-
-	/**
-	* A Widget represents a server side object that sends one or more responses to the client. The client can then
-	* interpret these responses to see what to render, or how to respond.
-	* <p>
-	* Most custom object types result in a single response being sent to the client, often with other exported objects, but
-	* some will have streamed responses, and allow the client to send follow-up requests of its own. This class's API is
-	* backwards compatible, but as such does not offer a way to tell the difference between a streaming or non-streaming
-	* object type, the client code that handles the payloads is expected to know what to expect. See
-	* {@link dh.WidgetMessageDetails} for more information.
-	* <p>
-	* When the promise that returns this object resolves, it will have the first response assigned to its fields. Later
-	* responses from the server will be emitted as "message" events. When the connection with the server ends, the "close"
-	* event will be emitted. In this way, the connection will behave roughly in the same way as a WebSocket - either side
-	* can close, and after close no more messages will be processed. There can be some latency in closing locally while
-	* remote messages are still pending - it is up to implementations of plugins to handle this case.
-	* <p>
-	* Also like WebSockets, the plugin API doesn't define how to serialize messages, and just handles any binary payloads.
-	* What it does handle however, is allowing those messages to include references to server-side objects with those
-	* payloads. Those server side objects might be tables or other built-in types in the Deephaven JS API, or could be
-	* objects usable through their own plugins. They also might have no plugin at all, allowing the client to hold a
-	* reference to them and pass them back to the server, either to the current plugin instance, or through another API.
-	* The `Widget` type does not specify how those objects should be used or their lifecycle, but leaves that
-	* entirely to the plugin. Messages will arrive in the order they were sent.
-	* <p>
-	* This can suggest several patterns for how plugins operate:
-	* <ul>
-	* <li>The plugin merely exists to transport some other object to the client. This can be useful for objects which can
-	* easily be translated to some other type (like a Table) when the user clicks on it. An example of this is
-	* `pandas.DataFrame` will result in a widget that only contains a static
-	* {@link dh.Table}. Presently, the widget is immediately closed, and only the Table is
-	* provided to the JS API consumer.</li>
-	* <li>The plugin provides references to Tables and other objects, and those objects can live longer than the object
-	* which provided them. One concrete example of this could have been
-	* {@link dh.PartitionedTable} when fetching constituent tables, but it was implemented
-	* before bidirectional plugins were implemented. Another example of this is plugins that serve as a "factory", giving
-	* the user access to table manipulation/creation methods not supported by gRPC or the JS API.</li>
-	* <li>The plugin provides reference to Tables and other objects that only make sense within the context of the widget
-	* instance, so when the widget goes away, those objects should be released as well. This is also an example of
-	* {@link dh.PartitionedTable}, as the partitioned table tracks creation of new keys through
-	* an internal table instance.</li>
-	* </ul>
-	*
-	* Handling server objects in messages also has more than one potential pattern that can be used:
-	* <ul>
-	* <li>One object per message - the message clearly is about that object, no other details required.</li>
-	* <li>Objects indexed within their message - as each message comes with a list of objects, those objects can be
-	* referenced within the payload by index. This is roughly how {@link dh.plot.Figure}
-	* behaves, where the figure descriptor schema includes an index for each created series, describing which table should
-	* be used, which columns should be mapped to each axis.</li>
-	* <li>Objects indexed since widget creation - each message would append its objects to a list created when the widget
-	* was first made, and any new exports that arrive in a new message would be appended to that list. Then, subsequent
-	* messages can reference objects already sent. This imposes a limitation where the client cannot release any exports
-	* without the server somehow signaling that it will never reference that export again.</li>
-	* </ul>
-	*/
-	export class Widget implements WidgetMessageDetails, HasEventHandling {
-		static readonly EVENT_MESSAGE:string;
-		static readonly EVENT_CLOSE:string;
-
-		protected constructor();
-
-		/**
-		* Ends the client connection to the server.
-		*/
-		close():void;
-		getDataAsBase64():string;
-		getDataAsU8():Uint8Array;
-		getDataAsString():string;
-		/**
-		* Sends a string/bytes payload to the server, along with references to objects that exist on the server.
-		* @param msg - string/buffer/view instance that represents data to send
-		* @param references - an array of objects that can be safely sent to the server
-		*/
-		sendMessage(msg:string|ArrayBuffer|ArrayBufferView, references?:Array<Table|Widget|WidgetExportedObject|PartitionedTable|TotalsTable|TreeTable>):void;
-		addEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<T>>;
-		hasListeners(name:string):boolean;
-		removeEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):boolean;
-		/**
-		* 
-		* @return the exported objects sent in the initial message from the server. The client is responsible for closing
-		*         them when finished using them.
-		*/
-		get exportedObjects():WidgetExportedObject[];
-		/**
-		* 
-		* @return the type of this widget
+		* a Sort than can be used to reverse a table. This can be passed into n array in applySort. Note that Tree Tables
+		* do not support reverse.
+		* @return {@link dh.Sort}
 		*/
-		get type():string;
-	}
-
-	/**
-	* 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;
-		equals(o:object):boolean;
-		hashCode():number;
+		static reverse():Sort;
 	}
 
-	/**
-	* 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;
-		equals(o:object):boolean;
-		hashCode():number;
-	}
 
 	/**
-	* 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.
+	* 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 class InputTable {
-		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
-		*/
-		addTable(tableToAdd:Table):Promise<InputTable>;
+	export class PartitionedTable implements HasEventHandling {
 		/**
-		* Add multiple tables to this Input Table.
-		* @param tablesToAdd - 
-		* @return Promise of dh.InputTable
+		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
 		*/
-		addTables(tablesToAdd:Table[]):Promise<InputTable>;
+		static readonly EVENT_KEYADDED:string;
 		/**
-		* Deletes an entire table from this Input Table. Key columns must match the Input Table.
-		* @param tableToDelete - 
-		* @return Promise of dh.InputTable
+		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
 		*/
-		deleteTable(tableToDelete:Table):Promise<InputTable>;
+		static readonly EVENT_DISCONNECT:string;
 		/**
-		* Delete multiple tables from this Input Table.
-		* @param tablesToDelete - 
-		* @return 
+		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
 		*/
-		deleteTables(tablesToDelete:Table[]):Promise<InputTable>;
+		static readonly EVENT_RECONNECT:string;
 		/**
-		* A list of the key columns, by name
-		* @return String array.
+		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
 		*/
-		get keys():string[];
+		static readonly EVENT_RECONNECTFAILED:string;
+
+		protected constructor();
+
 		/**
-		* A list of the value columns, by name
-		* @return String array.
+		* 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.
 		*/
-		get values():string[];
+		getTable(key:object):Promise<Table|undefined|null>;
 		/**
-		* A list of the key columns.
-		* @return Column array.
+		* 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.
 		*/
-		get keyColumns():Column[];
+		getMergedTable():Promise<Table>;
 		/**
-		* A list of the value Column objects
-		* @return {@link dh.Column} array.
+		* 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
 		*/
-		get valueColumns():Column[];
+		getKeys():Set<object>;
 		/**
-		* The source table for this Input Table
-		* @return dh.table
+		* Fetch a table containing all the valid keys of the partitioned table.
+		* @return Promise of a Table
+		* @deprecated
 		*/
-		get table():Table;
-	}
-
-	/**
-	* 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 class TableViewportSubscription implements HasEventHandling {
-		protected constructor();
-
+		getKeyTable():Promise<Table>;
 		/**
-		* 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 - 
-		* @deprecated use {@link #update(Object)} instead
+		* Fetch the underlying base table of the partitioned table.
+		* @return Promise of a Table
 		*/
-		setViewport(firstRow:number, lastRow:number, columns?:Column[]|undefined|null, updateIntervalMs?:number|undefined|null, isReverseViewport?:boolean|undefined|null):void;
+		getBaseTable():Promise<Table>;
 		/**
-		* Update the options for this viewport subscription. This cannot alter the update interval or preview options.
-		* @param options - the subscription options
+		* Indicates that this PartitionedTable will no longer be used, removing subcriptions to updated keys, etc. This
+		* will not affect tables in use.
 		*/
-		update(options:ViewportSubscriptionOptions):void;
+		close():void;
 		/**
-		* Stops this viewport from running, stopping all events on itself and on the table that created it.
+		* The count of known keys.
+		* @return int
 		*/
-		close():void;
+		get size():number;
 		/**
-		* Gets the data currently visible in this viewport
-		* @return Promise of {@link dh.TableData}.
+		* 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
 		*/
-		getViewportData():Promise<ViewportData>;
+		get columns():Column[];
 		/**
-		* 
-		* @deprecated Use {@link JsTable#createSnapshot(Object)} instead
+		* An array of all the key columns that the tables are partitioned by.
+		* @return Array of Column
 		*/
-		snapshot(rows:RangeSet, columns:Column[]):Promise<TableData>;
+		get keyColumns():Column[];
 		/**
 		* Listen for events on this object.
 		* @param name - the name of the event to listen for
@@ -2090,6 +1929,48 @@ export namespace dh {
 		removeEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):boolean;
 	}
 
+	/**
+	* Addition optional configuration that can be passed to the {@link dh.CoreClient} constructor.
+	*/
+	export class ConnectOptions {
+		/**
+		* Optional map of http header names and values to send to the server with each request.
+		*/
+		headers?:{ [key: string]: string; }|null;
+		/**
+		* True to enable debug logging. At this time, only enables logging for gRPC calls.
+		*/
+		debug?:boolean|null;
+		/**
+		* Set this to true to force the use of websockets when connecting to the deephaven instance, false to force the use
+		* of `fetch`. Ignored if {@link dh.transportFactory} is set.
+		* <p>
+		* Defaults to null, indicating that the server URL should be checked to see if we connect with fetch or websockets.
+		*/
+		useWebsockets?:boolean|null;
+		/**
+		* The transport factory to use for creating gRPC streams. If specified, the JS API will ignore
+		* {@link dh.useWebsockets} and its own internal logic for determining the appropriate transport to use.
+		* <p>
+		* Defaults to null, indicating that the JS API should determine the appropriate transport to use. If
+		* `useWebsockets` is set to true, the JS API will use websockets, otherwise if the server url begins with
+		* https, it will use fetch, otherwise it will use websockets.
+		*/
+		transportFactory?:dh.grpc.GrpcTransportFactory|null;
+
+		constructor();
+	}
+
+	/**
+	* Event fired when a command is issued from the client.
+	*/
+	export class CommandInfo {
+		constructor(code:string, result:Promise<dh.ide.CommandResult>);
+
+		get result():Promise<dh.ide.CommandResult>;
+		get code():string;
+	}
+
 	/**
 	* 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
@@ -2263,299 +2144,150 @@ export namespace dh {
 	}
 
 	/**
-	* Describes a grouping and aggregations for a roll-up table. Pass to the <b>Table.rollup</b> function to create a
-	* roll-up table.
-	*/
-	export class RollupConfig {
-		/**
-		* Ordered list of columns to group by to form the hierarchy of the resulting roll-up table.
-		*/
-		groupingColumns:Array<String>;
-		/**
-		* Mapping from each aggregation name to the ordered list of columns it should be applied to in the resulting
-		* roll-up table.
-		*/
-		aggregations:{ [key: string]: Array<string>; };
-		/**
-		* Optional parameter indicating if an extra leaf node should be added at the bottom of the hierarchy, showing the
-		* rows in the underlying table which make up that grouping. Since these values might be a different type from the
-		* rest of the column, any client code must check if TreeRow.hasChildren = false, and if so, interpret those values
-		* as if they were Column.constituentType instead of Column.type. Defaults to false.
-		*/
-		includeConstituents:boolean;
-		includeOriginalColumns?:boolean|null;
-		/**
-		* Optional parameter indicating if original column descriptions should be included. Defaults to true.
-		*/
-		includeDescriptions:boolean;
-
-		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();
-
-		/**
-		* 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
-		*/
-		get isAbs():boolean;
-		/**
-		* The column which is sorted.
-		* @return {@link dh.Column}
-		*/
-		get column():Column;
-		/**
-		* The direction of this sort, either <b>ASC</b>, <b>DESC</b>, or <b>REVERSE</b>.
-		* @return String
-		*/
-		get direction():string;
-	}
-
-	export class 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_REQUEST_FAILED:string;
-		static readonly EVENT_REQUEST_STARTED:string;
-		static readonly EVENT_REQUEST_SUCCEEDED:string;
-		/**
-		* @deprecated
-		*/
-		static readonly EVENT_REFRESH_TOKEN_UPDATED: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:dh.Event<T>)=>void):()=>void;
-		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<T>>;
-		hasListeners(name:string):boolean;
-		removeEventListener<T>(name:string, callback:(e:dh.Event<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();
-	}
-
-	/**
-	* 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
+	* Wrap BigDecimal values for use in JS. Provides text formatting for display and access to the underlying value.
 	*/
-	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();
-	}
-
-	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;
-
+	export class BigDecimalWrapper {
 		protected constructor();
 
-		valueOf():string;
-		toString():string;
-		static from(columnInfo:string):CustomColumn;
-		/**
-		* The expression to evaluate this custom column.
-		* @return String
-		*/
-		get expression():string;
-		/**
-		* The name of the column to use.
-		* @return String
-		*/
-		get name():string;
-		/**
-		* The options for this custom column.
-		* @return CustomColumOptions
-		*/
-		get options():CustomColumnOptions;
-		/**
-		* Type of custom column. One of
-		*
-		* <ul>
-		* <li>FORMAT_COLOR</li>
-		* <li>FORMAT_NUMBER</li>
-		* <li>FORMAT_DATE</li>
-		* <li>NEW</li>
-		* </ul>
-		* @return String
-		*/
-		get type():string;
-	}
-
-	/**
-	* 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 column representing the unique ID for each item
-		*/
-		idColumn:string;
-		/**
-		* The column representing the parent ID for each item
-		*/
-		parentColumn:string;
-		/**
-		* Optional parameter indicating if items with an invalid parent ID should be promoted to root. Defaults to false.
-		*/
-		promoteOrphansToRoot:boolean;
-
-		constructor();
-	}
-
-	/**
-	* Options for custom columns.
-	*/
-	export class CustomColumnOptions {
-		/**
-		* When specified for custom columns on a rollup table, specifies if the formula apply to rollup or constituent
-		* nodes.
-		*/
-		rollupNodeType?:RollupNodeTypeType|null;
-
-		constructor();
+		static ofString(value:string):BigDecimalWrapper;
+		asNumber():number;
+		valueOf():string;
+		toString():string;
+		equals(o:object):boolean;
+		hashCode():number;
 	}
 
-	export class QueryInfo {
-		static readonly EVENT_TABLE_OPENED:string;
-		static readonly EVENT_DISCONNECT:string;
-		static readonly EVENT_RECONNECT:string;
-		static readonly EVENT_CONNECT:string;
+	export class IdeSession implements HasEventHandling {
+		static readonly EVENT_COMMANDSTARTED:string;
+		static readonly EVENT_REQUEST_FAILED:string;
 
 		protected 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.
-	*/
-	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.
-		*/
-		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.
+		* Load the named table, with columns and size information already fully populated.
+		* @param name - the name of the table to fetch
+		* @param applyPreviewColumns - false to disable previews, defaults to true
+		* @return a {@link Promise} that will resolve to the table, or reject with an error if it cannot be loaded.
+		* @deprecated Added to resolve a specific issue, in the future preview will be applied as part of the subscription.
 		*/
-		static readonly EVENT_RECONNECT:string;
+		getTable(name:string, applyPreviewColumns?:boolean):Promise<Table>;
 		/**
-		* Indicates that a new key has been added to the array of keys, which can now be fetched with getTable.
+		* Load the named Figure, including its tables and tablemaps as needed.
+		* @param name - 
+		* @return promise of dh.plot.Figure
 		*/
-		static readonly EVENT_RECONNECTFAILED:string;
-
-		protected constructor();
-
+		getFigure(name:string):Promise<dh.plot.Figure>;
 		/**
-		* 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.
+		* 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}
 		*/
-		getTable(key:object):Promise<Table|undefined|null>;
+		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>;
 		/**
-		* 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.
+		* Merges the given tables into a single table. Assumes all tables have the same structure.
+		* @param tables - 
+		* @return {@link Promise} of {@link dh.Table}
 		*/
-		getMergedTable():Promise<Table>;
+		mergeTables(tables:Table[]):Promise<Table>;
+		bindTableToVariable(table:Table, name:string):Promise<void>;
 		/**
-		* 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
+		* Makes the `object` available to another user or another client on this same server which knows the value of
+		* the `sharedTicketBytes`. Use that sharedTicketBytes value like a one-time use password - any other client
+		* which knows this value can read the same object.
+		* <p>
+		* Shared objects will remain available using the sharedTicketBytes until the client that first shared them
+		* releases/closes their copy of the object. Whatever side-channel is used to share the bytes, be sure to wait until
+		* the remote end has signaled that it has successfully fetched the object before releasing it from this client.
+		* <p>
+		* Be sure to use an unpredictable value for the shared ticket bytes, like a UUID or other large, random value to
+		* prevent access by unauthorized clients.
+		* @param object - the object to share with another client/user
+		* @param sharedTicketBytes - the value which another client/user must know to obtain the object. It may be a unicode
+		*        string (will be encoded as utf8 bytes), or a {@link Uint8Array} value.
+		* @return A promise that will resolve to the value passed as sharedTicketBytes when the object is ready to be read
+		*         by another client, or will reject if an error occurs.
 		*/
-		getKeys():Set<object>;
+		shareObject(object:Table|Widget|WidgetExportedObject|PartitionedTable|TotalsTable|TreeTable, sharedTicketBytes:string|Uint8Array):Promise<string|Uint8Array>;
 		/**
-		* Fetch a table containing all the valid keys of the partitioned table.
-		* @return Promise of a Table
-		* @deprecated
+		* Reads an object shared by another client to this server with the `sharedTicketBytes`. Until the other
+		* client releases this object (or their session ends), the object will be available on the server.
+		* <p>
+		* The type of the object must be passed so that the object can be read from the server correct - the other client
+		* should provide this information.
+		* @param sharedTicketBytes - the value provided by another client/user to obtain the object. It may be a unicode
+		*        string (will be encoded as utf8 bytes), or a {@link Uint8Array} value.
+		* @param type - The type of the object, so it can be correctly read from the server
+		* @return A promise that will resolve to the shared object, or will reject with an error if it cannot be read.
 		*/
-		getKeyTable():Promise<Table>;
+		getSharedObject(sharedTicketBytes:string|Uint8Array, type:string):Promise<any>;
+		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;
 		/**
-		* Fetch the underlying base table of the partitioned table.
-		* @return Promise of a Table
+		* 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}
 		*/
-		getBaseTable():Promise<Table>;
+		emptyTable(size:number):Promise<Table>;
 		/**
-		* Indicates that this PartitionedTable will no longer be used, removing subcriptions to updated keys, etc. This
-		* will not affect tables in use.
+		* 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}
 		*/
-		close():void;
+		timeTable(periodNanos:number, startTime?:DateWrapper):Promise<Table>;
+		addEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<T>>;
+		hasListeners(name:string):boolean;
+		removeEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):boolean;
+	}
+
+	/**
+	* 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.
+	* <p>
+	* 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.
+	* <p>
+	* 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 {
+		protected constructor();
+
+		static createTableSubscription(options:SubscriptionOptions, existingTable:Table):TableSubscription;
 		/**
-		* The count of known keys.
-		* @return int
+		* Updates the subscription to use the given columns and update interval.
+		* @param columns - the new columns to subscribe to
+		* @param updateIntervalMs - the new update interval, or null/omit to use the default of one second
 		*/
-		get size():number;
+		changeSubscription(columns:Array<Column>, updateIntervalMs:number|undefined|null):void;
 		/**
-		* 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
+		* Update the options for this viewport subscription. This cannot alter the update interval or preview options.
+		* @param options - the subscription options
 		*/
-		get columns():Column[];
+		update(options:SubscriptionOptions):void;
+		get columns():Array<Column>;
 		/**
-		* An array of all the key columns that the tables are partitioned by.
-		* @return Array of Column
+		* Stops the subscription on the server.
 		*/
-		get keyColumns():Column[];
+		close():void;
 		/**
 		* Listen for events on this object.
 		* @param name - the name of the event to listen for
@@ -2577,22 +2309,101 @@ export namespace dh {
 	}
 
 	/**
-	* Event fired when a command is issued from the client.
+	* 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 CommandInfo {
-		constructor(code:string, result:Promise<dh.ide.CommandResult>);
-
-		get result():Promise<dh.ide.CommandResult>;
-		get code():string;
-	}
+	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_SHUTDOWN:string;
 
-	export class LongWrapper {
 		protected constructor();
 
-		static ofString(str:string):LongWrapper;
-		asNumber():number;
-		valueOf():string;
-		toString():string;
+		/**
+		* Closes the current connection, releasing any resources on the server or client.
+		*/
+		close():void;
+		running():Promise<IdeConnection>;
+		/**
+		* Load the named table, with columns and size information already fully populated.
+		* @param name - the name of the table to fetch
+		* @param applyPreviewColumns - false to disable previews, defaults to true
+		* @return a {@link Promise} that will resolve to the table, or reject with an error if it cannot be loaded.
+		* @deprecated Added to resolve a specific issue, in the future preview will be applied as part of the subscription.
+		*/
+		getTable(name:string, applyPreviewColumns?:boolean):Promise<Table>;
+		getObject(definitionObject:dh.ide.VariableDescriptor):Promise<any>;
+		subscribeToFieldUpdates(callback:(arg0:dh.ide.VariableChanges)=>void):()=>void;
+		/**
+		* Makes an `object` available to another user or another client on this same server which knows the value of
+		* the `sharedTicketBytes`. Use that sharedTicketBytes value like a one-time use password - any other client
+		* which knows this value can read the same object.
+		* <p>
+		* Shared objects will remain available using the sharedTicketBytes until the client that first shared them
+		* releases/closes their copy of the object. Whatever side-channel is used to share the bytes, be sure to wait until
+		* the remote end has signaled that it has successfully fetched the object before releasing it from this client.
+		* <p>
+		* Be sure to use an unpredictable value for the shared ticket bytes, like a UUID or other large, random value to
+		* prevent access by unauthorized clients.
+		* @param object - the object to share with another client/user
+		* @param sharedTicketBytes - the value which another client/user must know to obtain the object. It may be a unicode
+		*        string (will be encoded as utf8 bytes), or a {@link Uint8Array} value.
+		* @return A promise that will resolve to the value passed as sharedTicketBytes when the object is ready to be read
+		*         by another client, or will reject if an error occurs.
+		*/
+		shareObject(object:Table|Widget|WidgetExportedObject|PartitionedTable|TotalsTable|TreeTable, sharedTicketBytes:string|Uint8Array):Promise<string|Uint8Array>;
+		/**
+		* Reads an object shared by another client to this server with the `sharedTicketBytes`. Until the other
+		* client releases this object (or their session ends), the object will be available on the server.
+		* <p>
+		* The type of the object must be passed so that the object can be read from the server correct - the other client
+		* should provide this information.
+		* @param sharedTicketBytes - the value provided by another client/user to obtain the object. It may be a unicode
+		*        string (will be encoded as utf8 bytes), or a {@link Uint8Array} value.
+		* @param type - The type of the object, so it can be correctly read from the server
+		* @return A promise that will resolve to the shared object, or will reject with an error if it cannot be read.
+		*/
+		getSharedObject(sharedTicketBytes:string|Uint8Array, type:string):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>;
+		/**
+		* 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:dh.Event<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<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:dh.Event<T>)=>void):boolean;
 	}
 
 	/**
@@ -2621,116 +2432,281 @@ export namespace dh {
 		get size():number;
 	}
 
+	export class LoginCredentials {
+		type?:string|null;
+		username?:string|null;
+		token?:string|null;
+
+		constructor();
+	}
+
 	/**
-	* Addition optional configuration that can be passed to the {@link dh.CoreClient} constructor.
+	* 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 ConnectOptions {
+	export class Column {
 		/**
-		* Optional map of http header names and values to send to the server with each request.
+		* 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
 		*/
-		headers?:{ [key: string]: string; }|null;
+		readonly constituentType?:string|null;
+		readonly description?:string|null;
+
+		protected constructor();
+
 		/**
-		* True to enable debug logging. At this time, only enables logging for gRPC calls.
+		* the value for this column in the given row. Type will be consistent with the type of the Column.
+		* @param row - 
+		* @return Any
 		*/
-		debug?:boolean|null;
+		get(row:Row):any;
+		getFormat(row:Row):Format;
 		/**
-		* Set this to true to force the use of websockets when connecting to the deephaven instance, false to force the use
-		* of `fetch`. Ignored if {@link dh.transportFactory} is set.
-		* <p>
-		* Defaults to null, indicating that the server URL should be checked to see if we connect with fetch or websockets.
+		* Creates a sort builder object, to be used when sorting by this column.
+		* @return {@link dh.Sort}
 		*/
-		useWebsockets?:boolean|null;
+		sort():Sort;
 		/**
-		* The transport factory to use for creating gRPC streams. If specified, the JS API will ignore
-		* {@link dh.useWebsockets} and its own internal logic for determining the appropriate transport to use.
-		* <p>
-		* Defaults to null, indicating that the JS API should determine the appropriate transport to use. If
-		* `useWebsockets` is set to true, the JS API will use websockets, otherwise if the server url begins with
-		* https, it will use fetch, otherwise it will use websockets.
+		* 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}
 		*/
-		transportFactory?:dh.grpc.GrpcTransportFactory|null;
+		filter():FilterValue;
+		/**
+		* a <b>CustomColumn</b> object to apply using `applyCustomColumns` with the expression specified.
+		* @param expression - 
+		* @return {@link dh.CustomColumn}
+		*/
+		formatColor(expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		/**
+		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
+		* @param expression - 
+		* @return {@link dh.CustomColumn}
+		*/
+		formatNumber(expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		/**
+		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
+		* @param expression - 
+		* @return {@link dh.CustomColumn}
+		*/
+		formatDate(expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		toString():string;
+		/**
+		* Label for this column.
+		* @return String
+		*/
+		get name():string;
+		/**
+		* True if this column is a partition column. Partition columns are used for filtering uncoalesced tables - see
+		* {@link Table.uncoalesced}.
+		* @return true if the column is a partition column
+		*/
+		get isPartitionColumn():boolean;
+		/**
+		* 
+		* @deprecated do not use. Internal index of the column in the table, to be used as a key on the Row.
+		* @return int
+		*/
+		get index():number;
+		get isSortable():boolean;
+		/**
+		* Type of the row data that can be found in this column.
+		* @return String
+		*/
+		get type():string;
+		/**
+		* 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 - 
+		* @param options - 
+		* @return {@link dh.CustomColumn}
+		*/
+		static formatRowColor(expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+		/**
+		* a <b>CustomColumn</b> object to apply using <b>applyCustomColumns</b> with the expression specified.
+		* @param name - 
+		* @param expression - 
+		* @param options - 
+		* @return {@link dh.CustomColumn}
+		*/
+		static createCustomColumn(name:string, expression:string, options?:CustomColumnOptions|undefined|null):CustomColumn;
+	}
+
+	/**
+	* 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 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_REQUEST_FAILED:string;
+		static readonly EVENT_REQUEST_STARTED:string;
+		static readonly EVENT_REQUEST_SUCCEEDED:string;
+		/**
+		* @deprecated
+		*/
+		static readonly EVENT_REFRESH_TOKEN_UPDATED: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:dh.Event<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<T>>;
+		hasListeners(name:string):boolean;
+		removeEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):boolean;
+	}
+
 	/**
-	* 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.
+	* A Widget represents a server side object that sends one or more responses to the client. The client can then
+	* interpret these responses to see what to render, or how to respond.
+	* <p>
+	* Most custom object types result in a single response being sent to the client, often with other exported objects, but
+	* some will have streamed responses, and allow the client to send follow-up requests of its own. This class's API is
+	* backwards compatible, but as such does not offer a way to tell the difference between a streaming or non-streaming
+	* object type, the client code that handles the payloads is expected to know what to expect. See
+	* {@link dh.WidgetMessageDetails} for more information.
+	* <p>
+	* When the promise that returns this object resolves, it will have the first response assigned to its fields. Later
+	* responses from the server will be emitted as "message" events. When the connection with the server ends, the "close"
+	* event will be emitted. In this way, the connection will behave roughly in the same way as a WebSocket - either side
+	* can close, and after close no more messages will be processed. There can be some latency in closing locally while
+	* remote messages are still pending - it is up to implementations of plugins to handle this case.
+	* <p>
+	* Also like WebSockets, the plugin API doesn't define how to serialize messages, and just handles any binary payloads.
+	* What it does handle however, is allowing those messages to include references to server-side objects with those
+	* payloads. Those server side objects might be tables or other built-in types in the Deephaven JS API, or could be
+	* objects usable through their own plugins. They also might have no plugin at all, allowing the client to hold a
+	* reference to them and pass them back to the server, either to the current plugin instance, or through another API.
+	* The `Widget` type does not specify how those objects should be used or their lifecycle, but leaves that
+	* entirely to the plugin. Messages will arrive in the order they were sent.
+	* <p>
+	* This can suggest several patterns for how plugins operate:
+	* <ul>
+	* <li>The plugin merely exists to transport some other object to the client. This can be useful for objects which can
+	* easily be translated to some other type (like a Table) when the user clicks on it. An example of this is
+	* `pandas.DataFrame` will result in a widget that only contains a static
+	* {@link dh.Table}. Presently, the widget is immediately closed, and only the Table is
+	* provided to the JS API consumer.</li>
+	* <li>The plugin provides references to Tables and other objects, and those objects can live longer than the object
+	* which provided them. One concrete example of this could have been
+	* {@link dh.PartitionedTable} when fetching constituent tables, but it was implemented
+	* before bidirectional plugins were implemented. Another example of this is plugins that serve as a "factory", giving
+	* the user access to table manipulation/creation methods not supported by gRPC or the JS API.</li>
+	* <li>The plugin provides reference to Tables and other objects that only make sense within the context of the widget
+	* instance, so when the widget goes away, those objects should be released as well. This is also an example of
+	* {@link dh.PartitionedTable}, as the partitioned table tracks creation of new keys through
+	* an internal table instance.</li>
+	* </ul>
+	*
+	* Handling server objects in messages also has more than one potential pattern that can be used:
+	* <ul>
+	* <li>One object per message - the message clearly is about that object, no other details required.</li>
+	* <li>Objects indexed within their message - as each message comes with a list of objects, those objects can be
+	* referenced within the payload by index. This is roughly how {@link dh.plot.Figure}
+	* behaves, where the figure descriptor schema includes an index for each created series, describing which table should
+	* be used, which columns should be mapped to each axis.</li>
+	* <li>Objects indexed since widget creation - each message would append its objects to a list created when the widget
+	* was first made, and any new exports that arrive in a new message would be appended to that list. Then, subsequent
+	* messages can reference objects already sent. This imposes a limitation where the client cannot release any exports
+	* without the server somehow signaling that it will never reference that export again.</li>
+	* </ul>
 	*/
-	export class IdeConnection implements HasEventHandling {
+	export class Widget implements WidgetMessageDetails, HasEventHandling {
+		static readonly EVENT_MESSAGE:string;
+		static readonly EVENT_CLOSE:string;
+
+		protected constructor();
+
 		/**
-		* @deprecated
+		* Ends the client connection to the server.
 		*/
-		static readonly HACK_CONNECTION_FAILURE:string;
-		static readonly EVENT_DISCONNECT:string;
-		static readonly EVENT_RECONNECT:string;
-		static readonly EVENT_SHUTDOWN:string;
+		close():void;
+		getDataAsBase64():string;
+		getDataAsU8():Uint8Array;
+		getDataAsString():string;
+		/**
+		* Sends a string/bytes payload to the server, along with references to objects that exist on the server.
+		* @param msg - string/buffer/view instance that represents data to send
+		* @param references - an array of objects that can be safely sent to the server
+		*/
+		sendMessage(msg:string|ArrayBuffer|ArrayBufferView, references?:Array<Table|Widget|WidgetExportedObject|PartitionedTable|TotalsTable|TreeTable>):void;
+		addEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):()=>void;
+		nextEvent<T>(eventName:string, timeoutInMillis?:number):Promise<Event<T>>;
+		hasListeners(name:string):boolean;
+		removeEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):boolean;
+		/**
+		* 
+		* @return the exported objects sent in the initial message from the server. The client is responsible for closing
+		*         them when finished using them.
+		*/
+		get exportedObjects():WidgetExportedObject[];
+		/**
+		* 
+		* @return the type of this widget
+		*/
+		get type():string;
+	}
 
+	/**
+	* 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 class TableViewportSubscription implements HasEventHandling {
 		protected constructor();
 
 		/**
-		* Closes the current connection, releasing any resources on the server or client.
-		*/
-		close():void;
-		running():Promise<IdeConnection>;
-		/**
-		* Load the named table, with columns and size information already fully populated.
-		* @param name - the name of the table to fetch
-		* @param applyPreviewColumns - false to disable previews, defaults to true
-		* @return a {@link Promise} that will resolve to the table, or reject with an error if it cannot be loaded.
-		* @deprecated Added to resolve a specific issue, in the future preview will be applied as part of the subscription.
+		* 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 - 
+		* @deprecated use {@link #update(Object)} instead
 		*/
-		getTable(name:string, applyPreviewColumns?:boolean):Promise<Table>;
-		getObject(definitionObject:dh.ide.VariableDescriptor):Promise<any>;
-		subscribeToFieldUpdates(callback:(arg0:dh.ide.VariableChanges)=>void):()=>void;
+		setViewport(firstRow:number, lastRow:number, columns?:Column[]|undefined|null, updateIntervalMs?:number|undefined|null, isReverseViewport?:boolean|undefined|null):void;
 		/**
-		* Makes an `object` available to another user or another client on this same server which knows the value of
-		* the `sharedTicketBytes`. Use that sharedTicketBytes value like a one-time use password - any other client
-		* which knows this value can read the same object.
-		* <p>
-		* Shared objects will remain available using the sharedTicketBytes until the client that first shared them
-		* releases/closes their copy of the object. Whatever side-channel is used to share the bytes, be sure to wait until
-		* the remote end has signaled that it has successfully fetched the object before releasing it from this client.
-		* <p>
-		* Be sure to use an unpredictable value for the shared ticket bytes, like a UUID or other large, random value to
-		* prevent access by unauthorized clients.
-		* @param object - the object to share with another client/user
-		* @param sharedTicketBytes - the value which another client/user must know to obtain the object. It may be a unicode
-		*        string (will be encoded as utf8 bytes), or a {@link Uint8Array} value.
-		* @return A promise that will resolve to the value passed as sharedTicketBytes when the object is ready to be read
-		*         by another client, or will reject if an error occurs.
+		* Update the options for this viewport subscription. This cannot alter the update interval or preview options.
+		* @param options - the subscription options
 		*/
-		shareObject(object:Table|Widget|WidgetExportedObject|PartitionedTable|TotalsTable|TreeTable, sharedTicketBytes:string|Uint8Array):Promise<string|Uint8Array>;
+		update(options:ViewportSubscriptionOptions):void;
 		/**
-		* Reads an object shared by another client to this server with the `sharedTicketBytes`. Until the other
-		* client releases this object (or their session ends), the object will be available on the server.
-		* <p>
-		* The type of the object must be passed so that the object can be read from the server correct - the other client
-		* should provide this information.
-		* @param sharedTicketBytes - the value provided by another client/user to obtain the object. It may be a unicode
-		*        string (will be encoded as utf8 bytes), or a {@link Uint8Array} value.
-		* @param type - The type of the object, so it can be correctly read from the server
-		* @return A promise that will resolve to the shared object, or will reject with an error if it cannot be read.
+		* Stops this viewport from running, stopping all events on itself and on the table that created it.
 		*/
-		getSharedObject(sharedTicketBytes:string|Uint8Array, type:string):Promise<any>;
-		newTable(columnNames:string[], types:string[], data:string[][], userTimeZone:string):Promise<Table>;
+		close():void;
 		/**
-		* Merges the given tables into a single table. Assumes all tables have the same structure.
-		* @param tables - 
-		* @return {@link Promise} of {@link dh.Table}
+		* Gets the data currently visible in this viewport
+		* @return Promise of {@link dh.TableData}.
 		*/
-		mergeTables(tables:Table[]):Promise<Table>;
+		getViewportData():Promise<ViewportData>;
 		/**
-		* 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}
+		* 
+		* @deprecated Use {@link JsTable#createSnapshot(Object)} instead
 		*/
-		onLogMessage(callback:(arg0:dh.ide.LogItem)=>void):()=>void;
-		startSession(type:string):Promise<IdeSession>;
-		getConsoleTypes():Promise<Array<string>>;
-		getWorkerHeapInfo():Promise<WorkerHeapInfo>;
+		snapshot(rows:RangeSet, columns:Column[]):Promise<TableData>;
 		/**
 		* Listen for events on this object.
 		* @param name - the name of the event to listen for
@@ -2751,6 +2727,30 @@ export namespace dh {
 		removeEventListener<T>(name:string, callback:(e:dh.Event<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 {
+		/**
+		* The column representing the unique ID for each item
+		*/
+		idColumn:string;
+		/**
+		* The column representing the parent ID for each item
+		*/
+		parentColumn:string;
+		/**
+		* Optional parameter indicating if items with an invalid parent ID should be promoted to root. Defaults to false.
+		*/
+		promoteOrphansToRoot:boolean;
+
+		constructor();
+	}
+
 
 	type ValueTypeType = string;
 	export class ValueType {
@@ -2762,6 +2762,31 @@ 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;
+	}
+
+	/**
+	* Describes the type of node in a rollup table.
+	*/
+	type RollupNodeTypeType = string;
+	export class RollupNodeType {
+		static readonly ROLLUP_NODE_TYPE_AGGREGATED:RollupNodeTypeType;
+		static readonly ROLLUP_NODE_TYPE_CONSTITUENT:RollupNodeTypeType;
+	}
+
 	/**
 	* This enum describes the name of each supported operation/aggregation type when creating a `TreeTable`.
 	*/
@@ -2784,15 +2809,6 @@ export namespace dh {
 		static readonly SKIP:AggregationOperationType;
 	}
 
-	/**
-	* Describes the type of node in a rollup table.
-	*/
-	type RollupNodeTypeType = string;
-	export class RollupNodeType {
-		static readonly ROLLUP_NODE_TYPE_AGGREGATED:RollupNodeTypeType;
-		static readonly ROLLUP_NODE_TYPE_CONSTITUENT:RollupNodeTypeType;
-	}
-
 	type SearchDisplayModeType = string;
 	export class SearchDisplayMode {
 		static readonly SEARCH_DISPLAY_DEFAULT:SearchDisplayModeType;
@@ -2800,26 +2816,59 @@ export namespace dh {
 		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;
-	}
-
 }
 
 export namespace dh.ide {
 
+	/**
+	* 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 {
+		/**
+		* Describes changes made in the course of this command.
+		* @return {@link dh.ide.VariableChanges}.
+		*/
+		get changes():VariableChanges;
+		/**
+		* If the command failed, the error message will be provided here.
+		* @return String
+		*/
+		get error():string;
+		/**
+		* The timestamp when the command finished running.
+		* @return DateWrapper
+		*/
+		get endTimestamp():dh.DateWrapper;
+		/**
+		* The timestamp when the command started running.
+		* @return DateWrapper
+		*/
+		get startTimestamp():dh.DateWrapper;
+	}
 	/**
 	* A format to describe a variable available to be read from the server. Application fields are optional, and only
 	* populated when a variable is provided by application mode.
@@ -2878,66 +2927,17 @@ export namespace dh.ide {
 		* The level of the log message, enabling the client to ignore messages.
 		* @return String
 		*/
-		get logLevel():string;
-		/**
-		* Timestamp of the message in microseconds since Jan 1, 1970 UTC.
-		* @return double
-		*/
-		get micros():number;
-		/**
-		* The log message written on the server.
-		* @return String
-		*/
-		get message():string;
-	}
-	/**
-	* Indicates the result of code run on the server.
-	*/
-	export interface CommandResult {
-		/**
-		* Describes changes made in the course of this command.
-		* @return {@link dh.ide.VariableChanges}.
-		*/
-		get changes():VariableChanges;
-		/**
-		* If the command failed, the error message will be provided here.
-		* @return String
-		*/
-		get error():string;
-		/**
-		* The timestamp when the command finished running.
-		* @return DateWrapper
-		*/
-		get endTimestamp():dh.DateWrapper;
-		/**
-		* The timestamp when the command started running.
-		* @return DateWrapper
-		*/
-		get startTimestamp():dh.DateWrapper;
-	}
-	/**
-	* 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>;
+		get logLevel():string;
 		/**
-		* 
-		* @return The variables that were created by this operation, or have a new type.
+		* Timestamp of the message in microseconds since Jan 1, 1970 UTC.
+		* @return double
 		*/
-		get created():Array<VariableDefinition>;
+		get micros():number;
 		/**
-		* 
-		* @return The variables that changed value during this operation.
+		* The log message written on the server.
+		* @return String
 		*/
-		get updated():Array<VariableDefinition>;
+		get message():string;
 	}
 }
 
@@ -3210,6 +3210,24 @@ export namespace dh.i18n {
 
 export namespace dh.grpc {
 
+	/**
+	* Factory for creating gRPC transports.
+	*/
+	export interface GrpcTransportFactory {
+		/**
+		* Create a new transport instance.
+		* @param options - options for creating the transport
+		* @return a transport instance to use for gRPC communication
+		*/
+		create(options:GrpcTransportOptions):GrpcTransport;
+		/**
+		* Return true to signal that created transports may have {@link GrpcTransport.sendMessage} called on it
+		* more than once before {@link GrpcTransport.finishSend} should be called.
+		* @return true to signal that the implementation can stream multiple messages, false otherwise indicating that
+		*         Open/Next gRPC calls should be used
+		*/
+		get supportsClientStreaming():boolean;
+	}
 	/**
 	* gRPC transport implementation.
 	*/
@@ -3262,96 +3280,10 @@ export namespace dh.grpc {
 		*/
 		onEnd:(error?:Error|undefined|null)=>void;
 	}
-	/**
-	* Factory for creating gRPC transports.
-	*/
-	export interface GrpcTransportFactory {
-		/**
-		* Create a new transport instance.
-		* @param options - options for creating the transport
-		* @return a transport instance to use for gRPC communication
-		*/
-		create(options:GrpcTransportOptions):GrpcTransport;
-		/**
-		* Return true to signal that created transports may have {@link GrpcTransport.sendMessage} called on it
-		* more than once before {@link GrpcTransport.finishSend} should be called.
-		* @return true to signal that the implementation can stream multiple messages, false otherwise indicating that
-		*         Open/Next gRPC calls should be used
-		*/
-		get supportsClientStreaming():boolean;
-	}
 }
 
 export namespace dh.plot {
 
-	export interface FigureDataUpdatedEvent {
-		getArray(series:Series, sourceType:number, mappingFunc?:(arg0:any)=>any):Array<any>;
-		get series():Series[];
-	}
-	/**
-	* 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;
-		/**
-		* Disable updates for this Series.
-		*/
-		unsubscribe():void;
-		get shape():string;
-		/**
-		* 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}
-		*/
-		get sources():SeriesDataSource[];
-		get lineColor():string;
-		/**
-		* The plotting style to use for this series. See <b>SeriesPlotStyle</b> enum for more details.
-		* @return int
-		*/
-		get plotStyle():SeriesPlotStyleType;
-		get oneClick():OneClick;
-		get gradientVisible():boolean;
-		get shapeColor():string;
-		/**
-		* The name for this series.
-		* @return String
-		*/
-		get name():string;
-		/**
-		* indicates that this series belongs to a MultiSeries, null otherwise
-		* @return dh.plot.MultiSeries
-		*/
-		get multiSeries():MultiSeries;
-		get shapeLabel():string;
-	}
-	/**
-	* Describes how to access and display data required within a series.
-	*/
-	export interface SeriesDataSource {
-		/**
-		* the type of data stored in the underlying table's Column.
-		* @return String
-		*/
-		get columnType():string;
-		/**
-		* the axis that this source should be drawn on.
-		* @return dh.plot.Axis
-		*/
-		get axis():Axis;
-		/**
-		* the feature of this series represented by this source. See the <b>SourceType</b> enum for more details.
-		* @return int
-		*/
-		get type():SourceTypeType;
-	}
 	/**
 	* Describes a template that will be used to make new series instances when a new table added to a plotBy.
 	*/
@@ -3441,96 +3373,73 @@ export namespace dh.plot {
 		get formatType():AxisFormatTypeType;
 		get minRange():number;
 	}
-
-	export class FigureSourceException {
-		table:dh.Table;
-		source:SeriesDataSource;
-
-		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.
+	* Describes how to access and display data required within a series.
 	*/
-	export class ChartData {
-		constructor(table:dh.Table);
-
-		update(tableData:dh.SubscriptionTableData):void;
-		getColumn(columnName:string, mappingFunc:(arg0:any)=>any, currentUpdate:dh.TableData):Array<any>;
+	export interface SeriesDataSource {
 		/**
-		* 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.
+		* the type of data stored in the underlying table's Column.
+		* @return String
 		*/
-		removeColumn(columnName:string, mappingFunc:(arg0:any)=>any):void;
-	}
-
-	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 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 FigureFetchError {
-		error:object;
-		errors:Array<string>;
-
-		protected constructor();
+		get columnType():string;
+		/**
+		* the axis that this source should be drawn on.
+		* @return dh.plot.Axis
+		*/
+		get axis():Axis;
+		/**
+		* the feature of this series represented by this source. See the <b>SourceType</b> enum for more details.
+		* @return int
+		*/
+		get type():SourceTypeType;
 	}
-
 	/**
-	* A descriptor used with JsFigureFactory.create to create a figure from JS.
+	* Provides access to the data for displaying in a figure.
 	*/
-	export class FigureDescriptor {
-		title?:string|null;
-		titleFont?:string|null;
-		titleColor?:string|null;
-		isResizable?:boolean|null;
-		isDefaultTheme?:boolean|null;
-		updateInterval?:number|null;
-		cols?:number|null;
-		rows?:number|null;
-		charts:Array<ChartDescriptor>;
+	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;
 
-		constructor();
+		subscribe(forceDisableDownsample?:DownsampleOptions):void;
+		/**
+		* Disable updates for this Series.
+		*/
+		unsubscribe():void;
+		get shape():string;
+		/**
+		* 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}
+		*/
+		get sources():SeriesDataSource[];
+		get lineColor():string;
+		/**
+		* The plotting style to use for this series. See <b>SeriesPlotStyle</b> enum for more details.
+		* @return int
+		*/
+		get plotStyle():SeriesPlotStyleType;
+		get oneClick():OneClick;
+		get gradientVisible():boolean;
+		get shapeColor():string;
+		/**
+		* The name for this series.
+		* @return String
+		*/
+		get name():string;
+		/**
+		* indicates that this series belongs to a MultiSeries, null otherwise
+		* @return dh.plot.MultiSeries
+		*/
+		get multiSeries():MultiSeries;
+		get shapeLabel():string;
+	}
+	export interface FigureDataUpdatedEvent {
+		getArray(series:Series, sourceType:number, mappingFunc?:(arg0:any)=>any):Array<any>;
+		get series():Series[];
 	}
 
 	export class ChartDescriptor {
@@ -3594,6 +3503,58 @@ export namespace dh.plot {
 		get multiSeries():MultiSeries[];
 	}
 
+	export class SourceDescriptor {
+		axis:AxisDescriptor;
+		table:dh.Table;
+		columnName:string;
+		type:string;
+
+		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 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 Figure implements dh.HasEventHandling {
 		/**
 		* The title of the figure.
@@ -3678,11 +3639,30 @@ export namespace dh.plot {
 		removeEventListener<T>(name:string, callback:(e:dh.Event<T>)=>void):boolean;
 	}
 
-	export class SeriesDataSourceException {
-		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>;
 
-		get source():SeriesDataSource;
-		get message():string;
+		constructor();
+	}
+
+	export class FigureFetchError {
+		error:object;
+		errors:Array<string>;
+
+		protected constructor();
 	}
 
 	export class DownsampleOptions {
@@ -3711,48 +3691,59 @@ export namespace dh.plot {
 		protected constructor();
 	}
 
+	export class FigureSourceException {
+		table:dh.Table;
+		source:SeriesDataSource;
+
+		protected constructor();
+	}
+
 	/**
-	* Helper class for plot downsampling methods.
+	* 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 Downsample {
-		protected constructor();
+	export class ChartData {
+		constructor(table:dh.Table);
 
+		update(tableData:dh.SubscriptionTableData):void;
+		getColumn(columnName:string, mappingFunc:(arg0:any)=>any, currentUpdate:dh.TableData):Array<any>;
 		/**
-		* 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.
+		* 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.
 		*/
-		static runChartDownsample(table:dh.Table, xCol:string, yCols:string[], width:number, xRange?:dh.LongWrapper[]|undefined|null):Promise<dh.Table>;
+		removeColumn(columnName:string, mappingFunc:(arg0:any)=>any):void;
 	}
 
-	export class SourceDescriptor {
-		axis:AxisDescriptor;
-		table:dh.Table;
-		columnName:string;
-		type:string;
+	/**
+	* A descriptor used with JsFigureFactory.create to create a figure from JS.
+	*/
+	export class FigureDescriptor {
+		title?:string|null;
+		titleFont?:string|null;
+		titleColor?:string|null;
+		isResizable?:boolean|null;
+		isDefaultTheme?:boolean|null;
+		updateInterval?:number|null;
+		cols?:number|null;
+		rows?:number|null;
+		charts:Array<ChartDescriptor>;
 
 		constructor();
 	}
 
+	export class SeriesDataSourceException {
+		protected constructor();
 
-	/**
-	* 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;
+		get source():SeriesDataSource;
+		get message():string;
+	}
+
+
+	type AxisFormatTypeType = number;
+	export class AxisFormatType {
+		static readonly CATEGORY:AxisFormatTypeType;
+		static readonly NUMBER:AxisFormatTypeType;
 	}
 
 	type AxisTypeType = number;
@@ -3765,15 +3756,6 @@ export namespace dh.plot {
 		static readonly COLOR:AxisTypeType;
 	}
 
-	type AxisPositionType = number;
-	export class AxisPosition {
-		static readonly TOP:AxisPositionType;
-		static readonly BOTTOM:AxisPositionType;
-		static readonly LEFT:AxisPositionType;
-		static readonly RIGHT:AxisPositionType;
-		static readonly NONE:AxisPositionType;
-	}
-
 	/**
 	* 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
@@ -3803,10 +3785,19 @@ export namespace dh.plot {
 		static readonly HOVER_TEXT:SourceTypeType;
 	}
 
-	type AxisFormatTypeType = number;
-	export class AxisFormatType {
-		static readonly CATEGORY:AxisFormatTypeType;
-		static readonly NUMBER:AxisFormatTypeType;
+	/**
+	* 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;
@@ -3825,25 +3816,41 @@ export namespace dh.plot {
 		static readonly TREEMAP:SeriesPlotStyleType;
 	}
 
+	type AxisPositionType = number;
+	export class AxisPosition {
+		static readonly TOP:AxisPositionType;
+		static readonly BOTTOM:AxisPositionType;
+		static readonly LEFT:AxisPositionType;
+		static readonly RIGHT:AxisPositionType;
+		static readonly NONE:AxisPositionType;
+	}
+
 }
 
 export namespace dh.lsp {
 
-	export class Hover {
-		contents:MarkupContent;
+	export class TextDocumentContentChangeEvent {
 		range:Range;
+		rangeLength:number;
+		text:string;
 
 		constructor();
 	}
 
-	export class TextDocumentContentChangeEvent {
+	export class TextEdit {
 		range:Range;
-		rangeLength:number;
 		text:string;
 
 		constructor();
 	}
 
+	export class MarkupContent {
+		kind:string;
+		value:string;
+
+		constructor();
+	}
+
 	export class ParameterInformation {
 		label:string;
 		documentation:MarkupContent;
@@ -3864,18 +3871,19 @@ export namespace dh.lsp {
 		copy():Position;
 	}
 
-	export class MarkupContent {
-		kind:string;
-		value:string;
-
-		constructor();
-	}
-
-	export class SignatureInformation {
+	export class CompletionItem {
 		label:string;
+		kind:number;
+		detail:string;
 		documentation:MarkupContent;
-		parameters:Array<ParameterInformation>;
-		activeParameter:number;
+		deprecated:boolean;
+		preselect:boolean;
+		textEdit:TextEdit;
+		sortText:string;
+		filterText:string;
+		insertTextFormat:number;
+		additionalTextEdits:Array<TextEdit>;
+		commitCharacters:Array<string>;
 
 		constructor();
 	}
@@ -3889,26 +3897,18 @@ export namespace dh.lsp {
 		isInside(innerStart:Position, innerEnd:Position):boolean;
 	}
 
-	export class TextEdit {
-		range:Range;
-		text:string;
+	export class SignatureInformation {
+		label:string;
+		documentation:MarkupContent;
+		parameters:Array<ParameterInformation>;
+		activeParameter:number;
 
 		constructor();
 	}
 
-	export class CompletionItem {
-		label:string;
-		kind:number;
-		detail:string;
-		documentation:MarkupContent;
-		deprecated:boolean;
-		preselect:boolean;
-		textEdit:TextEdit;
-		sortText:string;
-		filterText:string;
-		insertTextFormat:number;
-		additionalTextEdits:Array<TextEdit>;
-		commitCharacters:Array<string>;
+	export class Hover {
+		contents:MarkupContent;
+		range:Range;
 
 		constructor();
 	}
@@ -3917,6 +3917,10 @@ export namespace dh.lsp {
 
 export namespace dh.calendar {
 
+	export interface BusinessPeriod {
+		get close():string;
+		get open():string;
+	}
 	/**
 	* Defines a calendar with business hours and holidays.
 	*/
@@ -3947,10 +3951,6 @@ 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.