declarations
Version:
[](https://www.npmjs.com/package/declarations)
976 lines (941 loc) • 42.7 kB
TypeScript
// Type definitions for Google Apps Script 2015-11-12
// Project: https://developers.google.com/apps-script/
// Definitions by: motemen <https://github.com/motemen/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference path="google-apps-script.types.d.ts" />
/// <reference path="google-apps-script.base.d.ts" />
/// <reference path="google-apps-script.ui.d.ts" />
declare namespace GoogleAppsScript {
export module Charts {
/**
* Builder for area charts. For more details, see the
* Google Charts documentation.
*
* Here is an example that shows how to build an area chart.
*
* function doGet() {
* // Create a data table with some sample data.
* var sampleData = Charts.newDataTable()
* .addColumn(Charts.ColumnType.STRING, "Month")
* .addColumn(Charts.ColumnType.NUMBER, "Dining")
* .addColumn(Charts.ColumnType.NUMBER, "Total")
* .addRow(["Jan", 60, 520])
* .addRow(["Feb", 50, 430])
* .addRow(["Mar", 53, 440])
* .addRow(["Apr", 70, 410])
* .addRow(["May", 80, 390])
* .addRow(["Jun", 60, 500])
* .addRow(["Jul", 100, 450])
* .addRow(["Aug", 140, 431])
* .addRow(["Sep", 75, 488])
* .addRow(["Oct", 70, 521])
* .addRow(["Nov", 58, 388])
* .addRow(["Dec", 63, 400])
* .build();
*
* var chart = Charts.newAreaChart()
* .setTitle('Yearly Spending')
* .setXAxisTitle('Month')
* .setYAxisTitle('Spending (USD)')
* .setDimensions(600, 500)
* .setStacked()
* .setColors(['red', 'green'])
* .setDataTable(sampleData)
* .build();
*
* return UiApp.createApplication().add(chart);
* }
*/
export interface AreaChartBuilder {
build(): Chart;
reverseCategories(): AreaChartBuilder;
setBackgroundColor(cssValue: string): AreaChartBuilder;
setColors(cssValues: String[]): AreaChartBuilder;
setDataSourceUrl(url: string): AreaChartBuilder;
setDataTable(tableBuilder: DataTableBuilder): AreaChartBuilder;
setDataTable(table: DataTableSource): AreaChartBuilder;
setDataViewDefinition(dataViewDefinition: DataViewDefinition): AreaChartBuilder;
setDimensions(width: Integer, height: Integer): AreaChartBuilder;
setLegendPosition(position: Position): AreaChartBuilder;
setLegendTextStyle(textStyle: TextStyle): AreaChartBuilder;
setOption(option: string, value: Object): AreaChartBuilder;
setPointStyle(style: PointStyle): AreaChartBuilder;
setRange(start: Number, end: Number): AreaChartBuilder;
setStacked(): AreaChartBuilder;
setTitle(chartTitle: string): AreaChartBuilder;
setTitleTextStyle(textStyle: TextStyle): AreaChartBuilder;
setXAxisTextStyle(textStyle: TextStyle): AreaChartBuilder;
setXAxisTitle(title: string): AreaChartBuilder;
setXAxisTitleTextStyle(textStyle: TextStyle): AreaChartBuilder;
setYAxisTextStyle(textStyle: TextStyle): AreaChartBuilder;
setYAxisTitle(title: string): AreaChartBuilder;
setYAxisTitleTextStyle(textStyle: TextStyle): AreaChartBuilder;
useLogScale(): AreaChartBuilder;
}
/**
* Builder for bar charts. For more details, see the
* Google Charts documentation.
*
* Here is an example that shows how to build a bar chart. The data is
*
* imported from a Google spreadsheet.
*
* function doGet() {
* // Get sample data from a spreadsheet.
* var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=B1%3AC11' +
* '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=0&headers=-1';
*
* var chartBuilder = Charts.newBarChart()
* .setTitle('Top Grossing Films in US and Canada')
* .setXAxisTitle('USD')
* .setYAxisTitle('Film')
* .setDimensions(600, 500)
* .setLegendPosition(Charts.Position.BOTTOM)
* .setDataSourceUrl(dataSourceUrl);
*
* var chart = chartBuilder.build();
* return UiApp.createApplication().add(chart);
* }
*/
export interface BarChartBuilder {
build(): Chart;
reverseCategories(): BarChartBuilder;
reverseDirection(): BarChartBuilder;
setBackgroundColor(cssValue: string): BarChartBuilder;
setColors(cssValues: String[]): BarChartBuilder;
setDataSourceUrl(url: string): BarChartBuilder;
setDataTable(tableBuilder: DataTableBuilder): BarChartBuilder;
setDataTable(table: DataTableSource): BarChartBuilder;
setDataViewDefinition(dataViewDefinition: DataViewDefinition): BarChartBuilder;
setDimensions(width: Integer, height: Integer): BarChartBuilder;
setLegendPosition(position: Position): BarChartBuilder;
setLegendTextStyle(textStyle: TextStyle): BarChartBuilder;
setOption(option: string, value: Object): BarChartBuilder;
setRange(start: Number, end: Number): BarChartBuilder;
setStacked(): BarChartBuilder;
setTitle(chartTitle: string): BarChartBuilder;
setTitleTextStyle(textStyle: TextStyle): BarChartBuilder;
setXAxisTextStyle(textStyle: TextStyle): BarChartBuilder;
setXAxisTitle(title: string): BarChartBuilder;
setXAxisTitleTextStyle(textStyle: TextStyle): BarChartBuilder;
setYAxisTextStyle(textStyle: TextStyle): BarChartBuilder;
setYAxisTitle(title: string): BarChartBuilder;
setYAxisTitleTextStyle(textStyle: TextStyle): BarChartBuilder;
useLogScale(): BarChartBuilder;
}
/**
* A builder for category filter controls.
*
* A category filter is a picker to choose one or more between a set of defined values.
* Given a column of type string, this control will filter out the rows that
* don't match any of the picked values.
*
* Here is an example that creates a table chart a binds a category filter to it. This allows the
* user to filter the data the table displays.
*
* function doGet() {
* var app = UiApp.createApplication();
* var sampleData = Charts.newDataTable()
* .addColumn(Charts.ColumnType.STRING, "Month")
* .addColumn(Charts.ColumnType.NUMBER, "Dining")
* .addColumn(Charts.ColumnType.NUMBER, "Total")
* .addRow(["Jan", 60, 520])
* .addRow(["Feb", 50, 430])
* .addRow(["Mar", 53, 440])
* .addRow(["Apr", 70, 410])
* .addRow(["May", 80, 390])
* .addRow(["Jun", 60, 500])
* .addRow(["Jul", 100, 450])
* .addRow(["Aug", 140, 431])
* .addRow(["Sep", 75, 488])
* .addRow(["Oct", 70, 521])
* .addRow(["Nov", 58, 388])
* .addRow(["Dec", 63, 400])
* .build();
*
* var chart = Charts.newTableChart()
* .setDimensions(600, 500)
* .build();
*
* var categoryFilter = Charts.newCategoryFilter()
* .setFilterColumnLabel("Month")
* .setAllowMultiple(true)
* .setSortValues(true)
* .setLabelStacking(Charts.Orientation.VERTICAL)
* .setCaption('Choose categories...')
* .build();
*
* var panel = app.createVerticalPanel().setSpacing(10);
* panel.add(categoryFilter).add(chart);
*
* var dashboard = Charts.newDashboardPanel()
* .setDataTable(sampleData)
* .bind(categoryFilter, chart)
* .build();
*
* dashboard.add(panel);
* app.add(dashboard);
* return app;
* }
*
* documentation
*/
export interface CategoryFilterBuilder {
build(): Control;
setAllowMultiple(allowMultiple: boolean): CategoryFilterBuilder;
setAllowNone(allowNone: boolean): CategoryFilterBuilder;
setAllowTyping(allowTyping: boolean): CategoryFilterBuilder;
setCaption(caption: string): CategoryFilterBuilder;
setDataTable(tableBuilder: DataTableBuilder): CategoryFilterBuilder;
setDataTable(table: DataTableSource): CategoryFilterBuilder;
setFilterColumnIndex(columnIndex: Integer): CategoryFilterBuilder;
setFilterColumnLabel(columnLabel: string): CategoryFilterBuilder;
setLabel(label: string): CategoryFilterBuilder;
setLabelSeparator(labelSeparator: string): CategoryFilterBuilder;
setLabelStacking(orientation: Orientation): CategoryFilterBuilder;
setSelectedValuesLayout(layout: PickerValuesLayout): CategoryFilterBuilder;
setSortValues(sortValues: boolean): CategoryFilterBuilder;
setValues(values: String[]): CategoryFilterBuilder;
}
/**
* A Chart object, which can be embedded into documents, UI elements, or used as a static image. For
* charts embedded in spreadsheets, see
* EmbeddedChart.
*/
export interface Chart {
getAs(contentType: string): Base.Blob;
getBlob(): Base.Blob;
getId(): string;
getOptions(): ChartOptions;
getType(): string;
setId(id: string): Chart;
}
/**
* Exposes options currently configured for a Chart, such as height, color, etc.
*
* Please see the visualization
* reference documentation for information on what options are available. Specific options for
* each chart can be found by clicking on the specific chart in the chart gallery.
*
* These options are immutable.
*/
export interface ChartOptions {
get(option: string): Object;
}
/**
* Chart types supported by the Charts service.
*/
export enum ChartType { AREA, BAR, COLUMN, LINE, PIE, SCATTER, TABLE }
/**
* Entry point for creating Charts in scripts.
*
* This example creates a basic data table, populates an area chart with the data, and adds it into
* a UiApp:
*
* function doGet() {
* var data = Charts.newDataTable()
* .addColumn(Charts.ColumnType.STRING, "Month")
* .addColumn(Charts.ColumnType.NUMBER, "In Store")
* .addColumn(Charts.ColumnType.NUMBER, "Online")
* .addRow(["January", 10, 1])
* .addRow(["February", 12, 1])
* .addRow(["March", 20, 2])
* .addRow(["April", 25, 3])
* .addRow(["May", 30, 4])
* .build();
*
* var chart = Charts.newAreaChart()
* .setDataTable(data)
* .setStacked()
* .setRange(0, 40)
* .setTitle("Sales per Month")
* .build();
*
* var uiApp = UiApp.createApplication().setTitle("My Chart");
* uiApp.add(chart);
* return uiApp;
* }
*/
export interface Charts {
ChartType: ChartType
ColumnType: ColumnType
CurveStyle: CurveStyle
MatchType: MatchType
Orientation: Orientation
PickerValuesLayout: PickerValuesLayout
PointStyle: PointStyle
Position: Position
newAreaChart(): AreaChartBuilder;
newBarChart(): BarChartBuilder;
newCategoryFilter(): CategoryFilterBuilder;
newColumnChart(): ColumnChartBuilder;
newDashboardPanel(): DashboardPanelBuilder;
newDataTable(): DataTableBuilder;
newDataViewDefinition(): DataViewDefinitionBuilder;
newLineChart(): LineChartBuilder;
newNumberRangeFilter(): NumberRangeFilterBuilder;
newPieChart(): PieChartBuilder;
newScatterChart(): ScatterChartBuilder;
newStringFilter(): StringFilterBuilder;
newTableChart(): TableChartBuilder;
newTextStyle(): TextStyleBuilder;
}
/**
* Builder for column charts. For more details, see the
* Google Charts documentation.
*
* This example shows how to create a column chart with data from a data table.
*
* function doGet() {
* var sampleData = Charts.newDataTable()
* .addColumn(Charts.ColumnType.STRING, "Year")
* .addColumn(Charts.ColumnType.NUMBER, "Sales")
* .addColumn(Charts.ColumnType.NUMBER, "Expenses")
* .addRow(["2004", 1000, 400])
* .addRow(["2005", 1170, 460])
* .addRow(["2006", 660, 1120])
* .addRow(["2007", 1030, 540])
* .addRow(["2008", 800, 600])
* .addRow(["2009", 943, 678])
* .addRow(["2010", 1020, 550])
* .addRow(["2011", 910, 700])
* .addRow(["2012", 1230, 840])
* .build();
*
* var chart = Charts.newColumnChart()
* .setTitle('Sales vs. Expenses')
* .setXAxisTitle('Year')
* .setYAxisTitle('Amount (USD)')
* .setDimensions(600, 500)
* .setDataTable(sampleData)
* .build();
*
* return UiApp.createApplication().add(chart);
* }
*/
export interface ColumnChartBuilder {
build(): Chart;
reverseCategories(): ColumnChartBuilder;
setBackgroundColor(cssValue: string): ColumnChartBuilder;
setColors(cssValues: String[]): ColumnChartBuilder;
setDataSourceUrl(url: string): ColumnChartBuilder;
setDataTable(tableBuilder: DataTableBuilder): ColumnChartBuilder;
setDataTable(table: DataTableSource): ColumnChartBuilder;
setDataViewDefinition(dataViewDefinition: DataViewDefinition): ColumnChartBuilder;
setDimensions(width: Integer, height: Integer): ColumnChartBuilder;
setLegendPosition(position: Position): ColumnChartBuilder;
setLegendTextStyle(textStyle: TextStyle): ColumnChartBuilder;
setOption(option: string, value: Object): ColumnChartBuilder;
setRange(start: Number, end: Number): ColumnChartBuilder;
setStacked(): ColumnChartBuilder;
setTitle(chartTitle: string): ColumnChartBuilder;
setTitleTextStyle(textStyle: TextStyle): ColumnChartBuilder;
setXAxisTextStyle(textStyle: TextStyle): ColumnChartBuilder;
setXAxisTitle(title: string): ColumnChartBuilder;
setXAxisTitleTextStyle(textStyle: TextStyle): ColumnChartBuilder;
setYAxisTextStyle(textStyle: TextStyle): ColumnChartBuilder;
setYAxisTitle(title: string): ColumnChartBuilder;
setYAxisTitleTextStyle(textStyle: TextStyle): ColumnChartBuilder;
useLogScale(): ColumnChartBuilder;
}
/**
* An enumeration of the valid data types for columns in a DataTable.
*/
export enum ColumnType { DATE, NUMBER, STRING }
/**
* A user interface control object, that drives the data displayed by a DashboardPanel.
*
* A control can be embedded in a UI application. Controls are user interface widgets (category
* pickers, range sliders, autocompleters, etc.) users interact with in order to drive the data
* managed by a dashboard and the charts that are part of it.
* Controls collect user input and use the information to decide which of the data the
* dashboard is managing should be made available to the charts that are part of it.
* Given a data table, a control will filter out the data that doesn't comply with the
* conditions implied by its current state, and will expose the filtered data table as
* an output.
*
* For more details, see the Gviz
*
* documentation.
*/
export interface Control {
getId(): string;
getType(): string;
setId(id: string): Control;
}
/**
* An enumeration of the styles for curves in a chart.
*/
export enum CurveStyle { NORMAL, SMOOTH }
/**
* A dashboard is a visual structure that enables the organization and management
* of multiple charts that share the same underlying data.
*
* Controls are user interface widgets (category pickers, range sliders, autocompleters, etc.)
* users interact with in order to drive the data managed by a dashboard and the charts that
* are part of it. For example, a string filter control is a simple text input field that lets
* the user filter data via string matching. Given a column and matching options, the control
* will filter out the rows that don't match the term that's in the input field.
*
* The Gviz API defines a dashboard as a set of charts and controls bound together. The
* bindings between the different components define the data flow, the state of the
* controls filters views of the data which propagate in the dashboard and are
* eventually visualized with charts. For more details, see the Gviz
*
* documentation.
*
* The dashboard panel has two purposes, one is being a container for the charts and
* controls objects that compose the dashboard, and the other is holding the data and use
* as an interface for binding controls to charts.
*
* Here's an example of creating a dashboard and showing it in a UI app:
*
* function doGet() {
* // Create a data table with some sample data.
* var data = Charts.newDataTable()
* .addColumn(Charts.ColumnType.STRING, "Name")
* .addColumn(Charts.ColumnType.NUMBER, "Age")
* .addRow(["Michael", 18])
* .addRow(["Elisa", 12])
* .addRow(["John", 20])
* .addRow(["Jessica", 25])
* .addRow(["Aaron", 14])
* .addRow(["Margareth", 19])
* .addRow(["Miranda", 22])
* .addRow(["May", 20])
* .build();
*
* var chart = Charts.newBarChart()
* .setTitle("Ages")
* .build();
*
* var control = Charts.newStringFilter()
* .setFilterColumnLabel("Name")
* .build();
*
* // Bind the control to the chart in a dashboard panel.
* var dashboard = Charts.newDashboardPanel()
* .setDataTable(data)
* .bind(control, chart)
* .build();
*
* var uiApp = UiApp.createApplication().setTitle("My Dashboard");
*
* var panel = uiApp.createHorizontalPanel()
* .setVerticalAlignment(UiApp.VerticalAlignment.MIDDLE)
* .setSpacing(50);
*
* panel.add(control);
* panel.add(chart);
* dashboard.add(panel);
* uiApp.add(dashboard);
* return uiApp;
* }
*/
export interface DashboardPanel {
add(widget: UI.Widget): DashboardPanel;
getId(): string;
getType(): string;
setId(id: string): DashboardPanel;
}
/**
* A builder for a dashboard panel object. For an example of how to use
* DashboardPanelBuilder, refer to DashboardPanel.
*
* For more details, see the Gviz
*
* documentation.
*/
export interface DashboardPanelBuilder {
bind(control: Control, chart: Chart, controls: Control[], charts: Chart[]): DashboardPanelBuilder;
bind(control: Control, chart: Chart, controls: Control[], charts: Chart[]): DashboardPanelBuilder;
build(): DashboardPanel;
setDataTable(tableBuilder: DataTableBuilder): DashboardPanelBuilder;
setDataTable(source: DataTableSource): DashboardPanelBuilder;
}
/**
* A Data Table to be used in charts. A DataTable can come from sources such as Google
* Sheets or specified data-table URLs, or can be filled in by hand. This class intentionally has no
* methods: a DataTable can be passed around, but not manipulated directly.
*/
export interface DataTable {
}
/**
* Builder of DataTable objects. Building a data table consists of first specifying its columns,
* and then adding its rows, one at a time. Example:
*
* var data = Charts.newDataTable()
* .addColumn(Charts.ColumnType.STRING, "Month")
* .addColumn(Charts.ColumnType.NUMBER, "In Store")
* .addColumn(Charts.ColumnType.NUMBER, "Online")
* .addRow(["January", 10, 1])
* .addRow(["February", 12, 1])
* .addRow(["March", 20, 2])
* .addRow(["April", 25, 3])
* .addRow(["May", 30, 4])
* .build();
*/
export interface DataTableBuilder {
addColumn(type: ColumnType, label: string): DataTableBuilder;
addRow(values: Object[]): DataTableBuilder;
build(): DataTable;
setValue(row: Integer, column: Integer, value: Object): DataTableBuilder;
}
/**
* Interface for objects that can represent their data as a DataTable.
* Implementing classes
*
* NameBrief description
*
* DataTableA Data Table to be used in charts.
*
* RangeAccess and modify spreadsheet ranges.
*/
export interface DataTableSource {
getDataTable(): DataTable;
}
/**
* A data view definition for visualizing chart data.
*
* Data view definition can be set for charts to visualize a view derived from the given data table
* and not the data table itself. For example if the view definition of a chart states that the view
* columns are [0, 3], only the first and the third columns of the data table will be taken into
* consideration when drawing the chart. See DataViewDefinitionBuilder for an example on how
* to define and use a DataViewDefinition.
*/
export interface DataViewDefinition {
}
/**
* Builder for DataViewDefinition objects.
*
* Here's an example of using the builder. The data is imported from a Google spreadsheet.
*
* function doGet() {
* // This example creates two table charts side by side. One uses a data view definition to
* // restrict the number of displayed columns.
* var app = UiApp.createApplication();
* // Get sample data from a spreadsheet.
* var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AF' +
* '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=4&headers=-1';
*
* // Create a chart to display all of the data.
* var originalChart = Charts.newTableChart()
* .setDimensions(600, 500)
* .setDataSourceUrl(dataSourceUrl)
* .build();
*
* // Create another chart to display a subset of the data (only columns 1 and 4).
* var dataViewDefinition = Charts.newDataViewDefinition().setColumns([0, 3]);
* var limitedChart = Charts.newTableChart()
* .setDimensions(200, 500)
* .setDataSourceUrl(dataSourceUrl)
* .setDataViewDefinition(dataViewDefinition)
* .build();
*
* var panel = app.createHorizontalPanel().setSpacing(15);
* panel.add(originalChart).add(limitedChart);
* return app.add(panel);
* }
*/
export interface DataViewDefinitionBuilder {
build(): DataViewDefinition;
setColumns(columns: Object[]): DataViewDefinitionBuilder;
}
/**
* Builder for line charts. For more details, see the
* Google Charts documentation.
*
* Here is an example that shows how to build a line chart. The data is
* imported from a Google spreadsheet.
*
* function doGet() {
* // Get sample data from a spreadsheet.
* var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AG5' +
* '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=2&headers=-1';
*
* var chartBuilder = Charts.newLineChart()
* .setTitle('Yearly Rainfall')
* .setXAxisTitle('Month')
* .setYAxisTitle('Rainfall (in)')
* .setDimensions(600, 500)
* .setCurveStyle(Charts.CurveStyle.SMOOTH)
* .setPointStyle(Charts.PointStyle.MEDIUM)
* .setDataSourceUrl(dataSourceUrl);
*
* var chart = chartBuilder.build();
* return UiApp.createApplication().add(chart);
* }
*/
export interface LineChartBuilder {
build(): Chart;
reverseCategories(): LineChartBuilder;
setBackgroundColor(cssValue: string): LineChartBuilder;
setColors(cssValues: String[]): LineChartBuilder;
setCurveStyle(style: CurveStyle): LineChartBuilder;
setDataSourceUrl(url: string): LineChartBuilder;
setDataTable(tableBuilder: DataTableBuilder): LineChartBuilder;
setDataTable(table: DataTableSource): LineChartBuilder;
setDataViewDefinition(dataViewDefinition: DataViewDefinition): LineChartBuilder;
setDimensions(width: Integer, height: Integer): LineChartBuilder;
setLegendPosition(position: Position): LineChartBuilder;
setLegendTextStyle(textStyle: TextStyle): LineChartBuilder;
setOption(option: string, value: Object): LineChartBuilder;
setPointStyle(style: PointStyle): LineChartBuilder;
setRange(start: Number, end: Number): LineChartBuilder;
setTitle(chartTitle: string): LineChartBuilder;
setTitleTextStyle(textStyle: TextStyle): LineChartBuilder;
setXAxisTextStyle(textStyle: TextStyle): LineChartBuilder;
setXAxisTitle(title: string): LineChartBuilder;
setXAxisTitleTextStyle(textStyle: TextStyle): LineChartBuilder;
setYAxisTextStyle(textStyle: TextStyle): LineChartBuilder;
setYAxisTitle(title: string): LineChartBuilder;
setYAxisTitleTextStyle(textStyle: TextStyle): LineChartBuilder;
useLogScale(): LineChartBuilder;
}
/**
* An enumeration of how a string value should be matched.
* Matching a string is a boolean operation. Given a string, a match term (string), and a match
* type, the operation will output true in the following cases:
*
* If the match type equals EXACT and the match term equals the string.
* If the match type equals PREFIX and the match term is a prefix of the string.
* If the match type equals ANY and the match term is a substring of the string.
*
* This enumeration can be used in by a string filter control to decide which rows to filter out
* of the data table. Given a column to filter on, leave only the rows that match the value
* entered in the filter input box, using one of the above matching types.
*/
export enum MatchType { EXACT, PREFIX, ANY }
/**
* A builder for number range filter controls.
*
* A number range filter is a slider with two thumbs that lets the user select ranges of
* numeric values. Given a column of type number and matching options, this control will
* filter out the rows that don't match the range that was selected.
*
* This example creates a table chart bound to a number range filter:
*
* function doGet() {
* var app = UiApp.createApplication();
* // Get sample data from a spreadsheet.
* var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AF' +
* '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=4&headers=-1';
* var data = SpreadsheetApp.openByUrl(dataSourceUrl).getSheetByName('US_GDP').getRange("A1:F");
*
* var chart = Charts.newTableChart()
* .setDimensions(600, 500)
* .build();
*
* var numberRangeFilter = Charts.newNumberRangeFilter()
* .setFilterColumnLabel("Year")
* .setShowRangeValues(true)
* .setLabel("Restrict year range")
* .build();
*
* var panel = app.createVerticalPanel().setSpacing(10);
* panel.add(numberRangeFilter).add(chart);
*
* // Create a new dashboard panel to bind the filter and chart together.
* var dashboard = Charts.newDashboardPanel()
* .setDataTable(data)
* .bind(numberRangeFilter, chart)
* .build();
*
* dashboard.add(panel);
* app.add(dashboard);
* return app;
* }
*
* documentation
*/
export interface NumberRangeFilterBuilder {
build(): Control;
setDataTable(tableBuilder: DataTableBuilder): NumberRangeFilterBuilder;
setDataTable(table: DataTableSource): NumberRangeFilterBuilder;
setFilterColumnIndex(columnIndex: Integer): NumberRangeFilterBuilder;
setFilterColumnLabel(columnLabel: string): NumberRangeFilterBuilder;
setLabel(label: string): NumberRangeFilterBuilder;
setLabelSeparator(labelSeparator: string): NumberRangeFilterBuilder;
setLabelStacking(orientation: Orientation): NumberRangeFilterBuilder;
setMaxValue(maxValue: Integer): NumberRangeFilterBuilder;
setMinValue(minValue: Integer): NumberRangeFilterBuilder;
setOrientation(orientation: Orientation): NumberRangeFilterBuilder;
setShowRangeValues(showRangeValues: boolean): NumberRangeFilterBuilder;
setTicks(ticks: Integer): NumberRangeFilterBuilder;
}
/**
* An enumeration of the orientation of an object.
*/
export enum Orientation { HORIZONTAL, VERTICAL }
/**
* An enumeration of how to display selected values in picker widget.
*/
export enum PickerValuesLayout { ASIDE, BELOW, BELOW_WRAPPING, BELOW_STACKED }
/**
* A builder for pie charts. For more details, see the
* Google Charts documentation.
*
* Here is an example that shows how to build a pie chart. The data is
* imported from a Google spreadsheet.
*
* function doGet() {
* // Get sample data from a spreadsheet.
* var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AB8' +
* '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=3&headers=-1';
*
* var chartBuilder = Charts.newPieChart()
* .setTitle('World Population by Continent')
* .setDimensions(600, 500)
* .set3D()
* .setDataSourceUrl(dataSourceUrl);
*
* var chart = chartBuilder.build();
* return UiApp.createApplication().add(chart);
* }
*/
export interface PieChartBuilder {
build(): Chart;
reverseCategories(): PieChartBuilder;
set3D(): PieChartBuilder;
setBackgroundColor(cssValue: string): PieChartBuilder;
setColors(cssValues: String[]): PieChartBuilder;
setDataSourceUrl(url: string): PieChartBuilder;
setDataTable(tableBuilder: DataTableBuilder): PieChartBuilder;
setDataTable(table: DataTableSource): PieChartBuilder;
setDataViewDefinition(dataViewDefinition: DataViewDefinition): PieChartBuilder;
setDimensions(width: Integer, height: Integer): PieChartBuilder;
setLegendPosition(position: Position): PieChartBuilder;
setLegendTextStyle(textStyle: TextStyle): PieChartBuilder;
setOption(option: string, value: Object): PieChartBuilder;
setTitle(chartTitle: string): PieChartBuilder;
setTitleTextStyle(textStyle: TextStyle): PieChartBuilder;
}
/**
* An enumeration of the styles of points in a line.
*/
export enum PointStyle { NONE, TINY, MEDIUM, LARGE, HUGE }
/**
* An enumeration of legend positions within a chart.
*/
export enum Position { TOP, RIGHT, BOTTOM, NONE }
/**
* Builder for scatter charts. For more details, see the
* Google Charts documentation.
*
* Here is an example that shows how to build a scatter chart. The data is
* imported from a Google spreadsheet.
*
* function doGet() {
* // Get sample data from a spreadsheet.
* var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=C1%3AD' +
* '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=4&headers=-1';
*
* var chartBuilder = Charts.newScatterChart()
* .setTitle('Adjusted GDP vs. U.S. Population')
* .setXAxisTitle('U.S. Population (millions)')
* .setYAxisTitle('Adjusted GDP ($ billions)')
* .setDimensions(600, 500)
* .setLegendPosition(Charts.Position.NONE)
* .setDataSourceUrl(dataSourceUrl);
*
* var chart = chartBuilder.build();
* return UiApp.createApplication().add(chart);
* }
*/
export interface ScatterChartBuilder {
build(): Chart;
setBackgroundColor(cssValue: string): ScatterChartBuilder;
setColors(cssValues: String[]): ScatterChartBuilder;
setDataSourceUrl(url: string): ScatterChartBuilder;
setDataTable(tableBuilder: DataTableBuilder): ScatterChartBuilder;
setDataTable(table: DataTableSource): ScatterChartBuilder;
setDataViewDefinition(dataViewDefinition: DataViewDefinition): ScatterChartBuilder;
setDimensions(width: Integer, height: Integer): ScatterChartBuilder;
setLegendPosition(position: Position): ScatterChartBuilder;
setLegendTextStyle(textStyle: TextStyle): ScatterChartBuilder;
setOption(option: string, value: Object): ScatterChartBuilder;
setPointStyle(style: PointStyle): ScatterChartBuilder;
setTitle(chartTitle: string): ScatterChartBuilder;
setTitleTextStyle(textStyle: TextStyle): ScatterChartBuilder;
setXAxisLogScale(): ScatterChartBuilder;
setXAxisRange(start: Number, end: Number): ScatterChartBuilder;
setXAxisTextStyle(textStyle: TextStyle): ScatterChartBuilder;
setXAxisTitle(title: string): ScatterChartBuilder;
setXAxisTitleTextStyle(textStyle: TextStyle): ScatterChartBuilder;
setYAxisLogScale(): ScatterChartBuilder;
setYAxisRange(start: Number, end: Number): ScatterChartBuilder;
setYAxisTextStyle(textStyle: TextStyle): ScatterChartBuilder;
setYAxisTitle(title: string): ScatterChartBuilder;
setYAxisTitleTextStyle(textStyle: TextStyle): ScatterChartBuilder;
}
/**
* A builder for string filter controls.
*
* A string filter is a simple text input field that lets the user filter data via string matching.
* Given a column of type string and matching options, this control will filter out the rows that
* don't match the term that's in the input field.
*
* This example creates a table chart and binds it to a string filter. Using the filter, it is
* possible to change the table chart to display a subset of its data.
*
* function doGet() {
* var app = UiApp.createApplication();
* var sampleData = Charts.newDataTable()
* .addColumn(Charts.ColumnType.STRING, "Month")
* .addColumn(Charts.ColumnType.NUMBER, "Dining")
* .addColumn(Charts.ColumnType.NUMBER, "Total")
* .addRow(["Jan", 60, 520])
* .addRow(["Feb", 50, 430])
* .addRow(["Mar", 53, 440])
* .addRow(["Apr", 70, 410])
* .addRow(["May", 80, 390])
* .addRow(["Jun", 60, 500])
* .addRow(["Jul", 100, 450])
* .addRow(["Aug", 140, 431])
* .addRow(["Sep", 75, 488])
* .addRow(["Oct", 70, 521])
* .addRow(["Nov", 58, 388])
* .addRow(["Dec", 63, 400])
* .build();
*
* var chart = Charts.newTableChart()
* .setDimensions(600, 500)
* .build();
*
* var stringFilter = Charts.newStringFilter()
* .setFilterColumnLabel("Month")
* .setRealtimeTrigger(true)
* .setCaseSensitive(true)
* .setLabel("Filter months shown")
* .build();
*
* var panel = app.createVerticalPanel().setSpacing(10);
* panel.add(stringFilter).add(chart);
*
* // Create a dashboard panel to bind the filter and the chart together.
* var dashboard = Charts.newDashboardPanel()
* .setDataTable(sampleData)
* .bind(stringFilter, chart)
* .build();
*
* dashboard.add(panel);
* app.add(dashboard);
* return app;
* }
*
* documentation
*/
export interface StringFilterBuilder {
build(): Control;
setCaseSensitive(caseSensitive: boolean): StringFilterBuilder;
setDataTable(tableBuilder: DataTableBuilder): StringFilterBuilder;
setDataTable(table: DataTableSource): StringFilterBuilder;
setFilterColumnIndex(columnIndex: Integer): StringFilterBuilder;
setFilterColumnLabel(columnLabel: string): StringFilterBuilder;
setLabel(label: string): StringFilterBuilder;
setLabelSeparator(labelSeparator: string): StringFilterBuilder;
setLabelStacking(orientation: Orientation): StringFilterBuilder;
setMatchType(matchType: MatchType): StringFilterBuilder;
setRealtimeTrigger(realtimeTrigger: boolean): StringFilterBuilder;
}
/**
* A builder for table charts. For more details, see the
* Google Charts documentation.
*
* Here is an example that shows how to build a table chart. The data is
* imported from a Google spreadsheet.
*
* function doGet() {
* // Get sample data from a spreadsheet.
* var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AF' +
* '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=4&headers=-1';
*
* var chartBuilder = Charts.newTableChart()
* .setDimensions(600, 500)
* .enablePaging(20)
* .setDataSourceUrl(dataSourceUrl);
*
* var chart = chartBuilder.build();
* return UiApp.createApplication().add(chart);
* }
*/
export interface TableChartBuilder {
build(): Chart;
enablePaging(enablePaging: boolean): TableChartBuilder;
enablePaging(pageSize: Integer): TableChartBuilder;
enablePaging(pageSize: Integer, startPage: Integer): TableChartBuilder;
enableRtlTable(rtlEnabled: boolean): TableChartBuilder;
enableSorting(enableSorting: boolean): TableChartBuilder;
setDataSourceUrl(url: string): TableChartBuilder;
setDataTable(tableBuilder: DataTableBuilder): TableChartBuilder;
setDataTable(table: DataTableSource): TableChartBuilder;
setDataViewDefinition(dataViewDefinition: DataViewDefinition): TableChartBuilder;
setDimensions(width: Integer, height: Integer): TableChartBuilder;
setFirstRowNumber(number: Integer): TableChartBuilder;
setInitialSortingAscending(column: Integer): TableChartBuilder;
setInitialSortingDescending(column: Integer): TableChartBuilder;
setOption(option: string, value: Object): TableChartBuilder;
showRowNumberColumn(showRowNumber: boolean): TableChartBuilder;
useAlternatingRowStyle(alternate: boolean): TableChartBuilder;
}
/**
* A text style configuration object. Used in charts options to configure text style for
* elements that accepts it, such as title, horizontal axis, vertical axis, legend and tooltip.
*
* // This example creates a chart specifying different text styles for the title and axes.
* function doGet() {
* var sampleData = Charts.newDataTable()
* .addColumn(Charts.ColumnType.STRING, "Seasons")
* .addColumn(Charts.ColumnType.NUMBER, "Rainy Days")
* .addRow(["Winter", 5])
* .addRow(["Spring", 12])
* .addRow(["Summer", 8])
* .addRow(["Fall", 8])
* .build();
*
* var titleTextStyleBuilder = Charts.newTextStyle()
* .setColor('#0000FF').setFontSize(26).setFontName('Ariel');
* var axisTextStyleBuilder = Charts.newTextStyle()
* .setColor('#3A3A3A').setFontSize(20).setFontName('Ariel');
* var titleTextStyle = titleTextStyleBuilder.build();
* var axisTextStyle = axisTextStyleBuilder.build();
*
* var chart = Charts.newLineChart()
* .setTitleTextStyle(titleTextStyle)
* .setXAxisTitleTextStyle(axisTextStyle)
* .setYAxisTitleTextStyle(axisTextStyle)
* .setTitle('Rainy Days Per Season')
* .setXAxisTitle('Season')
* .setYAxisTitle('Number of Rainy Days')
* .setDataTable(sampleData)
* .build();
*
* return UiApp.createApplication().add(chart);
* }
*/
export interface TextStyle {
getColor(): string;
getFontName(): string;
getFontSize(): Number;
}
/**
* A builder used to create TextStyle objects. It allows configuration of the text's
* properties such as name, color, and size.
*
* The following example shows how to create a text style using the builder. For a more complete
* example, refer to the documentation for TextStyle.
*
* // Creates a new text style that uses 26-point, blue, Ariel font.
* var textStyleBuilder = Charts.newTextStyle()
* .setColor('#0000FF').setFontName('Ariel').setFontSize(26);
* var style = textStyleBuilder.build();
*/
export interface TextStyleBuilder {
build(): TextStyle;
setColor(cssValue: string): TextStyleBuilder;
setFontName(fontName: string): TextStyleBuilder;
setFontSize(fontSize: Number): TextStyleBuilder;
}
}
}
declare var Charts: GoogleAppsScript.Charts.Charts;