// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { Aggregate } from "./Aggregate.js";
import type { ColumnConfigValues } from "./ColumnConfigValues.js";
import type { Expressions } from "./Expressions.js";
import type { Filter } from "./Filter.js";
import type { FilterReducer } from "./FilterReducer.js";
import type { OptionalUpdate } from "./OptionalUpdate.js";
import type { PluginConfig } from "./PluginConfig.js";
import type { Sort } from "./Sort.js";

export type ViewerConfigUpdate = { version?: OptionalUpdate<string>, plugin?: OptionalUpdate<string>, title?: OptionalUpdate<string>, theme?: OptionalUpdate<string>, settings?: OptionalUpdate<boolean>, plugin_config?: PluginConfig | null, columns_config?: OptionalUpdate<{ [key in string]?: ColumnConfigValues }>, 
/**
 * A group by _groups_ the dataset by the unique values of each column used
 * as a group by - a close analogue in SQL to the `GROUP BY` statement.
 * The underlying dataset is aggregated to show the values belonging to
 * each group, and a total row is calculated for each group, showing
 * the currently selected aggregated value (e.g. `sum`) of the column.
 * Group by are useful for hierarchies, categorizing data and
 * attributing values, i.e. showing the number of units sold based on
 * State and City. In Perspective, group by are represented as an array
 * of string column names to pivot, are applied in the order provided;
 * For example, a group by of `["State", "City", "Postal Code"]` shows
 * the values for each Postal Code, which are grouped by City,
 * which are in turn grouped by State.
 */
group_by?: Array<string>, 
/**
 * A split by _splits_ the dataset by the unique values of each column used
 * as a split by. The underlying dataset is not aggregated, and a new
 * column is created for each unique value of the split by. Each newly
 * created column contains the parts of the dataset that correspond to
 * the column header, i.e. a `View` that has `["State"]` as its split
 * by will have a new column for each state. In Perspective, Split By
 * are represented as an array of string column names to pivot.
 */
split_by?: Array<string>, 
/**
 * The `columns` property specifies which columns should be included in the
 * [`crate::View`]'s output. This allows users to show or hide a specific
 * subset of columns, as well as control the order in which columns
 * appear to the user. This is represented in Perspective as an array
 * of string column names.
 */
columns?: Array<string | null>, 
/**
 * The `filter` property specifies columns on which the query can be
 * filtered, returning rows that pass the specified filter condition.
 * This is analogous to the `WHERE` clause in SQL. There is no limit on
 * the number of columns where `filter` is applied, but the resulting
 * dataset is one that passes all the filter conditions, i.e. the
 * filters are joined with an `AND` condition.
 *
 * Perspective represents `filter` as an array of arrays, with the values
 * of each inner array being a string column name, a string filter
 * operator, and a filter operand in the type of the column.
 */
filter?: Array<Filter>, 
/**
 * The `sort` property specifies columns on which the query should be
 * sorted, analogous to `ORDER BY` in SQL. A column can be sorted
 * regardless of its data type, and sorts can be applied in ascending
 * or descending order. Perspective represents `sort` as an array of
 * arrays, with the values of each inner array being a string column
 * name and a string sort direction. When `column-pivots` are applied,
 * the additional sort directions `"col asc"` and `"col desc"` will
 * determine the order of pivot columns groups.
 */
sort?: Array<Sort>, 
/**
 * The `expressions` property specifies _new_ columns in Perspective that
 * are created using existing column values or arbitary scalar values
 * defined within the expression. In `<perspective-viewer>`,
 * expressions are added using the "New Column" button in the side
 * panel.
 */
expressions?: Expressions, 
/**
 * Aggregates perform a calculation over an entire column, and are
 * displayed when one or more [Group By](#group-by) are applied to the
 * `View`. Aggregates can be specified by the user, or Perspective will
 * use the following sensible default aggregates based on column type:
 *
 * - "sum" for `integer` and `float` columns
 * - "count" for all other columns
 *
 * Perspective provides a selection of aggregate functions that can be
 * applied to columns in the `View` constructor using a dictionary of
 * column name to aggregate function name.
 */
aggregates?: { [key in string]?: Aggregate }, group_by_depth?: number, filter_op?: FilterReducer, };
