@hitc/netsuite-types 2021.2.5 → 2021.2.10

package/N/crypto.d.ts

@@ -14,7 +14,7 @@ export interface CipherPayload {
   /** The result of the ciphering process. For example, to take the cipher payload and send it to another system. */
   ciphertext: string;
   /** Initialization vector for the cipher payload. You can pass in the iv value to crypto.createDecipher(options). */
-  iv: number;
+  iv: string;
 }
 
 /** Encapsulates a decipher. This object has methods that decrypt. */

package/N/dataset.d.ts

@@ -33,9 +33,9 @@ interface Condition {
 }
 
 /**
- * Encapsulates joined records used in the dataset. This object is created using the dataset.createJoin(options) method.
- * For more information on using joins in SuiteAnalytics, see Joining Records Types in a Dataset.
- */
+* Encapsulates joined records used in the dataset. This object is created using the dataset.createJoin(options) method.
+* For more information on using joins in SuiteAnalytics, see Joining Records Types in a Dataset.
+*/
 interface Join {
   readonly fieldId: string;
   readonly join: Join;
@@ -45,7 +45,12 @@ interface Join {
 
 /** Encapsulates the entire dataset, including columns, conditions, and joins. This object is created using the dataset.create(options) method. */
 export interface Dataset {
-  getExpressionFromColumn(options: { columnId: number, alias?: string }): Expression;
+  /**
+  * Returns an expression which can be used in workbook.
+  * The Help Center documentation shows alias is optional and columnId is required.
+  * Testing on version 2021.2 indicates that alias is required and columnId is optional.
+  */
+  getExpressionFromColumn(options: { alias: string, columnId?: number }): Expression;
   /** Executes the dataset and returns the result set (the same as in N/query Module). */
   run(): ResultSet;
   runPaged(): PagedData;

package/N/datasetLink.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Load the N/datasetLink module to link datasets. When you link two datasets, you can use data from both datasets in your workbooks.
+ * 
+ * The N/datasetLink module lets you logically link two datasets and use data from both datasets in your workbook visualizations (such as pivots).
+ * Linking datasets is useful when you cannot use joins in the SuiteAnalytics Workbook UI or the Workbook API to join record types explicitly.
+ * Linking datasets does not merge or join the datasets.
+ * Instead, you specify an expression (which usually represents a column that shares common data between the two datasets, such as a date), and this expression is used to link the datasets.
+ * After datasets are linked, you can access all of the data in both datasets to use in workbook visualizations.
+ * For example, when you create a pivot in a workbook, you can specify a linked dataset (as a datasetLink.DatasetLink object) to use as the data source for the pivot.
+ * You can use fields in both datasets to create data dimensions, data measures, sections, and other elements of the pivot.
+ * 
+ * For more information about linking datasets in SuiteAnalytics Workbook, see Dataset Linking in SuiteAnalytics Workbook.
+ */
+import { Dataset } from "./dataset";
+import { Expression } from "./workbook";
+
+
+interface CreateDatasetLinkOptions {
+    /**
+     * The datasets to link.
+     */
+    datasets: Dataset[];
+    /**
+     * The column expressions to use to link the datasets.
+     */
+    expressions: Array<Expression[]>;
+    /**
+     * The ID of the linked dataset.
+     * The Help Center indicates this is optional, but testing on 2021.2 indicates it is required.
+     */
+    id: string;
+}
+
+/** A representation of two datasets that are linked using datasetLink.create(options). */
+interface DatasetLink {
+    /**
+     * The linked datasets that the datasetLink.DatasetLink object represents.
+     */
+    datasets: Dataset[];
+    /**
+     * The column expressions for the datasetLink.DatasetLink object.
+     */
+    expressions: Array<Expression[]>;
+    id: string;
+}
+
+/**
+ * Links two datasets using a common column expression.
+ * To link two datasets, both datasets must include a column that shares common data, such as a date.
+ * You use Dataset.getExpressionFromColumn(options) to obtain expressions for each column, then you specify these expressions (and the datasets they are part of) when you call datasetLink.create(options).
+ * @throws {SuiteScriptError} NO_DATASET_DEFINED if the value of the options.datasets parameter is an empty array.
+ */
+export function create(option: CreateDatasetLinkOptions): DatasetLink
+ 

package/N/query.d.ts

@@ -313,7 +313,7 @@ export interface Query {
      * Create a Column object based on the root component of the Query. This is a shortcut for Query.root.createColumn.
      * @see Component.createColumn
      */
-    createColumn(options: CreateColumnOptions): Column;
+    createColumn(options: CreateColumnOptions | CreateColumnWithFormulaOptions): Column;
 
     /**
      * Create a Sort object based on the root component of the Query. This is a shortcut for Query.root.createSort.

package/N/record.d.ts

@@ -238,7 +238,7 @@ interface SetCurrentSublistTextOptions {
     forceSyncSourcing?: boolean
 }
 
-interface SetValueOptions {
+export interface SetValueOptions {
     /** The internal ID of a standard or custom body field. */
     fieldId: string;
     /**

package/N/sftp.d.ts

@@ -71,15 +71,19 @@ interface CreateSFTPConnectionWithKeyOptions extends CreateSFTPConnectionOptions
     /** The Key ID for the private key file uploaded to NetSuite */
     keyId: string;
 }
+interface CreateSFTPConnectionWithSecretOptions extends CreateSFTPConnectionOptions {
+    /** The script ID of the secret used for authentication. Secrets are stored at Setup > Company > API Secrets. Since 2021.1. */
+    secret: string;
+}
 
-/** 
+/**
  * Establishes a connection to a remote FTP server.
  * To generate the passwordguid, you can create a suitelet that uses Form.addCredentialField(options).
  * Use the N/https Module to fetch the GUID value returned from the Suitelet's credential field.
  * For a Suitelet example, see N/https Module Script Sample.
  * For more information about supported SFTP protocol, see Supported Cipher Suites and Host Key Types
  */
-export function createConnection(options: CreateSFTPConnectionWithKeyOptions | CreateSFTPConnectionWithPasswordOptions): Connection;
+export function createConnection(options: CreateSFTPConnectionWithKeyOptions | CreateSFTPConnectionWithPasswordOptions | CreateSFTPConnectionWithSecretOptions): Connection;
 
 export enum Sort {
     DATE,

package/N/types.d.ts

@@ -3,9 +3,11 @@ import * as N_portlet from './portlet';
 import * as N_record from './record';
 import * as N_search from './search';
 import * as N_ui_serverWidget from './ui/serverWidget';
-import * as N_FiConnectivity from "./plugins/fiConnectivityPlugin"
-import * as N_FiParser from "./plugins/fiParserPlugin"
-
+import * as N_FiConnectivity from "./plugins/fiConnectivityPlugin";
+import * as N_FiParser from "./plugins/fiParserPlugin";
+import * as N_dataset from "./dataset";
+import * as N_workbook from "./workbook";
+ 
 /*Don't export these into the Namespace as we don't
 want to accidentally use a comparison like this:
 export var beforeSubmit: EntryPoints.UserEvent.beforeSubmit = (ctx) => {
@@ -466,6 +468,30 @@ export namespace EntryPoints {
             type getAccounts = N_FiConnectivity.getAccounts;
             type getConfigurationIFrameUrl = N_FiConnectivity.getConfigurationIFrameUrl;
         }
+
+        namespace DatasetBuilder {
+            interface createDatasetContext {
+                dataset: N_dataset.Dataset;
+                readonly description: string;
+                readonly name: string;
+                readonly owner: number;
+                readonly role: number;
+            }
+    
+            type createDataset = (scriptContext: createDatasetContext) => void;
+        }
+
+        namespace WorkbookBuilder {
+            interface createWorkbookContext {
+                workbook: N_workbook.Workbook;
+                readonly description: string;
+                readonly name: string;
+                readonly owner: number;
+                readonly role: number;
+            }
+
+            type createWorkbook = (scriptContext: createWorkbookContext) => void;
+        }
     }
 }
 

package/N/workbook.d.ts

@@ -1,13 +1,19 @@
 /** Load the N/workbook module when you want to create a new workbook, load an existing workbook, or list all existing workbooks. */
 
-import { Dataset } from "./dataset";
-import {SortLocale} from "N/query";
+import { Dataset } from "N/dataset";
+import { PagedData, ResultSet, SortLocale } from "N/query";
+import { DatasetLink } from "N/datasetLink";
 
 interface Aspect {
   measure: Measure;
   type: AspectType;
 }
 
+interface CalculatedMeasure {
+  expression: Expression;
+  label: string | Expression;
+}
+
 interface Category {
   axis: ChartAxis;
   /** The root data (i.e., fields) that defines the category. */
@@ -53,6 +59,17 @@ interface ChartDefinition {
   chartType: ChartType;
 }
 
+/**
+ * A color, which is made up of red, green, blue, and alpha components.
+ * Object is called `Color` in documentation, used different name here to avoid naming collision with `Color` enum.
+ */
+interface ColorRGBA {
+  alpha: number;
+  blue: number;
+  green: number;
+  red: number;
+}
+
 /**
  * A conditional filter.
  * A conditional filter can be used when you create a pivot definition or a chart definition.
@@ -71,6 +88,22 @@ interface ConditionalFilter {
   row: boolean;
 }
 
+interface ConditionalFormat {
+  rules: ConditionalFormatRule[];
+}
+
+interface ConditionalFormatRule {
+  /** The filter that determines which rows or cells to apply the conditional format to. */
+  filter: TableColumnFilter;
+  style: Style;
+}
+
+interface Currency {
+  amount: number;
+  /** The ID of the currency (for example, USD, EUR, GBP, and so on). */
+  id: string;
+}
+
 /**
  * A data dimension. A data dimension can be used when you create a category, a legend, a pivot axis, a dimension selector, or a section.
  * You can create a data dimension using workbook.createDataDimension(options).
@@ -95,6 +128,25 @@ interface DataDimensionItem {
    label: string;
 }
 
+interface DataDimensionItemValue {
+  item: DataDimensionItem;
+  value: string | number | boolean | Record | Currency | Range | Duration;
+}
+
+interface DataDimensionValue {
+  dataDimension: DataDimension;
+  itemValues: DataDimensionItemValue[];
+}
+
+interface DataMeasure {
+  aggregation: string;
+  /** This property is used if the data measure is a single-expression measure. */
+  expression: Expression;
+  /** This property is used if the data measure is a multiple-expression measure. */
+  expressions: Expression[];
+  label: string;
+}
+
 /**
  * A dimension selector. A dimension selector is used when you create a path selector, a sort definition, a conditional filter, a limiting filter or a measure sort.
  * You can create a dimension selector using workbook.createDimensionSelector(options).
@@ -115,6 +167,11 @@ interface DimensionSort {
   sort: Sort;
 }
 
+interface Duration {
+  amount: number;
+  units: unknown;
+}
+
 /**
  * An expression. An expression can be used when you create a pivot definition, a chart definition, a data dimension item, a measure, a conditional filter, or a constant.
  * You can create an expression using workbook.createExpression(options).
@@ -137,6 +194,15 @@ interface FieldContext {
   parameters: Object;
 }
 
+/**
+ * A font size.
+ * Object is called `FontSize` in documentation, used different name here to avoid naming collision with `FontSize` enum.
+ */
+interface FontSizeObj {
+  size: number;
+  unit: string;
+}
+
 /**
  * A legend. A legend can be used when you create a chart definition.
  * You can create a legend using workbook.createLegend(options).
@@ -180,6 +246,10 @@ interface Measure {
   label: string;
 }
 
+interface MeasureSelector {
+  measures: CalculatedMeasure[] | DataMeasure;
+}
+
 /**
  * A measure sort. A measure sort can be used when you create a limiting filter or a sort definition.
  * You can create a measure sort using workbook.createMeasureSort(options).
@@ -193,6 +263,17 @@ interface MeasureSort {
   sort: Sort;
 }
 
+interface MeasureValue {
+  measure: Measure;
+  value: string | number | boolean | Record | Currency | Range | Duration;
+}
+
+interface MeasureValueSelector {
+  columnSelector: DimensionSelector | PathSelector;
+  measureSelector: MeasureSelector[];
+  rowSelector: DimensionSelector | PathSelector;
+}
+
 /**
  * A path selector. A path selector can be used when you create a sort definition, a conditional filter, a limiting filter, or a measure sort.
  * You can create a path selector using workbook.createPathSelector(options).
@@ -211,6 +292,73 @@ interface PivotAxis {
   /** The sort definitions of the pivot axis. */
   sortDefinitions: SortDefinition
 }
+
+/**
+ * A pivot is a workbook component that enables you to pivot your dataset query results by defining measures and dimensions, so that you can analyze different subsets of data.
+ * You can create a pivot using workbook.createPivot(options).
+ */
+interface Pivot {
+  aggregationFilters: (ConditionalFilter|LimitingFilter)[];
+  columnAxis: PivotAxis;
+  dataset: Dataset;
+  filterExpressions: Expression[];
+  id: string;
+  name: string;
+  rowAxis: PivotAxis;
+}
+
+interface PivotIntersection {
+  column: DataDimensionValue | SectionValue;
+  measureValues: MeasureValue[];
+  row: DataDimensionValue | SectionValue;
+}
+
+interface PositionPercent {
+  percentX: number;
+  percentY: number;
+}
+
+interface PositionUnits {
+  unit: string;
+  x: number;
+  y: number;
+}
+
+interface PositionValues {
+  horizontal: string;
+  vertical: string;
+}
+
+/**
+ * A date or date-time range.
+ * The dates in the range are formatted according to the user’s preferences in their account. This object can be returned from a pivot execution.
+ */
+interface Range {
+  end: string;
+  start: string;
+}
+
+interface Record {
+  name: string;
+  primaryKey: number;
+  properties: unknown;
+}
+
+interface RecordKey {
+  properties: unknown
+}
+
+interface ReportStyle {
+  rules: ReportStyleRule[];
+  selectors: MeasureValueSelector[];
+}
+
+interface ReportStyleRule {
+  /** A Boolean expression indicating whether the style should be applied. */
+  expression: Expression;
+  style: Style;
+}
+
 /**
  * A section. A section can be used when you create a category, a legend, a data dimension, a dimension selector, a pivot axis, or a pivot definition.
  * You can create a section using workbook.createSection(options).
@@ -222,6 +370,10 @@ interface Section {
   totalLine: TotalLine;
 }
 
+interface SectionValue {
+  section: Section;
+}
+
 /**
  * A series in a workbook. A series is used when you create a chart definition.
  * You can create a series using workbook.createSeries(options).
@@ -257,6 +409,31 @@ interface SortDefinition {
   sortBys: DimensionSelector|MeasureSort[];
 }
 
+interface SortByDataDimensionItem {
+  item: DataDimensionItem;
+  sort: Sort;
+}
+
+interface SortByMeasure {
+  measure: CalculatedMeasure | DataMeasure;
+  otherAxisSelector: PathSelector | DimensionSelector;
+  sort: Sort;
+}
+
+interface Style {
+  backgroundColor: string | Color | ColorRGBA;
+  backgroundImage: string;
+  backgroundPosition: PositionPercent | PositionUnits | PositionValues;
+  color: string | ColorRGBA;
+  fontSize: string | FontSizeObj;
+  fontStyle: string;
+  fontWeight: string;
+  textAlign: string;
+  textDecorationColor: string | Color | ColorRGBA;
+  textDecorationLine: string;
+  textDecorationStyle: string;
+}
+
 /**
  * A table column. A table column is used when you create a table definition.
  * You can create a table column using workbook.createTableColumn(options).
@@ -271,7 +448,7 @@ interface TableColumn {
   /** The field context specification for the field used in the table column. */
   fieldContext: FieldContext;
   /** The filters for the table column. */
-  filters: TableFilter[];
+  filters: TableColumnFilter[];
   /** The label of table column. */
   label: string;
   /** The sort of the table column. */
@@ -299,7 +476,7 @@ interface TableDefinition {
  * A table filter. A table filter can be used when you create a table column.
  * You can create a table filter using workbook.createTableFilter(options).
  * */
-interface TableFilter {
+interface TableColumnFilter {
   /** The operator of the table filter. */
   operator: Operator;
   /** The values of the table filter. */
@@ -313,10 +490,11 @@ interface TableFilter {
  * A workbook can include tables, pivots, and charts. A workbook is created using workbook.create(options).
  */
 export interface Workbook {
+  runPivot(options: RunPivot): PivotIntersection[];
   /** Executes the table and returns the result set (the same as in N/query Module). */
-  runTable(options: RunTable): Workbook;
+  runTable(options: RunTable): ResultSet;
   /** Executes the table and returns paginated data (the same as in N/query Module). */
-  runTablePaged(options: RunTablePaged): Workbook;
+  runTablePaged(options: RunTablePaged): PagedData;
   /** Chart definitions that can be included in a workbook when you create a new workbook. */
   chartDefinitions: ChartDefinition;
   /** The description of the workbook. This is set when you create a workbook. */
@@ -326,20 +504,9 @@ export interface Workbook {
   /** The name of the workbook. */
   name: string;
   /** Pivot definitions that can be included in a workbook when you create a new workbook. */
-  pivotDefinitions: PivotDefinition[];
+  pivots: Pivot[];
   /** *Table definitions that can be included in a workbook when you create a new workbook. */
-  tableDefinitions: TableDefinition[];
-}
-
-/**
- * An expression. An expression can be used when you create a pivot definition, a chart definition, a data dimension item, a measure, a conditional filter, or a constant.
- * You can create an expression using workbook.createExpression(options).
- */
-interface Expression {
-  /** The ID of the function used in the expression. */
-  functionId: ExpressionType
-  /** The parameters for the expression. */
-  parameters: Object;
+  tables: TableDefinition[];
 }
 
 /**
@@ -350,21 +517,11 @@ interface AllSubNodesSelector {
   // TODO Update this as it is empty with NS Help
 }
 
-interface PivotDefinition {
-  aggregationFilters: (ConditionalFilter|LimitingFilter)[];
-  columnAxis: PivotAxis;
-  dataset: Dataset;
-  filterExpressions: Expression[];
-  id: string;
-  name: string;
-  rowAxis: PivotAxis;
-}
-
 interface CreateOptions {
   chartDefinition?: ChartDefinition[];
   description?: string;
   name?: string;
-  pivotDefinitions?: PivotDefinition[];
+  pivots?: Pivot[];
   tableDefinitions?: TableDefinition[];
 }
 
@@ -373,6 +530,14 @@ interface CreateAspectOptions {
   type?: AspectType;
 }
 
+interface CreateCalculatedMeasure {
+  expression: Expression;
+  label?: string | Expression;
+  name?: string;
+  pivotDefinitions?: Pivot[];
+  tableDefinitions?: TableDefinition[];
+}
+
 interface CreateCategoryOptions {
   axis: ChartAxis;
   root: DataDimension|Section;
@@ -398,6 +563,13 @@ interface CreateChartDefinition {
   type: ChartType;
 }
 
+interface CreateColor {
+  alpha?: number;
+  blue?: number;
+  green?: number;
+  red?: number;
+}
+
 interface CreateConditionalFilter {
   filteredNodesSelector: AllSubNodesSelector|DimensionSelector|PathSelector;
   measure: Measure;
@@ -406,6 +578,15 @@ interface CreateConditionalFilter {
   row: boolean;
 }
 
+interface CreateConditionalFormat {
+  rules: ConditionalFormatRule[];
+}
+
+interface CreateConditionalFormatRule {
+  filter: TableColumnFilter;
+  style: Style;
+}
+
 interface CreateConstant {
   constant: string|number|boolean|Date;
   tye?: ConstantType;
@@ -413,7 +594,7 @@ interface CreateConstant {
 
 interface CreateDataDimension {
   children?: (DataDimension|Section|Measure)[];
-  items: DataDimensionItem;
+  items: DataDimensionItem[];
   totalLine?: string;
 }
 
@@ -422,6 +603,13 @@ interface CreateDataDimensionItem {
   label?: string;
 }
 
+interface CreateDataMeasure {
+  aggregation: string;
+  expression?: Expression;
+  expressions?: Expression[];
+  label: string;
+}
+
 interface CreateDimensionSelector {
   dimension: DataDimension|Section;
 }
@@ -441,6 +629,11 @@ interface CreateFieldContext {
   parameters?: Object;
 }
 
+interface CreateFontSize {
+  size: number;
+  unit: string;
+}
+
 interface CreateLegend {
   axes: ChartAxis[];
   root: Section|DataDimension;
@@ -456,11 +649,15 @@ interface CreateLimitingFilter {
 
 interface CreateMeasure {
   aggregation?: string;
-  expression: Expression;
-  expressions: Expression[];
+  expression?: Expression;
+  expressions?: Expression[];
   label: string;
 }
 
+interface CreateMeasureSelector {
+  measures: (CalculatedMeasure | DataMeasure)[];
+}
+
 interface CreateMeasureSort {
   measure: Measure;
   otherAxisSelector: AllSubNodesSelector|DimensionSelector|PathSelector;
@@ -468,6 +665,12 @@ interface CreateMeasureSort {
   sort: Sort;
 }
 
+interface CreateMeasureValueSelector {
+  columnSelector: DimensionSelector | PathSelector;
+  measureSelector: MeasureSelector;
+  rowSelector: DimensionSelector | PathSelector;
+}
+
 interface CreatePathSelector {
   elements: (AllSubNodesSelector|DimensionSelector)[];
 }
@@ -480,15 +683,42 @@ interface CreatePivotAxis {
 interface CreatePivotDefinition {
   aggregationFilters?: (ConditionalFilter|LimitingFilter)[];
   columnAxis: PivotAxis;
-  dataset: Dataset;
+  dataset?: Dataset;
   filterExpressions?: Expression[];
   id: string;
   name: string;
   rowAxis: PivotAxis;
+  datasetLink?: DatasetLink;
+}
+
+interface CreatePositionPercent {
+  percentX: number;
+  percentY: number;
+}
+
+interface CreatePositionUnits {
+  unit: string;
+  x: number;
+  y: number;
+}
+
+interface CreatePositionValues {
+  horizontal: string;
+  vertical: string;
+}
+
+interface CreateReportStyle {
+  rules: ReportStyleRule[];
+  selectors: MeasureValueSelector[];
+}
+
+interface CreateReportStyleRule {
+  expression: Expression;
+  style: Style;
 }
 
 interface CreateSection {
-  children: (DataDimension|Measure|Section)[];
+  children: (DataDimension|Measure|Section|DataMeasure)[];
   totalLine?: TotalLine;
 }
 
@@ -503,17 +733,43 @@ interface CreateSort {
   nullsLast?: boolean;
 }
 
+interface CreateSortByDataDimensionItem {
+  item: DataDimensionItem;
+  sort: Sort;
+}
+
+interface CreateSortByMeasure {
+  measure: Measure;
+  otherAxisSelector: (DimensionSelector | PathSelector)[];
+  selector: (DimensionSelector | PathSelector)[];
+  sort: Sort;
+}
+
 interface CreateSortDefinition {
   selector: AllSubNodesSelector|DimensionSelector|PathSelector;
   sortBys: (DimensionSort|MeasureSort)[];
 }
 
+interface CreateStyle {
+  backgroundColor?: Color | string;
+  backgroundImage?: string;
+  backgroundPosition?: PositionPercent | PositionUnits | PositionValues;
+  color?: Color | string;
+  fontSize?: string;
+  fontStyle?: string;
+  fontWeight?: string;
+  textAlign?: string;
+  textDecorationColor?: Color | string;
+  textDecorationLine?: string;
+  textDecorationStyle?: string;
+}
+
 interface CreateTableColumn {
   alias?: string;
   datasetColumnAlias: string;
   datasetColumnId: number;
   fieldContext?: FieldContext;
-  filters?: TableFilter;
+  filters?: TableColumnFilter;
   label?: string;
   sort: Sort;
   width?: number;
@@ -526,7 +782,7 @@ interface CreateTableDefinition {
   name: string;
 }
 
-interface CreateTableFilter {
+interface CreateTableColumnFilter {
   operator: string;
   values?: (null|Object|number|string|boolean|Date)[];
 }
@@ -544,6 +800,10 @@ interface RunTablePaged {
   pageSize?: number;
 }
 
+interface RunPivot {
+  id: string;
+}
+
 /**
  * Creates a new workbook. Workbooks are where you analyze the results of your dataset queries using different components, such as table views, pivot tables, and charts.
  * All workbooks are based on a dataset, and a single dataset can be used as the basis for multiple workbooks.
@@ -559,17 +819,22 @@ export function createAllSubNodesSelector(): AllSubNodesSelector;
 /**
  * Creates an aspect for a chart series. An aspect includes a measure and an aspect type.
  */
-export function createAspect(options: CreateAspectOptions): Workbook;
+export function createAspect(options: CreateAspectOptions): Aspect;
+
+/**
+ * Creates a calculated measure.
+ */
+export function createCalculatedMeasure(options: CreateCalculatedMeasure): CalculatedMeasure;
 
 /**
  * Creates a chart category, which includes an axis, a data root, and a sort definition. A chart category is used in a workbook.ChartDefinition.
  */
-export function createCategory(options: CreateCategoryOptions): Workbook;
+export function createCategory(options: CreateCategoryOptions): Category;
 
 /**
  * Creates an X-axis or a Y-axis for the chart.
  */
-export function createChartAxis(options: CreateChartAxis): Workbook;
+export function createChartAxis(options: CreateChartAxis): ChartAxis;
 
 /**
  * Creates a chart definition.
@@ -579,125 +844,200 @@ export function createChartAxis(options: CreateChartAxis): Workbook;
  */
 export function createChartDefinition(options: CreateChartDefinition): Workbook;
 
+/**
+ * Creates a color.
+ */
+export function createColor(options: CreateColor): ColorRGBA;
+
 /**
  * Creates a conditional filter, which includes a selector of what to filter, a row axis and other axis, a measure and a predicate.
  * Conditional filters can be used in pivot definitions and chart definitions.
  */
-export function createConditionalFilter(options: CreateConditionalFilter): Workbook;
+export function createConditionalFilter(options: CreateConditionalFilter): ConditionalFilter;
+
+/**
+ * Creates a conditional format.
+ */
+export function createConditionalFormat(options: CreateConditionalFormat): ConditionalFormat;
+
+/**
+ * Creates a conditional format rule.
+ */
+export function createConditionalFormatRule(options: CreateConditionalFormatRule): ConditionalFormatRule;
 
 /**
  * Creates a constant expression.
  */
-export function createConstant(options: CreateConstant): Workbook;
+export function createConstant(options: CreateConstant): Expression;
 
 /**
  * Creates a data dimension, which includes items, child data items, and a total line.
  * A data dimension is used in a workbook.Category, a workbook.Legend a workbook.PivotAxis, a workbook.DimensionSelector, and a workbook.Section.
  */
-export function createDataDimension(options: CreateDataDimension): Workbook;
+export function createDataDimension(options: CreateDataDimension): DataDimension;
 
 /**
  * Creates a data dimension item, which includes an expression and a label.
  */
-export function createDataDimensionItem(options: CreateDataDimensionItem): Workbook;
+export function createDataDimensionItem(options: CreateDataDimensionItem): DataDimensionItem;
+
+/**
+ * Creates a data measure.
+ */
+export function createDataMeasure(options: CreateDataMeasure): DataMeasure;
 
 /**
  * Creates a dimension selector.
  */
-export function createDimensionSelector(options: CreateDimensionSelector): Workbook;
+export function createDimensionSelector(options: CreateDimensionSelector): DimensionSelector;
 
 /**
  * Creates a dimension sort.
  */
-export function createDimensionSort(options: CreateDimensionSort): Workbook;
+export function createDimensionSort(options: CreateDimensionSort): DimensionSort;
 
 /**
  * Creates an expression, that includes a function ID and parameters.
  * Expressions can be used to create a pivot definition, a chart definition, a data dimension item, a measure, a conditional filter, and a dimension sort.
  */
-export function createExpression(options: CreateExpression): Workbook;
+export function createExpression(options: CreateExpression): Expression;
 
 /**
  * Creates a field context for a table definition column.
  */
-export function createFieldContext(options: CreateFieldContext): Workbook;
+export function createFieldContext(options: CreateFieldContext): FieldContext;
+
+/**
+ * Creates a font size defined using units.
+ */
+export function createFontSize(options: CreateFontSize): FontSizeObj;
 
 /**
  * Creates a chart legend.
  */
-export function createLegend(options: CreateLegend): Workbook;
+export function createLegend(options: CreateLegend): Legend;
 
 /**
  * Creates a limiting filter, which includes a selector of what to filter, a row axis, a limit, and a sorting order.
  * Limiting filters can be used in pivot definitions and chart definitions to limit the data shown on a pivot or chart.
  */
-export function createLimitingFilter(options: CreateLimitingFilter): Workbook;
+export function createLimitingFilter(options: CreateLimitingFilter): LimitingFilter;
 
 /**
  * Creates a measure, which includes an aggregation, a label, and one or more expressions.
  */
-export function createMeasure(options: CreateMeasure): Workbook;
+export function createMeasure(options: CreateMeasure): Measure;
+
+/**
+ * Creates a measure selector.
+ */
+export function createMeasureSelector(options: CreateMeasureSelector): MeasureSelector;
 
 /**
  * Creates a measure sort, which defines a sort on a measure.
  */
-export function createMeasureSort(options: CreateMeasureSort): Workbook;
+export function createMeasureSort(options: CreateMeasureSort): MeasureSort;
+
+/**
+ * Creates a measure value selector.
+ */
+export function createMeasureValueSelector(options: CreateMeasureValueSelector): MeasureValueSelector;
 
 /**
  * Creates a path selector.
  */
-export function createPathSelector(options: CreatePathSelector): Workbook;
+export function createPathSelector(options: CreatePathSelector): PathSelector;
 
 /**
  * Creates a pivot axis, which includes a data root and a sort definition.
  */
-export function createPivotAxis(options: CreatePivotAxis): Workbook;
+export function createPivotAxis(options: CreatePivotAxis): PivotAxis;
 
 /**
  * Creates a pivot definition.
  * A pivot is a workbook component that enables you to pivot your dataset query results by defining measures and dimensions, so that you can analyze different subsets of data.
  * A pivot definition is based on an underlying dataset and can include an ID, a name, a row axis, a column axis, conditional/limiting filters, and filter expressions.
  */
-export function createPivotDefinition(options: CreatePivotDefinition): Workbook;
+export function createPivot(options: CreatePivotDefinition): Pivot;
+
+/**
+ * Creates a percent-defined background position.
+ */
+export function createPositionPercent(options: CreatePositionPercent): PositionPercent;
+
+/**
+ * Creates a background position defined using x-y coordinates and units.
+ */
+export function createPositionUnits(options: CreatePositionUnits): PositionUnits;
+
+/**
+ * Creates a background position defined using position values.
+ */
+export function createPositionValues(options: CreatePositionValues): PositionValues;
+
+/**
+ * Creates a report style.
+ */
+export function createReportStyle(options: CreateReportStyle): ReportStyle;
+
+/**
+ * Creates a report style formatting rule.
+ */
+export function createReportStyleRule(options: CreateReportStyleRule): ReportStyleRule;
 
 /**
  * Creates a section, which includes children and a total line.
  */
-export function createSection(options: CreateSection): Workbook;
+export function createSection(options: CreateSection): Section;
 
 /**
  * Creates a chart series, which is a set of aspects.
  */
-export function createSeries(options: CreateSeries): Workbook;
+export function createSeries(options: CreateSeries): Series;
 
 /**
  * Creates a sort, which includes indicators for sorting in ascending order, case sensitivity, sort locale, and whether nulls should be placed last.
  */
-export function createSort(options: CreateSort): Workbook;
+export function createSort(options: CreateSort): Sort;
+
+/**
+ * Creates a sort based on data dimension items.
+ */
+export function createSortByDataDimensionItem(options: CreateSortByDataDimensionItem): SortByDataDimensionItem;
+
+/**
+ * Creates a sort based on a measure.
+ */
+export function createSortByMeasure(options: CreateSortByMeasure): SortByMeasure;
 
 /**
  * Creates a sort definition.
  * A sort definition is used to specify sorting for a category, legend, pivot definition, or pivot axis.
  */
-export function createSortDefinition(options: CreateSortDefinition): Workbook;
+export function createSortDefinition(options: CreateSortDefinition): SortDefinition;
+
+/**
+ * Creates a style to be used for conditional formatting.
+ */
+export function createStyle(options: CreateStyle): Style;
 
 /**
  * Creates a table column.
  * Table columns are used in table definitions, and include an alias, dataset column alias/ID, filters, a label, sorts, and a column width.
  */
-export function createTableColumn(options: CreateTableColumn): Workbook;
+export function createTableColumn(options: CreateTableColumn): TableColumn;
 
 /**
  * Creates a table.
  * A table is a workbook component that enables you to view your dataset query results in a simple table.
  * A table is based on an underlying dataset and can include an ID, a name, a dataset, and table columns,
  */
-export function createTableDefinition(options: CreateTableDefinition): Workbook;
+export function createTableDefinition(options: CreateTableDefinition): TableDefinition;
 
 /**
  * Creates a table filter, which includes an operator and values.
  */
-export function createTableFilter(options: CreateTableFilter): Workbook;
+export function createTableColumnFilter(options: CreateTableColumnFilter): TableColumnFilter;
 
 /**
  * Lists all existing workbooks.
@@ -723,6 +1063,20 @@ declare enum AspectType {
   VALUE = 'value'
 }
 
+declare enum Color {
+  BLACK,
+  BLUE,
+  BROWN,
+  GRAY,
+  GREEN,
+  ORANGE,
+  PINK,
+  PURPLE,
+  RED,
+  WHITE,
+  YELLOW
+}
+
 declare enum ChartType {
   AREA,
   BAR,
@@ -781,12 +1135,99 @@ declare enum ExpressionType {
   TRUNCATE_DATE_TIME
 }
 
+declare enum FontSize {
+  LARGE,
+  LARGER,
+  MEDIUM,
+  SMALL,
+  SMALLER,
+  XX_LARGE,
+  XX_SMALL,
+  X_LARGE,
+  X_SMALL
+}
+
+declare enum FontStyle {
+  ITALIC,
+  NORMAL,
+  OBLIQUE,
+}
+
+declare enum FontWeight {
+  BOLD,
+  NORMAL
+}
+
+declare enum Image {
+  EXCLAMATION,
+  QUESTION,
+  SMILE
+}
+
+declare enum Position {
+  BOTTOM,
+  CENTER,
+  LEFT,
+  RIGHT,
+  TOP
+}
+
 declare enum Stacking {
   DISABLED,
   NORMAL,
   PERCENT
 }
 
+declare enum TemporalUnit {
+  HOURS,
+  MINUTES
+}
+
+declare enum TextAlign {
+  CENTER,
+  JUSTIFY,
+  LEFT,
+  RIGHT
+}
+
+declare enum TextDecorationLine {
+  LINE_THROUGH,
+  NONE,
+  OVERLINE,
+  UNDERLINE
+}
+
+declare enum TextDecorationStyle {
+  DASHED,
+  DOTTED,
+  DOUBLE,
+  SOLID,
+  WAVY
+}
+
+declare enum TotalLine {
+  FIRST_LINE,
+  HIDDEN,
+  LAST_LINE
+}
+
+declare enum Unit {
+  CH,
+  CM,
+  EM,
+  EX,
+  IN,
+  MM,
+  PC,
+  PT,
+  PX,
+  REM,
+  VH,
+  VMAX,
+  VMIN,
+  VW
+}
+
 declare enum Operator {
   AFTER                 = 'AFTER',
   AFTER_NOT	            =	'AFTER_NOT',
@@ -830,10 +1271,4 @@ declare enum Operator {
   START_WITH_NOT	      =	'START_WITH_NOT',
   WITHIN	              =	'WITHIN',
   WITHIN_NOT	          =	'WITHIN_NOT'
-}
-
-declare enum TotalLine {
-  FIRST_LINE,
-  HIDDEN,
-  LAST_LINE
 }

package/package.json

@@ -8,7 +8,7 @@
     "posttest": "npm run cleanup"
   },
   "homepage": "https://github.com/headintheclouddev/typings-suitescript-2.0",
-  "version": "2021.2.5",
+  "version": "2021.2.10",
   "main": "index.d.ts",
   "author": "Head in the Cloud Development <gurus@headintheclouddev.com> (www.headintheclouddev.com)",
   "license": "MIT",

package/DatasetBuilderPlugin.d.ts

@@ -1,10 +0,0 @@
-import {Dataset} from "N/dataset";
-
-/** Context object for the main createDataset() plugin interface function. */
-interface CreateDatasetContext {
-  dataset: Dataset;
-  readonly description: string
-  readonly name: string;
-  readonly owner: number;
-  readonly role: number;
-}

package/WorkbookBuilderPlugin.d.ts

@@ -1,9 +0,0 @@
-import {Workbook} from "N/workbook";
-
-interface CreateWorkbookContext {
-  readonly description: string;
-  readonly name: string;
-  readonly owner: number;
-  readonly role: number;
-  workbook: Workbook;
-}